{"version":3,"file":"VectorControl-CiXVbIqz.cjs","names":[],"sources":["../src/lib/ui/dom.ts","../src/lib/ui/layerPicker.ts","../src/lib/formats/detect.ts","../src/lib/utils/geometry.ts","../src/lib/formats/geojsonSniff.ts","../node_modules/fflate/esm/browser.js","../src/lib/formats/kmzMetadata.ts","../src/lib/render/renderMode.ts","../src/lib/render/styleBuilder.ts","../src/lib/render/mapSources.ts","../src/lib/utils/maplibre.ts","../src/lib/tiles/protocol.ts","../src/lib/utils/fit.ts","../src/lib/utils/helpers.ts","../src/lib/utils/remote.ts","../src/lib/core/LayerManager.ts","../src/lib/engine/sql.ts","../src/lib/engine/duckdbLoader.ts","../src/lib/engine/gpkgOgrContents.ts","../src/lib/engine/geopackage.ts","../src/lib/engine/geojsonBytes.ts","../src/lib/tiles/mvtFallback.ts","../src/lib/formats/shapefile.ts","../src/lib/formats/kmz.ts","../src/lib/formats/geoparquetCrs.ts","../src/lib/engine/surfaceWkb.ts","../src/lib/engine/DuckDBEngine.ts","../src/lib/ui/styleEditor.ts","../src/lib/ui/layerListItem.ts","../src/lib/ui/panel.ts","../src/lib/core/VectorControl.ts"],"sourcesContent":["/**\n * Tiny DOM helpers to keep the vanilla UI modules terse.\n */\n\n/**\n * Creates an element with a class name and optional attributes.\n *\n * @param tag - The element tag name\n * @param className - Optional class name\n * @param attrs - Optional attributes to set\n * @returns The created element\n */\nexport function el(\n tag: K,\n className?: string,\n attrs?: Record,\n): HTMLElementTagNameMap[K] {\n const element = document.createElement(tag);\n if (className) element.className = className;\n if (attrs) {\n for (const [key, value] of Object.entries(attrs)) {\n element.setAttribute(key, value);\n }\n }\n return element;\n}\n\n/**\n * Creates an inline SVG icon element from path markup.\n *\n * SECURITY: `paths` is inserted into innerHTML without sanitization.\n * Only pass trusted, static SVG markup such as the {@link ICONS}\n * constants - never user-generated content.\n *\n * @param paths - Trusted SVG inner markup (path/rect/circle elements)\n * @param size - Icon size in pixels\n * @returns A span wrapping the SVG\n */\nexport function svgIcon(paths: string, size = 14): HTMLSpanElement {\n const span = el('span', 'vector-control-svg-icon');\n span.innerHTML = `${paths}`;\n return span;\n}\n\n/**\n * Common SVG icon paths.\n */\nexport const ICONS = {\n eye: '',\n eyeOff:\n '',\n zoom: '',\n trash:\n '',\n sliders:\n '',\n upload:\n '',\n chevronDown: '',\n} as const;\n","import { el } from './dom';\n\n/**\n * A modal checkbox picker for the layers of a multi-layer container\n * (a GeoPackage with several feature tables, a multi-layer GDAL source,\n * ...), so the user loads only the layers they want instead of every\n * layer in the file.\n */\n\n/** Options for {@link openLayerPicker}. */\nexport interface LayerPickerOptions {\n /** Element the modal is appended to (normally the map container). */\n container: HTMLElement;\n /** Layer names offered, in the container's own order. */\n layers: string[];\n /** Display name of the container (file name or URL), shown in the prompt. */\n sourceName: string;\n}\n\n/** A picker that has been opened (or queued behind an earlier one). */\nexport interface LayerPickerHandle {\n /** Resolves with the chosen layer names; empty when the user cancelled. */\n selection: Promise;\n /** Closes the picker as if the user cancelled (resolves with `[]`). */\n close(): void;\n}\n\n// One picker at a time per container: the panel starts a load per dropped\n// file without awaiting, so two multi-layer files would otherwise stack two\n// modals on top of each other. Each open waits for the previous one to\n// settle, and the chain is keyed by container so separate maps stay\n// independent.\nconst pickerQueues = new WeakMap>();\n\n/**\n * Opens a modal layer picker over `container` and resolves with the layers\n * the user chose. Every layer starts selected, so confirming without changing\n * anything loads the whole container (the behavior before the picker existed).\n *\n * @param options - The container, the layer names, and the source name.\n * @returns A handle carrying the selection promise and a programmatic close.\n */\nexport function openLayerPicker(options: LayerPickerOptions): LayerPickerHandle {\n // Closing before the queued turn arrives must still cancel, so the state\n // lives here rather than inside the (not yet created) modal.\n let closed = false;\n let cancelOpenPicker: (() => void) | null = null;\n\n const show = (): Promise =>\n closed\n ? Promise.resolve([])\n : renderLayerPicker(options, (cancel) => {\n cancelOpenPicker = cancel;\n });\n\n const previous = pickerQueues.get(options.container) ?? Promise.resolve();\n // `.then(show, show)`: a rejected predecessor must not strand this picker.\n const selection = previous.then(show, show);\n pickerQueues.set(options.container, selection);\n\n return {\n selection,\n close: () => {\n closed = true;\n cancelOpenPicker?.();\n },\n };\n}\n\n/**\n * Builds the modal, wires it up, and resolves once the user confirms or\n * cancels. `registerCancel` receives the cancel callback so the caller's\n * handle can close a picker that is already on screen.\n */\nfunction renderLayerPicker(\n options: LayerPickerOptions,\n registerCancel: (cancel: () => void) => void,\n): Promise {\n const { container, layers, sourceName } = options;\n\n return new Promise((resolve) => {\n const titleId = `vector-layer-picker-title-${Math.random().toString(36).slice(2, 10)}`;\n\n const overlay = el('div', 'vector-control-layer-picker');\n const dialog = el('div', 'vector-control-layer-picker-dialog', {\n role: 'dialog',\n 'aria-modal': 'true',\n 'aria-labelledby': titleId,\n });\n\n const title = el('div', 'vector-control-layer-picker-title', { id: titleId });\n title.textContent = 'Choose layers to load';\n const subtitle = el('div', 'vector-control-layer-picker-subtitle');\n subtitle.textContent = `${sourceName} contains ${layers.length} layers.`;\n\n // \"Select all\" sits outside the scrolling list so it stays reachable for a\n // container with many layers.\n const selectAllRow = el('label', 'vector-control-layer-picker-all');\n const selectAll = el('input', 'vector-control-checkbox') as HTMLInputElement;\n selectAll.type = 'checkbox';\n selectAll.checked = true;\n const selectAllText = el('span');\n selectAllText.textContent = 'Select all';\n selectAllRow.appendChild(selectAll);\n selectAllRow.appendChild(selectAllText);\n\n const list = el('div', 'vector-control-layer-picker-list');\n const boxes: HTMLInputElement[] = [];\n for (const layer of layers) {\n const row = el('label', 'vector-control-layer-picker-item');\n const box = el('input', 'vector-control-checkbox') as HTMLInputElement;\n box.type = 'checkbox';\n box.checked = true;\n box.value = layer;\n const text = el('span', 'vector-control-layer-picker-name');\n // textContent, never innerHTML: a layer name comes from the file.\n text.textContent = layer;\n text.title = layer;\n row.appendChild(box);\n row.appendChild(text);\n list.appendChild(row);\n boxes.push(box);\n }\n\n const footer = el('div', 'vector-control-layer-picker-footer');\n const cancelButton = el('button', 'vector-control-button vector-control-button-secondary', {\n type: 'button',\n });\n cancelButton.textContent = 'Cancel';\n const loadButton = el('button', 'vector-control-button', { type: 'button' });\n footer.appendChild(cancelButton);\n footer.appendChild(loadButton);\n\n const chosen = (): string[] => boxes.filter((box) => box.checked).map((box) => box.value);\n\n const syncState = (): void => {\n const count = chosen().length;\n selectAll.checked = count === layers.length;\n selectAll.indeterminate = count > 0 && count < layers.length;\n loadButton.disabled = count === 0;\n loadButton.textContent = count === 1 ? 'Load 1 layer' : `Load ${count} layers`;\n };\n\n for (const box of boxes) box.addEventListener('change', syncState);\n selectAll.addEventListener('change', () => {\n for (const box of boxes) box.checked = selectAll.checked;\n syncState();\n });\n syncState();\n\n let settled = false;\n const finish = (result: string[]): void => {\n if (settled) return;\n settled = true;\n overlay.remove();\n resolve(result);\n };\n\n cancelButton.addEventListener('click', () => finish([]));\n loadButton.addEventListener('click', () => finish(chosen()));\n // Clicking the backdrop (not the dialog) cancels, like a native dialog.\n overlay.addEventListener('mousedown', (event) => {\n if (event.target === overlay) finish([]);\n });\n // The overlay sits inside the map container, so let neither the map nor\n // the control's click-outside handler see clicks meant for the dialog.\n for (const type of ['mousedown', 'click', 'dblclick', 'wheel'] as const) {\n overlay.addEventListener(type, (event) => event.stopPropagation());\n }\n overlay.addEventListener('keydown', (event) => {\n if (event.key === 'Escape') {\n event.stopPropagation();\n finish([]);\n }\n });\n\n dialog.appendChild(title);\n dialog.appendChild(subtitle);\n dialog.appendChild(selectAllRow);\n dialog.appendChild(list);\n dialog.appendChild(footer);\n overlay.appendChild(dialog);\n container.appendChild(overlay);\n\n // Focus inside the dialog so Escape and Tab land on it rather than on the\n // page behind it.\n selectAll.focus();\n\n registerCancel(() => finish([]));\n });\n}\n","import type { VectorDataSource, VectorFormat } from '../core/types';\n\n/**\n * Result of format detection for a data source.\n */\nexport interface DetectedSource {\n /** Detected vector format */\n format: VectorFormat;\n /** Suggested display name (file name without extension, or 'GeoJSON') */\n name: string;\n}\n\n/**\n * Maps file extensions to vector formats.\n */\nconst EXTENSION_FORMATS: Record = {\n geojson: 'geojson',\n json: 'geojson',\n gpkg: 'geopackage',\n shp: 'shapefile',\n zip: 'shapefile',\n parquet: 'geoparquet',\n geoparquet: 'geoparquet',\n pq: 'geoparquet',\n fgb: 'flatgeobuf',\n csv: 'csv',\n tsv: 'csv',\n // Not a GDAL-readable path on its own: the engine unzips a KMZ and reads\n // the KML inside it (see formats/kmz.ts).\n kmz: 'kmz',\n};\n\n/**\n * Extracts the file name from a URL or path, stripping query strings.\n *\n * @param url - URL or file path\n * @returns The trailing file name segment\n */\nexport function fileNameFromUrl(url: string): string {\n const withoutQuery = url.split(/[?#]/)[0];\n const segments = withoutQuery.split('/');\n return segments[segments.length - 1] || withoutQuery;\n}\n\n/**\n * Detects the vector format from a file name based on its extension.\n *\n * Extensions without a dedicated reader (kml, gml, tab, dxf, ...) are\n * returned as-is and handled by the GDAL-backed ST_Read, so every\n * format the spatial extension supports can load.\n *\n * @param fileName - File name or URL path\n * @returns The detected format, or 'unknown' when there is no extension\n */\nexport function formatFromFileName(fileName: string): VectorFormat {\n const match = /\\.([a-z0-9]+)$/i.exec(fileName.trim());\n if (!match) return 'unknown';\n const extension = match[1].toLowerCase();\n return EXTENSION_FORMATS[extension] ?? extension;\n}\n\n/**\n * Strips the extension from a file name for display purposes.\n *\n * @param fileName - File name\n * @returns File name without its extension\n */\nexport function baseName(fileName: string): string {\n return fileName.replace(/\\.[a-z0-9]+$/i, '') || fileName;\n}\n\n/**\n * Maps data: URL MIME types to vector formats.\n */\nconst MIME_FORMATS: Array<[RegExp, VectorFormat]> = [\n [/json/, 'geojson'],\n [/csv|tab-separated/, 'csv'],\n [/parquet/, 'geoparquet'],\n];\n\n/**\n * Detects the format of a data: URL from its MIME type.\n *\n * Bundlers (e.g. Vite) inline small assets as base64 data URLs, so a\n * sample.geojson import can reach addData as `data:application/geo+json;...`.\n *\n * @param url - The data: URL\n * @returns The detected format, or 'unknown'\n */\nexport function formatFromDataUrl(url: string): VectorFormat {\n const mime = url.slice('data:'.length).split(/[;,]/)[0].toLowerCase();\n for (const [pattern, format] of MIME_FORMATS) {\n if (pattern.test(mime)) return format;\n }\n return 'unknown';\n}\n\n/**\n * Detects the format and display name of a data source.\n *\n * GeoJSON objects are recognized directly; files and URLs are detected\n * from their extension (or MIME type for data: URLs). An explicit\n * format always wins.\n *\n * @param source - URL string, File/Blob, or GeoJSON object\n * @param explicitFormat - Optional format override\n * @returns The detected source description\n */\nexport function detectSource(\n source: VectorDataSource,\n explicitFormat?: VectorFormat,\n): DetectedSource {\n if (typeof source === 'string') {\n if (source.startsWith('data:')) {\n return { format: explicitFormat ?? formatFromDataUrl(source), name: 'Untitled' };\n }\n const name = fileNameFromUrl(source);\n return {\n format: explicitFormat ?? formatFromFileName(name),\n name: baseName(name),\n };\n }\n\n if (typeof File !== 'undefined' && source instanceof File) {\n return {\n format: explicitFormat ?? formatFromFileName(source.name),\n name: baseName(source.name),\n };\n }\n\n if (typeof Blob !== 'undefined' && source instanceof Blob) {\n return { format: explicitFormat ?? 'unknown', name: 'Untitled' };\n }\n\n // Plain object - treat as GeoJSON\n return { format: explicitFormat ?? 'geojson', name: 'GeoJSON' };\n}\n","import type { Feature, FeatureCollection, GeoJSON, Geometry, Position } from 'geojson';\nimport type { GeometryCategory } from '../core/types';\n\n/**\n * Bounding box as [minX, minY, maxX, maxY] in EPSG:4326.\n */\nexport type Bbox = [number, number, number, number];\n\n/**\n * Classifies a GeoJSON geometry type into a broad category.\n *\n * @param type - GeoJSON geometry type string\n * @returns The geometry category\n */\nexport function classifyGeometryType(type: string): GeometryCategory {\n switch (type) {\n case 'Point':\n case 'MultiPoint':\n return 'point';\n case 'LineString':\n case 'MultiLineString':\n return 'line';\n case 'Polygon':\n case 'MultiPolygon':\n return 'polygon';\n case 'GeometryCollection':\n return 'mixed';\n default:\n return 'unknown';\n }\n}\n\n/**\n * Merges a new category into an accumulated category.\n *\n * @param current - The accumulated category (undefined when empty)\n * @param next - The next category seen\n * @returns The merged category\n */\nexport function mergeGeometryCategory(\n current: GeometryCategory | undefined,\n next: GeometryCategory,\n): GeometryCategory {\n if (!current || current === 'unknown') return next;\n if (next === 'unknown') return current;\n return current === next ? current : 'mixed';\n}\n\n/**\n * Normalizes any GeoJSON object into a FeatureCollection.\n *\n * @param data - GeoJSON object (FeatureCollection, Feature, or Geometry)\n * @returns The data as a FeatureCollection\n */\nexport function toFeatureCollection(data: GeoJSON): FeatureCollection {\n if (data.type === 'FeatureCollection') return data;\n if (data.type === 'Feature') return { type: 'FeatureCollection', features: [data] };\n return {\n type: 'FeatureCollection',\n features: [{ type: 'Feature', geometry: data as Geometry, properties: {} }],\n };\n}\n\n/**\n * Reads the source CRS declared by a GeoJSON `crs` member and returns it as an\n * `EPSG:` string to reproject from, or null when the collection is already\n * WGS84 lon/lat (or carries no usable CRS member).\n *\n * RFC 7946 mandates WGS84 for GeoJSON, but the pre-RFC form with a top-level\n * `\"crs\": { \"type\": \"name\", \"properties\": { \"name\": \"urn:ogc:def:crs:EPSG::26911\" } }`\n * is still emitted by GDAL/QGIS exports of projected data. Such a collection\n * carries raw projected coordinates (metres) that MapLibre cannot render, so the\n * caller reprojects to WGS84 before adding the layer. Both the URN form\n * (`urn:ogc:def:crs:EPSG::26911`) and the short form (`EPSG:26911`) are handled.\n *\n * WGS84 aliases (`EPSG:4326`, `EPSG:4979`, and OGC `CRS84`) return null so the\n * already-WGS84 common case skips the reprojection round-trip entirely.\n *\n * @param collection - A FeatureCollection that may carry a legacy `crs` member\n * @returns An `EPSG:` string to reproject from, or null when none is needed\n */\nexport function crsFromGeoJSON(collection: FeatureCollection): string | null {\n const name = (collection as { crs?: { properties?: { name?: unknown } } }).crs?.properties?.name;\n if (typeof name !== 'string') return null;\n const upper = name.toUpperCase();\n // CRS84 (lon/lat) and the WGS84 EPSG codes are already the coordinates\n // MapLibre expects, so no reprojection is required.\n if (upper.includes('CRS84') || /EPSG:+(4326|4979)\\b/.test(upper)) return null;\n // Match the trailing EPSG code in either the URN (`EPSG::26911`) or short\n // (`EPSG:26911`) form; the `:+` tolerates the URN's double colon.\n const match = upper.match(/EPSG:+(\\d+)/);\n return match ? `EPSG:${match[1]}` : null;\n}\n\nfunction extendBboxWithPositions(bbox: Bbox, coords: unknown): void {\n if (!Array.isArray(coords)) return;\n if (typeof coords[0] === 'number') {\n const [x, y] = coords as Position;\n if (x < bbox[0]) bbox[0] = x;\n if (y < bbox[1]) bbox[1] = y;\n if (x > bbox[2]) bbox[2] = x;\n if (y > bbox[3]) bbox[3] = y;\n return;\n }\n for (const child of coords) {\n extendBboxWithPositions(bbox, child);\n }\n}\n\nfunction extendBboxWithGeometry(bbox: Bbox, geometry: Geometry | null): void {\n if (!geometry) return;\n if (geometry.type === 'GeometryCollection') {\n for (const child of geometry.geometries) {\n extendBboxWithGeometry(bbox, child);\n }\n return;\n }\n extendBboxWithPositions(bbox, geometry.coordinates);\n}\n\n/**\n * Summary statistics of a FeatureCollection.\n */\nexport interface GeoJSONSummary {\n featureCount: number;\n geometryType: GeometryCategory;\n bbox?: Bbox;\n}\n\n/**\n * Computes feature count, geometry category, and bounding box of a\n * FeatureCollection in a single pass.\n *\n * @param collection - The FeatureCollection to summarize\n * @returns Summary statistics\n */\nexport function summarizeFeatureCollection(collection: FeatureCollection): GeoJSONSummary {\n const bbox: Bbox = [Infinity, Infinity, -Infinity, -Infinity];\n let category: GeometryCategory | undefined;\n\n for (const feature of collection.features as Feature[]) {\n if (feature.geometry) {\n category = mergeGeometryCategory(category, classifyGeometryType(feature.geometry.type));\n extendBboxWithGeometry(bbox, feature.geometry);\n }\n }\n\n return {\n featureCount: collection.features.length,\n geometryType: category ?? 'unknown',\n bbox: bbox[0] <= bbox[2] && bbox[1] <= bbox[3] ? bbox : undefined,\n };\n}\n\n/**\n * Collects the union of attribute (property) names across a collection's\n * features, in first-seen order. A host uses these to offer attribute-driven\n * choices (e.g. a label field) for a loaded layer.\n *\n * @param collection - The FeatureCollection to scan\n * @returns The distinct property names found across all features\n */\nexport function collectFieldNames(collection: FeatureCollection): string[] {\n const names = new Set();\n for (const feature of collection.features as Feature[]) {\n if (!feature.properties) continue;\n for (const key of Object.keys(feature.properties)) names.add(key);\n }\n return Array.from(names);\n}\n","import type { FeatureCollection, GeoJSON } from 'geojson';\nimport { toFeatureCollection } from '../utils/geometry';\n\n/**\n * The `type` values a top-level GeoJSON object can carry (RFC 7946).\n */\nconst GEOJSON_TYPES = new Set([\n 'FeatureCollection',\n 'Feature',\n 'Point',\n 'MultiPoint',\n 'LineString',\n 'MultiLineString',\n 'Polygon',\n 'MultiPolygon',\n 'GeometryCollection',\n]);\n\n/**\n * Whether a parsed value is shaped like a GeoJSON object (a plain object\n * with a recognized `type`).\n *\n * @param value - A value parsed from JSON\n * @returns True when `value` looks like GeoJSON\n */\nexport function looksLikeGeoJSON(value: unknown): value is GeoJSON {\n return (\n typeof value === 'object' &&\n value !== null &&\n GEOJSON_TYPES.has((value as { type?: unknown }).type as string)\n );\n}\n\n/**\n * Fetches a remote URL and returns its parsed GeoJSON when the response\n * is GeoJSON, or `null` when it is not.\n *\n * Extensionless service endpoints (OGC API Features `?f=geojson`, ArcGIS\n * REST `query?f=geojson`, custom services with query strings and no file\n * extension) return GeoJSON the file-name detector cannot classify, so it\n * falls through to the DuckDB engine. That engine path lazily installs the\n * spatial extension from a remote repository, which hangs in sandboxed or\n * firewalled environments. Sniffing the response here keeps a GeoJSON\n * endpoint on the pure-JS path, so DuckDB is never loaded for it.\n *\n * The response body is only read when the `Content-Type` is JSON-ish, so a\n * binary endpoint without an extension (a `.parquet` behind a query string,\n * say) is not downloaded as text; its download is cancelled and the caller\n * falls back to the engine. The fetched text is returned alongside the\n * collection so the caller can render it without a second request.\n *\n * @param url - The http(s) URL to probe\n * @returns The parsed collection and its byte size, or `null` when the\n * source is not a JSON response the caller should treat as GeoJSON\n */\nexport async function sniffRemoteGeoJSON(\n url: string,\n): Promise<{ collection: FeatureCollection; byteSize: number } | null> {\n if (!/^https?:\\/\\//i.test(url)) return null;\n\n let response: Response;\n try {\n response = await fetch(url);\n } catch {\n // Network/CORS failure: let the engine path attempt the load and\n // surface its own error rather than masking it here.\n return null;\n }\n if (!response.ok) return null;\n\n const contentType = response.headers.get('content-type') ?? '';\n if (!/json/i.test(contentType)) {\n // Not a JSON response (e.g. application/octet-stream for a parquet\n // endpoint); don't download the body as text.\n await response.body?.cancel().catch(() => undefined);\n return null;\n }\n\n let text: string;\n try {\n text = await response.text();\n } catch {\n return null;\n }\n\n let parsed: unknown;\n try {\n parsed = JSON.parse(text);\n } catch {\n // JSON content type but unparsable body; fall back to the engine.\n return null;\n }\n\n if (!looksLikeGeoJSON(parsed)) return null;\n return { collection: toFeatureCollection(parsed), byteSize: text.length };\n}\n","// DEFLATE is a complex format; to read this code, you should probably check the RFC first:\n// https://tools.ietf.org/html/rfc1951\n// You may also wish to take a look at the guide I made about this program:\n// https://gist.github.com/101arrowz/253f31eb5abc3d9275ab943003ffecad\n// Some of the following code is similar to that of UZIP.js:\n// https://github.com/photopea/UZIP.js\n// However, the vast majority of the codebase has diverged from UZIP.js to increase performance and reduce bundle size.\n// Sometimes 0 will appear where -1 would be more appropriate. This is because using a uint\n// is better for memory in most engines (I *think*).\nvar ch2 = {};\nvar wk = (function (c, id, msg, transfer, cb) {\n var w = new Worker(ch2[id] || (ch2[id] = URL.createObjectURL(new Blob([\n c + ';addEventListener(\"error\",function(e){e=e.error;postMessage({$e$:[e.message,e.code,e.stack]})})'\n ], { type: 'text/javascript' }))));\n w.onmessage = function (e) {\n var d = e.data, ed = d.$e$;\n if (ed) {\n var err = new Error(ed[0]);\n err['code'] = ed[1];\n err.stack = ed[2];\n cb(err, null);\n }\n else\n cb(null, d);\n };\n w.postMessage(msg, transfer);\n return w;\n});\n\n// aliases for shorter compressed code (most minifers don't do this)\nvar u8 = Uint8Array, u16 = Uint16Array, i32 = Int32Array;\n// fixed length extra bits\nvar fleb = new u8([0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 0, /* unused */ 0, 0, /* impossible */ 0]);\n// fixed distance extra bits\nvar fdeb = new u8([0, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9, 10, 10, 11, 11, 12, 12, 13, 13, /* unused */ 0, 0]);\n// code length index map\nvar clim = new u8([16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15]);\n// get base, reverse index map from extra bits\nvar freb = function (eb, start) {\n var b = new u16(31);\n for (var i = 0; i < 31; ++i) {\n b[i] = start += 1 << eb[i - 1];\n }\n // numbers here are at max 18 bits\n var r = new i32(b[30]);\n for (var i = 1; i < 30; ++i) {\n for (var j = b[i]; j < b[i + 1]; ++j) {\n r[j] = ((j - b[i]) << 5) | i;\n }\n }\n return { b: b, r: r };\n};\nvar _a = freb(fleb, 2), fl = _a.b, revfl = _a.r;\n// we can ignore the fact that the other numbers are wrong; they never happen anyway\nfl[28] = 258, revfl[258] = 28;\nvar _b = freb(fdeb, 0), fd = _b.b, revfd = _b.r;\n// map of value to reverse (assuming 16 bits)\nvar rev = new u16(32768);\nfor (var i = 0; i < 32768; ++i) {\n // reverse table algorithm from SO\n var x = ((i & 0xAAAA) >> 1) | ((i & 0x5555) << 1);\n x = ((x & 0xCCCC) >> 2) | ((x & 0x3333) << 2);\n x = ((x & 0xF0F0) >> 4) | ((x & 0x0F0F) << 4);\n rev[i] = (((x & 0xFF00) >> 8) | ((x & 0x00FF) << 8)) >> 1;\n}\n// create huffman tree from u8 \"map\": index -> code length for code index\n// mb (max bits) must be at most 15\n// TODO: optimize/split up?\nvar hMap = (function (cd, mb, r) {\n var s = cd.length;\n // index\n var i = 0;\n // u16 \"map\": index -> # of codes with bit length = index\n var l = new u16(mb);\n // length of cd must be 288 (total # of codes)\n for (; i < s; ++i) {\n if (cd[i])\n ++l[cd[i] - 1];\n }\n // u16 \"map\": index -> minimum code for bit length = index\n var le = new u16(mb);\n for (i = 1; i < mb; ++i) {\n le[i] = (le[i - 1] + l[i - 1]) << 1;\n }\n var co;\n if (r) {\n // u16 \"map\": index -> number of actual bits, symbol for code\n co = new u16(1 << mb);\n // bits to remove for reverser\n var rvb = 15 - mb;\n for (i = 0; i < s; ++i) {\n // ignore 0 lengths\n if (cd[i]) {\n // num encoding both symbol and bits read\n var sv = (i << 4) | cd[i];\n // free bits\n var r_1 = mb - cd[i];\n // start value\n var v = le[cd[i] - 1]++ << r_1;\n // m is end value\n for (var m = v | ((1 << r_1) - 1); v <= m; ++v) {\n // every 16 bit value starting with the code yields the same result\n co[rev[v] >> rvb] = sv;\n }\n }\n }\n }\n else {\n co = new u16(s);\n for (i = 0; i < s; ++i) {\n if (cd[i]) {\n co[i] = rev[le[cd[i] - 1]++] >> (15 - cd[i]);\n }\n }\n }\n return co;\n});\n// fixed length tree\nvar flt = new u8(288);\nfor (var i = 0; i < 144; ++i)\n flt[i] = 8;\nfor (var i = 144; i < 256; ++i)\n flt[i] = 9;\nfor (var i = 256; i < 280; ++i)\n flt[i] = 7;\nfor (var i = 280; i < 288; ++i)\n flt[i] = 8;\n// fixed distance tree\nvar fdt = new u8(32);\nfor (var i = 0; i < 32; ++i)\n fdt[i] = 5;\n// fixed length map\nvar flm = /*#__PURE__*/ hMap(flt, 9, 0), flrm = /*#__PURE__*/ hMap(flt, 9, 1);\n// fixed distance map\nvar fdm = /*#__PURE__*/ hMap(fdt, 5, 0), fdrm = /*#__PURE__*/ hMap(fdt, 5, 1);\n// find max of array\nvar max = function (a) {\n var m = a[0];\n for (var i = 1; i < a.length; ++i) {\n if (a[i] > m)\n m = a[i];\n }\n return m;\n};\n// read d, starting at bit p and mask with m\nvar bits = function (d, p, m) {\n var o = (p / 8) | 0;\n return ((d[o] | (d[o + 1] << 8)) >> (p & 7)) & m;\n};\n// read d, starting at bit p continuing for at least 16 bits\nvar bits16 = function (d, p) {\n var o = (p / 8) | 0;\n return ((d[o] | (d[o + 1] << 8) | (d[o + 2] << 16)) >> (p & 7));\n};\n// get end of byte\nvar shft = function (p) { return ((p + 7) / 8) | 0; };\n// typed array slice - allows garbage collector to free original reference,\n// while being more compatible than .slice\nvar slc = function (v, s, e) {\n if (s == null || s < 0)\n s = 0;\n if (e == null || e > v.length)\n e = v.length;\n // can't use .constructor in case user-supplied\n return new u8(v.subarray(s, e));\n};\n/**\n * Codes for errors generated within this library\n */\nexport var FlateErrorCode = {\n UnexpectedEOF: 0,\n InvalidBlockType: 1,\n InvalidLengthLiteral: 2,\n InvalidDistance: 3,\n StreamFinished: 4,\n NoStreamHandler: 5,\n InvalidHeader: 6,\n NoCallback: 7,\n InvalidUTF8: 8,\n ExtraFieldTooLong: 9,\n InvalidDate: 10,\n FilenameTooLong: 11,\n StreamFinishing: 12,\n InvalidZipData: 13,\n UnknownCompressionMethod: 14\n};\n// error codes\nvar ec = [\n 'unexpected EOF',\n 'invalid block type',\n 'invalid length/literal',\n 'invalid distance',\n 'stream finished',\n 'no stream handler',\n ,\n 'no callback',\n 'invalid UTF-8 data',\n 'extra field too long',\n 'date not in range 1980-2099',\n 'filename too long',\n 'stream finishing',\n 'invalid zip data'\n // determined by unknown compression method\n];\n;\nvar err = function (ind, msg, nt) {\n var e = new Error(msg || ec[ind]);\n e.code = ind;\n if (Error.captureStackTrace)\n Error.captureStackTrace(e, err);\n if (!nt)\n throw e;\n return e;\n};\n// expands raw DEFLATE data\nvar inflt = function (dat, st, buf, dict) {\n // source length dict length\n var sl = dat.length, dl = dict ? dict.length : 0;\n if (!sl || st.f && !st.l)\n return buf || new u8(0);\n var noBuf = !buf;\n // have to estimate size\n var resize = noBuf || st.i != 2;\n // no state\n var noSt = st.i;\n // Assumes roughly 33% compression ratio average\n if (noBuf)\n buf = new u8(sl * 3);\n // ensure buffer can fit at least l elements\n var cbuf = function (l) {\n var bl = buf.length;\n // need to increase size to fit\n if (l > bl) {\n // Double or set to necessary, whichever is greater\n var nbuf = new u8(Math.max(bl * 2, l));\n nbuf.set(buf);\n buf = nbuf;\n }\n };\n // last chunk bitpos bytes\n var final = st.f || 0, pos = st.p || 0, bt = st.b || 0, lm = st.l, dm = st.d, lbt = st.m, dbt = st.n;\n // total bits\n var tbts = sl * 8;\n do {\n if (!lm) {\n // BFINAL - this is only 1 when last chunk is next\n final = bits(dat, pos, 1);\n // type: 0 = no compression, 1 = fixed huffman, 2 = dynamic huffman\n var type = bits(dat, pos + 1, 3);\n pos += 3;\n if (!type) {\n // go to end of byte boundary\n var s = shft(pos) + 4, l = dat[s - 4] | (dat[s - 3] << 8), t = s + l;\n if (t > sl) {\n if (noSt)\n err(0);\n break;\n }\n // ensure size\n if (resize)\n cbuf(bt + l);\n // Copy over uncompressed data\n buf.set(dat.subarray(s, t), bt);\n // Get new bitpos, update byte count\n st.b = bt += l, st.p = pos = t * 8, st.f = final;\n continue;\n }\n else if (type == 1)\n lm = flrm, dm = fdrm, lbt = 9, dbt = 5;\n else if (type == 2) {\n // literal lengths\n var hLit = bits(dat, pos, 31) + 257, hcLen = bits(dat, pos + 10, 15) + 4;\n var tl = hLit + bits(dat, pos + 5, 31) + 1;\n pos += 14;\n // length+distance tree\n var ldt = new u8(tl);\n // code length tree\n var clt = new u8(19);\n for (var i = 0; i < hcLen; ++i) {\n // use index map to get real code\n clt[clim[i]] = bits(dat, pos + i * 3, 7);\n }\n pos += hcLen * 3;\n // code lengths bits\n var clb = max(clt), clbmsk = (1 << clb) - 1;\n // code lengths map\n var clm = hMap(clt, clb, 1);\n for (var i = 0; i < tl;) {\n var r = clm[bits(dat, pos, clbmsk)];\n // bits read\n pos += r & 15;\n // symbol\n var s = r >> 4;\n // code length to copy\n if (s < 16) {\n ldt[i++] = s;\n }\n else {\n // copy count\n var c = 0, n = 0;\n if (s == 16)\n n = 3 + bits(dat, pos, 3), pos += 2, c = ldt[i - 1];\n else if (s == 17)\n n = 3 + bits(dat, pos, 7), pos += 3;\n else if (s == 18)\n n = 11 + bits(dat, pos, 127), pos += 7;\n while (n--)\n ldt[i++] = c;\n }\n }\n // length tree distance tree\n var lt = ldt.subarray(0, hLit), dt = ldt.subarray(hLit);\n // max length bits\n lbt = max(lt);\n // max dist bits\n dbt = max(dt);\n lm = hMap(lt, lbt, 1);\n dm = hMap(dt, dbt, 1);\n }\n else\n err(1);\n if (pos > tbts) {\n if (noSt)\n err(0);\n break;\n }\n }\n // Make sure the buffer can hold this + the largest possible addition\n // Maximum chunk size (practically, theoretically infinite) is 2^17\n if (resize)\n cbuf(bt + 131072);\n var lms = (1 << lbt) - 1, dms = (1 << dbt) - 1;\n var lpos = pos;\n for (;; lpos = pos) {\n // bits read, code\n var c = lm[bits16(dat, pos) & lms], sym = c >> 4;\n pos += c & 15;\n if (pos > tbts) {\n if (noSt)\n err(0);\n break;\n }\n if (!c)\n err(2);\n if (sym < 256)\n buf[bt++] = sym;\n else if (sym == 256) {\n lpos = pos, lm = null;\n break;\n }\n else {\n var add = sym - 254;\n // no extra bits needed if less\n if (sym > 264) {\n // index\n var i = sym - 257, b = fleb[i];\n add = bits(dat, pos, (1 << b) - 1) + fl[i];\n pos += b;\n }\n // dist\n var d = dm[bits16(dat, pos) & dms], dsym = d >> 4;\n if (!d)\n err(3);\n pos += d & 15;\n var dt = fd[dsym];\n if (dsym > 3) {\n var b = fdeb[dsym];\n dt += bits16(dat, pos) & (1 << b) - 1, pos += b;\n }\n if (pos > tbts) {\n if (noSt)\n err(0);\n break;\n }\n if (resize)\n cbuf(bt + 131072);\n var end = bt + add;\n if (bt < dt) {\n var shift = dl - dt, dend = Math.min(dt, end);\n if (shift + bt < 0)\n err(3);\n for (; bt < dend; ++bt)\n buf[bt] = dict[shift + bt];\n }\n for (; bt < end; ++bt)\n buf[bt] = buf[bt - dt];\n }\n }\n st.l = lm, st.p = lpos, st.b = bt, st.f = final;\n if (lm)\n final = 1, st.m = lbt, st.d = dm, st.n = dbt;\n } while (!final);\n // don't reallocate for streams or user buffers\n return bt != buf.length && noBuf ? slc(buf, 0, bt) : buf.subarray(0, bt);\n};\n// starting at p, write the minimum number of bits that can hold v to d\nvar wbits = function (d, p, v) {\n v <<= p & 7;\n var o = (p / 8) | 0;\n d[o] |= v;\n d[o + 1] |= v >> 8;\n};\n// starting at p, write the minimum number of bits (>8) that can hold v to d\nvar wbits16 = function (d, p, v) {\n v <<= p & 7;\n var o = (p / 8) | 0;\n d[o] |= v;\n d[o + 1] |= v >> 8;\n d[o + 2] |= v >> 16;\n};\n// creates code lengths from a frequency table\nvar hTree = function (d, mb) {\n // Need extra info to make a tree\n var t = [];\n for (var i = 0; i < d.length; ++i) {\n if (d[i])\n t.push({ s: i, f: d[i] });\n }\n var s = t.length;\n var t2 = t.slice();\n if (!s)\n return { t: et, l: 0 };\n if (s == 1) {\n var v = new u8(t[0].s + 1);\n v[t[0].s] = 1;\n return { t: v, l: 1 };\n }\n t.sort(function (a, b) { return a.f - b.f; });\n // after i2 reaches last ind, will be stopped\n // freq must be greater than largest possible number of symbols\n t.push({ s: -1, f: 25001 });\n var l = t[0], r = t[1], i0 = 0, i1 = 1, i2 = 2;\n t[0] = { s: -1, f: l.f + r.f, l: l, r: r };\n // efficient algorithm from UZIP.js\n // i0 is lookbehind, i2 is lookahead - after processing two low-freq\n // symbols that combined have high freq, will start processing i2 (high-freq,\n // non-composite) symbols instead\n // see https://reddit.com/r/photopea/comments/ikekht/uzipjs_questions/\n while (i1 != s - 1) {\n l = t[t[i0].f < t[i2].f ? i0++ : i2++];\n r = t[i0 != i1 && t[i0].f < t[i2].f ? i0++ : i2++];\n t[i1++] = { s: -1, f: l.f + r.f, l: l, r: r };\n }\n var maxSym = t2[0].s;\n for (var i = 1; i < s; ++i) {\n if (t2[i].s > maxSym)\n maxSym = t2[i].s;\n }\n // code lengths\n var tr = new u16(maxSym + 1);\n // max bits in tree\n var mbt = ln(t[i1 - 1], tr, 0);\n if (mbt > mb) {\n // more algorithms from UZIP.js\n // TODO: find out how this code works (debt)\n // ind debt\n var i = 0, dt = 0;\n // left cost\n var lft = mbt - mb, cst = 1 << lft;\n t2.sort(function (a, b) { return tr[b.s] - tr[a.s] || a.f - b.f; });\n for (; i < s; ++i) {\n var i2_1 = t2[i].s;\n if (tr[i2_1] > mb) {\n dt += cst - (1 << (mbt - tr[i2_1]));\n tr[i2_1] = mb;\n }\n else\n break;\n }\n dt >>= lft;\n while (dt > 0) {\n var i2_2 = t2[i].s;\n if (tr[i2_2] < mb)\n dt -= 1 << (mb - tr[i2_2]++ - 1);\n else\n ++i;\n }\n for (; i >= 0 && dt; --i) {\n var i2_3 = t2[i].s;\n if (tr[i2_3] == mb) {\n --tr[i2_3];\n ++dt;\n }\n }\n mbt = mb;\n }\n return { t: new u8(tr), l: mbt };\n};\n// get the max length and assign length codes\nvar ln = function (n, l, d) {\n return n.s == -1\n ? Math.max(ln(n.l, l, d + 1), ln(n.r, l, d + 1))\n : (l[n.s] = d);\n};\n// length codes generation\nvar lc = function (c) {\n var s = c.length;\n // Note that the semicolon was intentional\n while (s && !c[--s])\n ;\n var cl = new u16(++s);\n // ind num streak\n var cli = 0, cln = c[0], cls = 1;\n var w = function (v) { cl[cli++] = v; };\n for (var i = 1; i <= s; ++i) {\n if (c[i] == cln && i != s)\n ++cls;\n else {\n if (!cln && cls > 2) {\n for (; cls > 138; cls -= 138)\n w(32754);\n if (cls > 2) {\n w(cls > 10 ? ((cls - 11) << 5) | 28690 : ((cls - 3) << 5) | 12305);\n cls = 0;\n }\n }\n else if (cls > 3) {\n w(cln), --cls;\n for (; cls > 6; cls -= 6)\n w(8304);\n if (cls > 2)\n w(((cls - 3) << 5) | 8208), cls = 0;\n }\n while (cls--)\n w(cln);\n cls = 1;\n cln = c[i];\n }\n }\n return { c: cl.subarray(0, cli), n: s };\n};\n// calculate the length of output from tree, code lengths\nvar clen = function (cf, cl) {\n var l = 0;\n for (var i = 0; i < cl.length; ++i)\n l += cf[i] * cl[i];\n return l;\n};\n// writes a fixed block\n// returns the new bit pos\nvar wfblk = function (out, pos, dat) {\n // no need to write 00 as type: TypedArray defaults to 0\n var s = dat.length;\n var o = shft(pos + 2);\n out[o] = s & 255;\n out[o + 1] = s >> 8;\n out[o + 2] = out[o] ^ 255;\n out[o + 3] = out[o + 1] ^ 255;\n for (var i = 0; i < s; ++i)\n out[o + i + 4] = dat[i];\n return (o + 4 + s) * 8;\n};\n// writes a block\nvar wblk = function (dat, out, final, syms, lf, df, eb, li, bs, bl, p) {\n wbits(out, p++, final);\n ++lf[256];\n var _a = hTree(lf, 15), dlt = _a.t, mlb = _a.l;\n var _b = hTree(df, 15), ddt = _b.t, mdb = _b.l;\n var _c = lc(dlt), lclt = _c.c, nlc = _c.n;\n var _d = lc(ddt), lcdt = _d.c, ndc = _d.n;\n var lcfreq = new u16(19);\n for (var i = 0; i < lclt.length; ++i)\n ++lcfreq[lclt[i] & 31];\n for (var i = 0; i < lcdt.length; ++i)\n ++lcfreq[lcdt[i] & 31];\n var _e = hTree(lcfreq, 7), lct = _e.t, mlcb = _e.l;\n var nlcc = 19;\n for (; nlcc > 4 && !lct[clim[nlcc - 1]]; --nlcc)\n ;\n var flen = (bl + 5) << 3;\n var ftlen = clen(lf, flt) + clen(df, fdt) + eb;\n var dtlen = clen(lf, dlt) + clen(df, ddt) + eb + 14 + 3 * nlcc + clen(lcfreq, lct) + 2 * lcfreq[16] + 3 * lcfreq[17] + 7 * lcfreq[18];\n if (bs >= 0 && flen <= ftlen && flen <= dtlen)\n return wfblk(out, p, dat.subarray(bs, bs + bl));\n var lm, ll, dm, dl;\n wbits(out, p, 1 + (dtlen < ftlen)), p += 2;\n if (dtlen < ftlen) {\n lm = hMap(dlt, mlb, 0), ll = dlt, dm = hMap(ddt, mdb, 0), dl = ddt;\n var llm = hMap(lct, mlcb, 0);\n wbits(out, p, nlc - 257);\n wbits(out, p + 5, ndc - 1);\n wbits(out, p + 10, nlcc - 4);\n p += 14;\n for (var i = 0; i < nlcc; ++i)\n wbits(out, p + 3 * i, lct[clim[i]]);\n p += 3 * nlcc;\n var lcts = [lclt, lcdt];\n for (var it = 0; it < 2; ++it) {\n var clct = lcts[it];\n for (var i = 0; i < clct.length; ++i) {\n var len = clct[i] & 31;\n wbits(out, p, llm[len]), p += lct[len];\n if (len > 15)\n wbits(out, p, (clct[i] >> 5) & 127), p += clct[i] >> 12;\n }\n }\n }\n else {\n lm = flm, ll = flt, dm = fdm, dl = fdt;\n }\n for (var i = 0; i < li; ++i) {\n var sym = syms[i];\n if (sym > 255) {\n var len = (sym >> 18) & 31;\n wbits16(out, p, lm[len + 257]), p += ll[len + 257];\n if (len > 7)\n wbits(out, p, (sym >> 23) & 31), p += fleb[len];\n var dst = sym & 31;\n wbits16(out, p, dm[dst]), p += dl[dst];\n if (dst > 3)\n wbits16(out, p, (sym >> 5) & 8191), p += fdeb[dst];\n }\n else {\n wbits16(out, p, lm[sym]), p += ll[sym];\n }\n }\n wbits16(out, p, lm[256]);\n return p + ll[256];\n};\n// deflate options (nice << 13) | chain\nvar deo = /*#__PURE__*/ new i32([65540, 131080, 131088, 131104, 262176, 1048704, 1048832, 2114560, 2117632]);\n// empty\nvar et = /*#__PURE__*/ new u8(0);\n// compresses data into a raw DEFLATE buffer\nvar dflt = function (dat, lvl, plvl, pre, post, st) {\n var s = st.z || dat.length;\n var o = new u8(pre + s + 5 * (1 + Math.ceil(s / 7000)) + post);\n // writing to this writes to the output buffer\n var w = o.subarray(pre, o.length - post);\n var lst = st.l;\n var pos = (st.r || 0) & 7;\n if (lvl) {\n if (pos)\n w[0] = st.r >> 3;\n var opt = deo[lvl - 1];\n var n = opt >> 13, c = opt & 8191;\n var msk_1 = (1 << plvl) - 1;\n // prev 2-byte val map curr 2-byte val map\n var prev = st.p || new u16(32768), head = st.h || new u16(msk_1 + 1);\n var bs1_1 = Math.ceil(plvl / 3), bs2_1 = 2 * bs1_1;\n var hsh = function (i) { return (dat[i] ^ (dat[i + 1] << bs1_1) ^ (dat[i + 2] << bs2_1)) & msk_1; };\n // 24576 is an arbitrary number of maximum symbols per block\n // 424 buffer for last block\n var syms = new i32(25000);\n // length/literal freq distance freq\n var lf = new u16(288), df = new u16(32);\n // l/lcnt exbits index l/lind waitdx blkpos\n var lc_1 = 0, eb = 0, i = st.i || 0, li = 0, wi = st.w || 0, bs = 0;\n for (; i + 2 < s; ++i) {\n // hash value\n var hv = hsh(i);\n // index mod 32768 previous index mod\n var imod = i & 32767, pimod = head[hv];\n prev[imod] = pimod;\n head[hv] = imod;\n // We always should modify head and prev, but only add symbols if\n // this data is not yet processed (\"wait\" for wait index)\n if (wi <= i) {\n // bytes remaining\n var rem = s - i;\n if ((lc_1 > 7000 || li > 24576) && (rem > 423 || !lst)) {\n pos = wblk(dat, w, 0, syms, lf, df, eb, li, bs, i - bs, pos);\n li = lc_1 = eb = 0, bs = i;\n for (var j = 0; j < 286; ++j)\n lf[j] = 0;\n for (var j = 0; j < 30; ++j)\n df[j] = 0;\n }\n // len dist chain\n var l = 2, d = 0, ch_1 = c, dif = imod - pimod & 32767;\n if (rem > 2 && hv == hsh(i - dif)) {\n var maxn = Math.min(n, rem) - 1;\n var maxd = Math.min(32767, i);\n // max possible length\n // not capped at dif because decompressors implement \"rolling\" index population\n var ml = Math.min(258, rem);\n while (dif <= maxd && --ch_1 && imod != pimod) {\n if (dat[i + l] == dat[i + l - dif]) {\n var nl = 0;\n for (; nl < ml && dat[i + nl] == dat[i + nl - dif]; ++nl)\n ;\n if (nl > l) {\n l = nl, d = dif;\n // break out early when we reach \"nice\" (we are satisfied enough)\n if (nl > maxn)\n break;\n // now, find the rarest 2-byte sequence within this\n // length of literals and search for that instead.\n // Much faster than just using the start\n var mmd = Math.min(dif, nl - 2);\n var md = 0;\n for (var j = 0; j < mmd; ++j) {\n var ti = i - dif + j & 32767;\n var pti = prev[ti];\n var cd = ti - pti & 32767;\n if (cd > md)\n md = cd, pimod = ti;\n }\n }\n }\n // check the previous match\n imod = pimod, pimod = prev[imod];\n dif += imod - pimod & 32767;\n }\n }\n // d will be nonzero only when a match was found\n if (d) {\n // store both dist and len data in one int32\n // Make sure this is recognized as a len/dist with 28th bit (2^28)\n syms[li++] = 268435456 | (revfl[l] << 18) | revfd[d];\n var lin = revfl[l] & 31, din = revfd[d] & 31;\n eb += fleb[lin] + fdeb[din];\n ++lf[257 + lin];\n ++df[din];\n wi = i + l;\n ++lc_1;\n }\n else {\n syms[li++] = dat[i];\n ++lf[dat[i]];\n }\n }\n }\n for (i = Math.max(i, wi); i < s; ++i) {\n syms[li++] = dat[i];\n ++lf[dat[i]];\n }\n pos = wblk(dat, w, lst, syms, lf, df, eb, li, bs, i - bs, pos);\n if (!lst) {\n st.r = (pos & 7) | w[(pos / 8) | 0] << 3;\n // shft(pos) now 1 less if pos & 7 != 0\n pos -= 7;\n st.h = head, st.p = prev, st.i = i, st.w = wi;\n }\n }\n else {\n for (var i = st.w || 0; i < s + lst; i += 65535) {\n // end\n var e = i + 65535;\n if (e >= s) {\n // write final block\n w[(pos / 8) | 0] = lst;\n e = s;\n }\n pos = wfblk(w, pos + 1, dat.subarray(i, e));\n }\n st.i = s;\n }\n return slc(o, 0, pre + shft(pos) + post);\n};\n// CRC32 table\nvar crct = /*#__PURE__*/ (function () {\n var t = new Int32Array(256);\n for (var i = 0; i < 256; ++i) {\n var c = i, k = 9;\n while (--k)\n c = ((c & 1) && -306674912) ^ (c >>> 1);\n t[i] = c;\n }\n return t;\n})();\n// CRC32\nvar crc = function () {\n var c = -1;\n return {\n p: function (d) {\n // closures have awful performance\n var cr = c;\n for (var i = 0; i < d.length; ++i)\n cr = crct[(cr & 255) ^ d[i]] ^ (cr >>> 8);\n c = cr;\n },\n d: function () { return ~c; }\n };\n};\n// Adler32\nvar adler = function () {\n var a = 1, b = 0;\n return {\n p: function (d) {\n // closures have awful performance\n var n = a, m = b;\n var l = d.length | 0;\n for (var i = 0; i != l;) {\n var e = Math.min(i + 2655, l);\n for (; i < e; ++i)\n m += n += d[i];\n n = (n & 65535) + 15 * (n >> 16), m = (m & 65535) + 15 * (m >> 16);\n }\n a = n, b = m;\n },\n d: function () {\n a %= 65521, b %= 65521;\n return (a & 255) << 24 | (a & 0xFF00) << 8 | (b & 255) << 8 | (b >> 8);\n }\n };\n};\n;\n// deflate with opts\nvar dopt = function (dat, opt, pre, post, st) {\n if (!st) {\n st = { l: 1 };\n if (opt.dictionary) {\n var dict = opt.dictionary.subarray(-32768);\n var newDat = new u8(dict.length + dat.length);\n newDat.set(dict);\n newDat.set(dat, dict.length);\n dat = newDat;\n st.w = dict.length;\n }\n }\n return dflt(dat, opt.level == null ? 6 : opt.level, opt.mem == null ? (st.l ? Math.ceil(Math.max(8, Math.min(13, Math.log(dat.length))) * 1.5) : 20) : (12 + opt.mem), pre, post, st);\n};\n// Walmart object spread\nvar mrg = function (a, b) {\n var o = {};\n for (var k in a)\n o[k] = a[k];\n for (var k in b)\n o[k] = b[k];\n return o;\n};\n// worker clone\n// This is possibly the craziest part of the entire codebase, despite how simple it may seem.\n// The only parameter to this function is a closure that returns an array of variables outside of the function scope.\n// We're going to try to figure out the variable names used in the closure as strings because that is crucial for workerization.\n// We will return an object mapping of true variable name to value (basically, the current scope as a JS object).\n// The reason we can't just use the original variable names is minifiers mangling the toplevel scope.\n// This took me three weeks to figure out how to do.\nvar wcln = function (fn, fnStr, td) {\n var dt = fn();\n var st = fn.toString();\n var ks = st.slice(st.indexOf('[') + 1, st.lastIndexOf(']')).replace(/\\s+/g, '').split(',');\n for (var i = 0; i < dt.length; ++i) {\n var v = dt[i], k = ks[i];\n if (typeof v == 'function') {\n fnStr += ';' + k + '=';\n var st_1 = v.toString();\n if (v.prototype) {\n // for global objects\n if (st_1.indexOf('[native code]') != -1) {\n var spInd = st_1.indexOf(' ', 8) + 1;\n fnStr += st_1.slice(spInd, st_1.indexOf('(', spInd));\n }\n else {\n fnStr += st_1;\n for (var t in v.prototype)\n fnStr += ';' + k + '.prototype.' + t + '=' + v.prototype[t].toString();\n }\n }\n else\n fnStr += st_1;\n }\n else\n td[k] = v;\n }\n return fnStr;\n};\nvar ch = [];\n// clone bufs\nvar cbfs = function (v) {\n var tl = [];\n for (var k in v) {\n if (v[k].buffer) {\n tl.push((v[k] = new v[k].constructor(v[k])).buffer);\n }\n }\n return tl;\n};\n// use a worker to execute code\nvar wrkr = function (fns, init, id, cb) {\n if (!ch[id]) {\n var fnStr = '', td_1 = {}, m = fns.length - 1;\n for (var i = 0; i < m; ++i)\n fnStr = wcln(fns[i], fnStr, td_1);\n ch[id] = { c: wcln(fns[m], fnStr, td_1), e: td_1 };\n }\n var td = mrg({}, ch[id].e);\n return wk(ch[id].c + ';onmessage=function(e){for(var k in e.data)self[k]=e.data[k];onmessage=' + init.toString() + '}', id, td, cbfs(td), cb);\n};\n// base async inflate fn\nvar bInflt = function () { return [u8, u16, i32, fleb, fdeb, clim, fl, fd, flrm, fdrm, rev, ec, hMap, max, bits, bits16, shft, slc, err, inflt, inflateSync, pbf, gopt]; };\nvar bDflt = function () { return [u8, u16, i32, fleb, fdeb, clim, revfl, revfd, flm, flt, fdm, fdt, rev, deo, et, hMap, wbits, wbits16, hTree, ln, lc, clen, wfblk, wblk, shft, slc, dflt, dopt, deflateSync, pbf]; };\n// gzip extra\nvar gze = function () { return [gzh, gzhl, wbytes, crc, crct]; };\n// gunzip extra\nvar guze = function () { return [gzs, gzl]; };\n// zlib extra\nvar zle = function () { return [zlh, wbytes, adler]; };\n// unzlib extra\nvar zule = function () { return [zls]; };\n// post buf\nvar pbf = function (msg) { return postMessage(msg, [msg.buffer]); };\n// get opts\nvar gopt = function (o) { return o && {\n out: o.size && new u8(o.size),\n dictionary: o.dictionary\n}; };\n// async helper\nvar cbify = function (dat, opts, fns, init, id, cb) {\n var w = wrkr(fns, init, id, function (err, dat) {\n w.terminate();\n cb(err, dat);\n });\n w.postMessage([dat, opts], opts.consume ? [dat.buffer] : []);\n return function () { w.terminate(); };\n};\n// auto stream\nvar astrm = function (strm) {\n strm.ondata = function (dat, final) { return postMessage([dat, final], [dat.buffer]); };\n return function (ev) {\n if (ev.data.length) {\n strm.push(ev.data[0], ev.data[1]);\n postMessage([ev.data[0].length]);\n }\n else\n strm.flush();\n };\n};\n// async stream attach\nvar astrmify = function (fns, strm, opts, init, id, flush, ext) {\n var t;\n var w = wrkr(fns, init, id, function (err, dat) {\n if (err)\n w.terminate(), strm.ondata.call(strm, err);\n else if (!Array.isArray(dat))\n ext(dat);\n else if (dat.length == 1) {\n strm.queuedSize -= dat[0];\n if (strm.ondrain)\n strm.ondrain(dat[0]);\n }\n else {\n if (dat[1])\n w.terminate();\n strm.ondata.call(strm, err, dat[0], dat[1]);\n }\n });\n w.postMessage(opts);\n strm.queuedSize = 0;\n strm.push = function (d, f) {\n if (!strm.ondata)\n err(5);\n if (t)\n strm.ondata(err(4, 0, 1), null, !!f);\n strm.queuedSize += d.length;\n w.postMessage([d, t = f], [d.buffer]);\n };\n strm.terminate = function () { w.terminate(); };\n if (flush) {\n strm.flush = function () { w.postMessage([]); };\n }\n};\n// read 2 bytes\nvar b2 = function (d, b) { return d[b] | (d[b + 1] << 8); };\n// read 4 bytes\nvar b4 = function (d, b) { return (d[b] | (d[b + 1] << 8) | (d[b + 2] << 16) | (d[b + 3] << 24)) >>> 0; };\nvar b8 = function (d, b) { return b4(d, b) + (b4(d, b + 4) * 4294967296); };\n// write bytes\nvar wbytes = function (d, b, v) {\n for (; v; ++b)\n d[b] = v, v >>>= 8;\n};\n// gzip header\nvar gzh = function (c, o) {\n var fn = o.filename;\n c[0] = 31, c[1] = 139, c[2] = 8, c[8] = o.level < 2 ? 4 : o.level == 9 ? 2 : 0, c[9] = 3; // assume Unix\n if (o.mtime != 0)\n wbytes(c, 4, Math.floor(new Date(o.mtime || Date.now()) / 1000));\n if (fn) {\n c[3] = 8;\n for (var i = 0; i <= fn.length; ++i)\n c[i + 10] = fn.charCodeAt(i);\n }\n};\n// gzip footer: -8 to -4 = CRC, -4 to -0 is length\n// gzip start\nvar gzs = function (d) {\n if (d[0] != 31 || d[1] != 139 || d[2] != 8)\n err(6, 'invalid gzip data');\n var flg = d[3];\n var st = 10;\n if (flg & 4)\n st += (d[10] | d[11] << 8) + 2;\n for (var zs = (flg >> 3 & 1) + (flg >> 4 & 1); zs > 0; zs -= !d[st++])\n ;\n return st + (flg & 2);\n};\n// gzip length\nvar gzl = function (d) {\n var l = d.length;\n return (d[l - 4] | d[l - 3] << 8 | d[l - 2] << 16 | d[l - 1] << 24) >>> 0;\n};\n// gzip header length\nvar gzhl = function (o) { return 10 + (o.filename ? o.filename.length + 1 : 0); };\n// zlib header\nvar zlh = function (c, o) {\n var lv = o.level, fl = lv == 0 ? 0 : lv < 6 ? 1 : lv == 9 ? 3 : 2;\n c[0] = 120, c[1] = (fl << 6) | (o.dictionary && 32);\n c[1] |= 31 - ((c[0] << 8) | c[1]) % 31;\n if (o.dictionary) {\n var h = adler();\n h.p(o.dictionary);\n wbytes(c, 2, h.d());\n }\n};\n// zlib start\nvar zls = function (d, dict) {\n if ((d[0] & 15) != 8 || (d[0] >> 4) > 7 || ((d[0] << 8 | d[1]) % 31))\n err(6, 'invalid zlib data');\n if ((d[1] >> 5 & 1) == +!dict)\n err(6, 'invalid zlib data: ' + (d[1] & 32 ? 'need' : 'unexpected') + ' dictionary');\n return (d[1] >> 3 & 4) + 2;\n};\nfunction StrmOpt(opts, cb) {\n if (typeof opts == 'function')\n cb = opts, opts = {};\n this.ondata = cb;\n return opts;\n}\n/**\n * Streaming DEFLATE compression\n */\nvar Deflate = /*#__PURE__*/ (function () {\n function Deflate(opts, cb) {\n if (typeof opts == 'function')\n cb = opts, opts = {};\n this.ondata = cb;\n this.o = opts || {};\n this.s = { l: 0, i: 32768, w: 32768, z: 32768 };\n // Buffer length must always be 0 mod 32768 for index calculations to be correct when modifying head and prev\n // 98304 = 32768 (lookback) + 65536 (common chunk size)\n this.b = new u8(98304);\n if (this.o.dictionary) {\n var dict = this.o.dictionary.subarray(-32768);\n this.b.set(dict, 32768 - dict.length);\n this.s.i = 32768 - dict.length;\n }\n }\n Deflate.prototype.p = function (c, f) {\n this.ondata(dopt(c, this.o, 0, 0, this.s), f);\n };\n /**\n * Pushes a chunk to be deflated\n * @param chunk The chunk to push\n * @param final Whether this is the last chunk\n */\n Deflate.prototype.push = function (chunk, final) {\n if (!this.ondata)\n err(5);\n if (this.s.l)\n err(4);\n var endLen = chunk.length + this.s.z;\n if (endLen > this.b.length) {\n if (endLen > 2 * this.b.length - 32768) {\n var newBuf = new u8(endLen & -32768);\n newBuf.set(this.b.subarray(0, this.s.z));\n this.b = newBuf;\n }\n var split = this.b.length - this.s.z;\n this.b.set(chunk.subarray(0, split), this.s.z);\n this.s.z = this.b.length;\n this.p(this.b, false);\n this.b.set(this.b.subarray(-32768));\n this.b.set(chunk.subarray(split), 32768);\n this.s.z = chunk.length - split + 32768;\n this.s.i = 32766, this.s.w = 32768;\n }\n else {\n this.b.set(chunk, this.s.z);\n this.s.z += chunk.length;\n }\n this.s.l = final & 1;\n if (this.s.z > this.s.w + 8191 || final) {\n this.p(this.b, final || false);\n this.s.w = this.s.i, this.s.i -= 2;\n }\n };\n /**\n * Flushes buffered uncompressed data. Useful to immediately retrieve the\n * deflated output for small inputs.\n */\n Deflate.prototype.flush = function () {\n if (!this.ondata)\n err(5);\n if (this.s.l)\n err(4);\n this.p(this.b, false);\n this.s.w = this.s.i, this.s.i -= 2;\n };\n return Deflate;\n}());\nexport { Deflate };\n/**\n * Asynchronous streaming DEFLATE compression\n */\nvar AsyncDeflate = /*#__PURE__*/ (function () {\n function AsyncDeflate(opts, cb) {\n astrmify([\n bDflt,\n function () { return [astrm, Deflate]; }\n ], this, StrmOpt.call(this, opts, cb), function (ev) {\n var strm = new Deflate(ev.data);\n onmessage = astrm(strm);\n }, 6, 1);\n }\n return AsyncDeflate;\n}());\nexport { AsyncDeflate };\nexport function deflate(data, opts, cb) {\n if (!cb)\n cb = opts, opts = {};\n if (typeof cb != 'function')\n err(7);\n return cbify(data, opts, [\n bDflt,\n ], function (ev) { return pbf(deflateSync(ev.data[0], ev.data[1])); }, 0, cb);\n}\n/**\n * Compresses data with DEFLATE without any wrapper\n * @param data The data to compress\n * @param opts The compression options\n * @returns The deflated version of the data\n */\nexport function deflateSync(data, opts) {\n return dopt(data, opts || {}, 0, 0);\n}\n/**\n * Streaming DEFLATE decompression\n */\nvar Inflate = /*#__PURE__*/ (function () {\n function Inflate(opts, cb) {\n // no StrmOpt here to avoid adding to workerizer\n if (typeof opts == 'function')\n cb = opts, opts = {};\n this.ondata = cb;\n var dict = opts && opts.dictionary && opts.dictionary.subarray(-32768);\n this.s = { i: 0, b: dict ? dict.length : 0 };\n this.o = new u8(32768);\n this.p = new u8(0);\n if (dict)\n this.o.set(dict);\n }\n Inflate.prototype.e = function (c) {\n if (!this.ondata)\n err(5);\n if (this.d)\n err(4);\n if (!this.p.length)\n this.p = c;\n else if (c.length) {\n var n = new u8(this.p.length + c.length);\n n.set(this.p), n.set(c, this.p.length), this.p = n;\n }\n };\n Inflate.prototype.c = function (final) {\n this.s.i = +(this.d = final || false);\n var bts = this.s.b;\n var dt = inflt(this.p, this.s, this.o);\n this.ondata(slc(dt, bts, this.s.b), this.d);\n this.o = slc(dt, this.s.b - 32768), this.s.b = this.o.length;\n this.p = slc(this.p, (this.s.p / 8) | 0), this.s.p &= 7;\n };\n /**\n * Pushes a chunk to be inflated\n * @param chunk The chunk to push\n * @param final Whether this is the final chunk\n */\n Inflate.prototype.push = function (chunk, final) {\n this.e(chunk), this.c(final);\n };\n return Inflate;\n}());\nexport { Inflate };\n/**\n * Asynchronous streaming DEFLATE decompression\n */\nvar AsyncInflate = /*#__PURE__*/ (function () {\n function AsyncInflate(opts, cb) {\n astrmify([\n bInflt,\n function () { return [astrm, Inflate]; }\n ], this, StrmOpt.call(this, opts, cb), function (ev) {\n var strm = new Inflate(ev.data);\n onmessage = astrm(strm);\n }, 7, 0);\n }\n return AsyncInflate;\n}());\nexport { AsyncInflate };\nexport function inflate(data, opts, cb) {\n if (!cb)\n cb = opts, opts = {};\n if (typeof cb != 'function')\n err(7);\n return cbify(data, opts, [\n bInflt\n ], function (ev) { return pbf(inflateSync(ev.data[0], gopt(ev.data[1]))); }, 1, cb);\n}\n/**\n * Expands DEFLATE data with no wrapper\n * @param data The data to decompress\n * @param opts The decompression options\n * @returns The decompressed version of the data\n */\nexport function inflateSync(data, opts) {\n return inflt(data, { i: 2 }, opts && opts.out, opts && opts.dictionary);\n}\n// before you yell at me for not just using extends, my reason is that TS inheritance is hard to workerize.\n/**\n * Streaming GZIP compression\n */\nvar Gzip = /*#__PURE__*/ (function () {\n function Gzip(opts, cb) {\n this.c = crc();\n this.l = 0;\n this.v = 1;\n Deflate.call(this, opts, cb);\n }\n /**\n * Pushes a chunk to be GZIPped\n * @param chunk The chunk to push\n * @param final Whether this is the last chunk\n */\n Gzip.prototype.push = function (chunk, final) {\n this.c.p(chunk);\n this.l += chunk.length;\n Deflate.prototype.push.call(this, chunk, final);\n };\n Gzip.prototype.p = function (c, f) {\n var raw = dopt(c, this.o, this.v && gzhl(this.o), f && 8, this.s);\n if (this.v)\n gzh(raw, this.o), this.v = 0;\n if (f)\n wbytes(raw, raw.length - 8, this.c.d()), wbytes(raw, raw.length - 4, this.l);\n this.ondata(raw, f);\n };\n /**\n * Flushes buffered uncompressed data. Useful to immediately retrieve the\n * GZIPped output for small inputs.\n */\n Gzip.prototype.flush = function () {\n Deflate.prototype.flush.call(this);\n };\n return Gzip;\n}());\nexport { Gzip };\n/**\n * Asynchronous streaming GZIP compression\n */\nvar AsyncGzip = /*#__PURE__*/ (function () {\n function AsyncGzip(opts, cb) {\n astrmify([\n bDflt,\n gze,\n function () { return [astrm, Deflate, Gzip]; }\n ], this, StrmOpt.call(this, opts, cb), function (ev) {\n var strm = new Gzip(ev.data);\n onmessage = astrm(strm);\n }, 8, 1);\n }\n return AsyncGzip;\n}());\nexport { AsyncGzip };\nexport function gzip(data, opts, cb) {\n if (!cb)\n cb = opts, opts = {};\n if (typeof cb != 'function')\n err(7);\n return cbify(data, opts, [\n bDflt,\n gze,\n function () { return [gzipSync]; }\n ], function (ev) { return pbf(gzipSync(ev.data[0], ev.data[1])); }, 2, cb);\n}\n/**\n * Compresses data with GZIP\n * @param data The data to compress\n * @param opts The compression options\n * @returns The gzipped version of the data\n */\nexport function gzipSync(data, opts) {\n if (!opts)\n opts = {};\n var c = crc(), l = data.length;\n c.p(data);\n var d = dopt(data, opts, gzhl(opts), 8), s = d.length;\n return gzh(d, opts), wbytes(d, s - 8, c.d()), wbytes(d, s - 4, l), d;\n}\n/**\n * Streaming single or multi-member GZIP decompression\n */\nvar Gunzip = /*#__PURE__*/ (function () {\n function Gunzip(opts, cb) {\n this.v = 1;\n this.r = 0;\n Inflate.call(this, opts, cb);\n }\n /**\n * Pushes a chunk to be GUNZIPped\n * @param chunk The chunk to push\n * @param final Whether this is the last chunk\n */\n Gunzip.prototype.push = function (chunk, final) {\n Inflate.prototype.e.call(this, chunk);\n this.r += chunk.length;\n if (this.v) {\n var p = this.p.subarray(this.v - 1);\n var s = p.length > 3 ? gzs(p) : 4;\n if (s > p.length) {\n if (!final)\n return;\n }\n else if (this.v > 1 && this.onmember) {\n this.onmember(this.r - p.length);\n }\n this.p = p.subarray(s), this.v = 0;\n }\n // necessary to prevent TS from using the closure value\n // This allows for workerization to function correctly\n Inflate.prototype.c.call(this, final);\n // process concatenated GZIP\n if (this.s.f && !this.s.l && !final) {\n this.v = shft(this.s.p) + 9;\n this.s = { i: 0 };\n this.o = new u8(0);\n this.push(new u8(0), final);\n }\n };\n return Gunzip;\n}());\nexport { Gunzip };\n/**\n * Asynchronous streaming single or multi-member GZIP decompression\n */\nvar AsyncGunzip = /*#__PURE__*/ (function () {\n function AsyncGunzip(opts, cb) {\n var _this = this;\n astrmify([\n bInflt,\n guze,\n function () { return [astrm, Inflate, Gunzip]; }\n ], this, StrmOpt.call(this, opts, cb), function (ev) {\n var strm = new Gunzip(ev.data);\n strm.onmember = function (offset) { return postMessage(offset); };\n onmessage = astrm(strm);\n }, 9, 0, function (offset) { return _this.onmember && _this.onmember(offset); });\n }\n return AsyncGunzip;\n}());\nexport { AsyncGunzip };\nexport function gunzip(data, opts, cb) {\n if (!cb)\n cb = opts, opts = {};\n if (typeof cb != 'function')\n err(7);\n return cbify(data, opts, [\n bInflt,\n guze,\n function () { return [gunzipSync]; }\n ], function (ev) { return pbf(gunzipSync(ev.data[0], ev.data[1])); }, 3, cb);\n}\n/**\n * Expands GZIP data\n * @param data The data to decompress\n * @param opts The decompression options\n * @returns The decompressed version of the data\n */\nexport function gunzipSync(data, opts) {\n var st = gzs(data);\n if (st + 8 > data.length)\n err(6, 'invalid gzip data');\n return inflt(data.subarray(st, -8), { i: 2 }, opts && opts.out || new u8(gzl(data)), opts && opts.dictionary);\n}\n/**\n * Streaming Zlib compression\n */\nvar Zlib = /*#__PURE__*/ (function () {\n function Zlib(opts, cb) {\n this.c = adler();\n this.v = 1;\n Deflate.call(this, opts, cb);\n }\n /**\n * Pushes a chunk to be zlibbed\n * @param chunk The chunk to push\n * @param final Whether this is the last chunk\n */\n Zlib.prototype.push = function (chunk, final) {\n this.c.p(chunk);\n Deflate.prototype.push.call(this, chunk, final);\n };\n Zlib.prototype.p = function (c, f) {\n var raw = dopt(c, this.o, this.v && (this.o.dictionary ? 6 : 2), f && 4, this.s);\n if (this.v)\n zlh(raw, this.o), this.v = 0;\n if (f)\n wbytes(raw, raw.length - 4, this.c.d());\n this.ondata(raw, f);\n };\n /**\n * Flushes buffered uncompressed data. Useful to immediately retrieve the\n * zlibbed output for small inputs.\n */\n Zlib.prototype.flush = function () {\n Deflate.prototype.flush.call(this);\n };\n return Zlib;\n}());\nexport { Zlib };\n/**\n * Asynchronous streaming Zlib compression\n */\nvar AsyncZlib = /*#__PURE__*/ (function () {\n function AsyncZlib(opts, cb) {\n astrmify([\n bDflt,\n zle,\n function () { return [astrm, Deflate, Zlib]; }\n ], this, StrmOpt.call(this, opts, cb), function (ev) {\n var strm = new Zlib(ev.data);\n onmessage = astrm(strm);\n }, 10, 1);\n }\n return AsyncZlib;\n}());\nexport { AsyncZlib };\nexport function zlib(data, opts, cb) {\n if (!cb)\n cb = opts, opts = {};\n if (typeof cb != 'function')\n err(7);\n return cbify(data, opts, [\n bDflt,\n zle,\n function () { return [zlibSync]; }\n ], function (ev) { return pbf(zlibSync(ev.data[0], ev.data[1])); }, 4, cb);\n}\n/**\n * Compress data with Zlib\n * @param data The data to compress\n * @param opts The compression options\n * @returns The zlib-compressed version of the data\n */\nexport function zlibSync(data, opts) {\n if (!opts)\n opts = {};\n var a = adler();\n a.p(data);\n var d = dopt(data, opts, opts.dictionary ? 6 : 2, 4);\n return zlh(d, opts), wbytes(d, d.length - 4, a.d()), d;\n}\n/**\n * Streaming Zlib decompression\n */\nvar Unzlib = /*#__PURE__*/ (function () {\n function Unzlib(opts, cb) {\n Inflate.call(this, opts, cb);\n this.v = opts && opts.dictionary ? 2 : 1;\n }\n /**\n * Pushes a chunk to be unzlibbed\n * @param chunk The chunk to push\n * @param final Whether this is the last chunk\n */\n Unzlib.prototype.push = function (chunk, final) {\n Inflate.prototype.e.call(this, chunk);\n if (this.v) {\n if (this.p.length < 6 && !final)\n return;\n this.p = this.p.subarray(zls(this.p, this.v - 1)), this.v = 0;\n }\n if (final) {\n if (this.p.length < 4)\n err(6, 'invalid zlib data');\n this.p = this.p.subarray(0, -4);\n }\n // necessary to prevent TS from using the closure value\n // This allows for workerization to function correctly\n Inflate.prototype.c.call(this, final);\n };\n return Unzlib;\n}());\nexport { Unzlib };\n/**\n * Asynchronous streaming Zlib decompression\n */\nvar AsyncUnzlib = /*#__PURE__*/ (function () {\n function AsyncUnzlib(opts, cb) {\n astrmify([\n bInflt,\n zule,\n function () { return [astrm, Inflate, Unzlib]; }\n ], this, StrmOpt.call(this, opts, cb), function (ev) {\n var strm = new Unzlib(ev.data);\n onmessage = astrm(strm);\n }, 11, 0);\n }\n return AsyncUnzlib;\n}());\nexport { AsyncUnzlib };\nexport function unzlib(data, opts, cb) {\n if (!cb)\n cb = opts, opts = {};\n if (typeof cb != 'function')\n err(7);\n return cbify(data, opts, [\n bInflt,\n zule,\n function () { return [unzlibSync]; }\n ], function (ev) { return pbf(unzlibSync(ev.data[0], gopt(ev.data[1]))); }, 5, cb);\n}\n/**\n * Expands Zlib data\n * @param data The data to decompress\n * @param opts The decompression options\n * @returns The decompressed version of the data\n */\nexport function unzlibSync(data, opts) {\n return inflt(data.subarray(zls(data, opts && opts.dictionary), -4), { i: 2 }, opts && opts.out, opts && opts.dictionary);\n}\n// Default algorithm for compression (used because having a known output size allows faster decompression)\nexport { gzip as compress, AsyncGzip as AsyncCompress };\nexport { gzipSync as compressSync, Gzip as Compress };\n/**\n * Streaming GZIP, Zlib, or raw DEFLATE decompression\n */\nvar Decompress = /*#__PURE__*/ (function () {\n function Decompress(opts, cb) {\n this.o = StrmOpt.call(this, opts, cb) || {};\n this.G = Gunzip;\n this.I = Inflate;\n this.Z = Unzlib;\n }\n // init substream\n // overriden by AsyncDecompress\n Decompress.prototype.i = function () {\n var _this = this;\n this.s.ondata = function (dat, final) {\n _this.ondata(dat, final);\n };\n };\n /**\n * Pushes a chunk to be decompressed\n * @param chunk The chunk to push\n * @param final Whether this is the last chunk\n */\n Decompress.prototype.push = function (chunk, final) {\n if (!this.ondata)\n err(5);\n if (!this.s) {\n if (this.p && this.p.length) {\n var n = new u8(this.p.length + chunk.length);\n n.set(this.p), n.set(chunk, this.p.length);\n }\n else\n this.p = chunk;\n if (this.p.length > 2) {\n this.s = (this.p[0] == 31 && this.p[1] == 139 && this.p[2] == 8)\n ? new this.G(this.o)\n : ((this.p[0] & 15) != 8 || (this.p[0] >> 4) > 7 || ((this.p[0] << 8 | this.p[1]) % 31))\n ? new this.I(this.o)\n : new this.Z(this.o);\n this.i();\n this.s.push(this.p, final);\n this.p = null;\n }\n }\n else\n this.s.push(chunk, final);\n };\n return Decompress;\n}());\nexport { Decompress };\n/**\n * Asynchronous streaming GZIP, Zlib, or raw DEFLATE decompression\n */\nvar AsyncDecompress = /*#__PURE__*/ (function () {\n function AsyncDecompress(opts, cb) {\n Decompress.call(this, opts, cb);\n this.queuedSize = 0;\n this.G = AsyncGunzip;\n this.I = AsyncInflate;\n this.Z = AsyncUnzlib;\n }\n AsyncDecompress.prototype.i = function () {\n var _this = this;\n this.s.ondata = function (err, dat, final) {\n _this.ondata(err, dat, final);\n };\n this.s.ondrain = function (size) {\n _this.queuedSize -= size;\n if (_this.ondrain)\n _this.ondrain(size);\n };\n };\n /**\n * Pushes a chunk to be decompressed\n * @param chunk The chunk to push\n * @param final Whether this is the last chunk\n */\n AsyncDecompress.prototype.push = function (chunk, final) {\n this.queuedSize += chunk.length;\n Decompress.prototype.push.call(this, chunk, final);\n };\n return AsyncDecompress;\n}());\nexport { AsyncDecompress };\nexport function decompress(data, opts, cb) {\n if (!cb)\n cb = opts, opts = {};\n if (typeof cb != 'function')\n err(7);\n return (data[0] == 31 && data[1] == 139 && data[2] == 8)\n ? gunzip(data, opts, cb)\n : ((data[0] & 15) != 8 || (data[0] >> 4) > 7 || ((data[0] << 8 | data[1]) % 31))\n ? inflate(data, opts, cb)\n : unzlib(data, opts, cb);\n}\n/**\n * Expands compressed GZIP, Zlib, or raw DEFLATE data, automatically detecting the format\n * @param data The data to decompress\n * @param opts The decompression options\n * @returns The decompressed version of the data\n */\nexport function decompressSync(data, opts) {\n return (data[0] == 31 && data[1] == 139 && data[2] == 8)\n ? gunzipSync(data, opts)\n : ((data[0] & 15) != 8 || (data[0] >> 4) > 7 || ((data[0] << 8 | data[1]) % 31))\n ? inflateSync(data, opts)\n : unzlibSync(data, opts);\n}\n// flatten a directory structure\nvar fltn = function (d, p, t, o) {\n for (var k in d) {\n var val = d[k], n = p + k, op = o;\n if (Array.isArray(val))\n op = mrg(o, val[1]), val = val[0];\n if (val instanceof u8)\n t[n] = [val, op];\n else {\n t[n += '/'] = [new u8(0), op];\n fltn(val, n, t, o);\n }\n }\n};\n// text encoder\nvar te = typeof TextEncoder != 'undefined' && /*#__PURE__*/ new TextEncoder();\n// text decoder\nvar td = typeof TextDecoder != 'undefined' && /*#__PURE__*/ new TextDecoder();\n// text decoder stream\nvar tds = 0;\ntry {\n td.decode(et, { stream: true });\n tds = 1;\n}\ncatch (e) { }\n// decode UTF8\nvar dutf8 = function (d) {\n for (var r = '', i = 0;;) {\n var c = d[i++];\n var eb = (c > 127) + (c > 223) + (c > 239);\n if (i + eb > d.length)\n return { s: r, r: slc(d, i - 1) };\n if (!eb)\n r += String.fromCharCode(c);\n else if (eb == 3) {\n c = ((c & 15) << 18 | (d[i++] & 63) << 12 | (d[i++] & 63) << 6 | (d[i++] & 63)) - 65536,\n r += String.fromCharCode(55296 | (c >> 10), 56320 | (c & 1023));\n }\n else if (eb & 1)\n r += String.fromCharCode((c & 31) << 6 | (d[i++] & 63));\n else\n r += String.fromCharCode((c & 15) << 12 | (d[i++] & 63) << 6 | (d[i++] & 63));\n }\n};\n/**\n * Streaming UTF-8 decoding\n */\nvar DecodeUTF8 = /*#__PURE__*/ (function () {\n /**\n * Creates a UTF-8 decoding stream\n * @param cb The callback to call whenever data is decoded\n */\n function DecodeUTF8(cb) {\n this.ondata = cb;\n if (tds)\n this.t = new TextDecoder();\n else\n this.p = et;\n }\n /**\n * Pushes a chunk to be decoded from UTF-8 binary\n * @param chunk The chunk to push\n * @param final Whether this is the last chunk\n */\n DecodeUTF8.prototype.push = function (chunk, final) {\n if (!this.ondata)\n err(5);\n final = !!final;\n if (this.t) {\n this.ondata(this.t.decode(chunk, { stream: true }), final);\n if (final) {\n if (this.t.decode().length)\n err(8);\n this.t = null;\n }\n return;\n }\n if (!this.p)\n err(4);\n var dat = new u8(this.p.length + chunk.length);\n dat.set(this.p);\n dat.set(chunk, this.p.length);\n var _a = dutf8(dat), s = _a.s, r = _a.r;\n if (final) {\n if (r.length)\n err(8);\n this.p = null;\n }\n else\n this.p = r;\n this.ondata(s, final);\n };\n return DecodeUTF8;\n}());\nexport { DecodeUTF8 };\n/**\n * Streaming UTF-8 encoding\n */\nvar EncodeUTF8 = /*#__PURE__*/ (function () {\n /**\n * Creates a UTF-8 decoding stream\n * @param cb The callback to call whenever data is encoded\n */\n function EncodeUTF8(cb) {\n this.ondata = cb;\n }\n /**\n * Pushes a chunk to be encoded to UTF-8\n * @param chunk The string data to push\n * @param final Whether this is the last chunk\n */\n EncodeUTF8.prototype.push = function (chunk, final) {\n if (!this.ondata)\n err(5);\n if (this.d)\n err(4);\n this.ondata(strToU8(chunk), this.d = final || false);\n };\n return EncodeUTF8;\n}());\nexport { EncodeUTF8 };\n/**\n * Converts a string into a Uint8Array for use with compression/decompression methods\n * @param str The string to encode\n * @param latin1 Whether or not to interpret the data as Latin-1. This should\n * not need to be true unless decoding a binary string.\n * @returns The string encoded in UTF-8/Latin-1 binary\n */\nexport function strToU8(str, latin1) {\n if (latin1) {\n var ar_1 = new u8(str.length);\n for (var i = 0; i < str.length; ++i)\n ar_1[i] = str.charCodeAt(i);\n return ar_1;\n }\n if (te)\n return te.encode(str);\n var l = str.length;\n var ar = new u8(str.length + (str.length >> 1));\n var ai = 0;\n var w = function (v) { ar[ai++] = v; };\n for (var i = 0; i < l; ++i) {\n if (ai + 5 > ar.length) {\n var n = new u8(ai + 8 + ((l - i) << 1));\n n.set(ar);\n ar = n;\n }\n var c = str.charCodeAt(i);\n if (c < 128 || latin1)\n w(c);\n else if (c < 2048)\n w(192 | (c >> 6)), w(128 | (c & 63));\n else if (c > 55295 && c < 57344)\n c = 65536 + (c & 1023 << 10) | (str.charCodeAt(++i) & 1023),\n w(240 | (c >> 18)), w(128 | ((c >> 12) & 63)), w(128 | ((c >> 6) & 63)), w(128 | (c & 63));\n else\n w(224 | (c >> 12)), w(128 | ((c >> 6) & 63)), w(128 | (c & 63));\n }\n return slc(ar, 0, ai);\n}\n/**\n * Converts a Uint8Array to a string\n * @param dat The data to decode to string\n * @param latin1 Whether or not to interpret the data as Latin-1. This should\n * not need to be true unless encoding to binary string.\n * @returns The original UTF-8/Latin-1 string\n */\nexport function strFromU8(dat, latin1) {\n if (latin1) {\n var r = '';\n for (var i = 0; i < dat.length; i += 16384)\n r += String.fromCharCode.apply(null, dat.subarray(i, i + 16384));\n return r;\n }\n else if (td) {\n return td.decode(dat);\n }\n else {\n var _a = dutf8(dat), s = _a.s, r = _a.r;\n if (r.length)\n err(8);\n return s;\n }\n}\n;\n// deflate bit flag\nvar dbf = function (l) { return l == 1 ? 3 : l < 6 ? 2 : l == 9 ? 1 : 0; };\n// skip local zip header\nvar slzh = function (d, b) { return b + 30 + b2(d, b + 26) + b2(d, b + 28); };\n// read zip header\nvar zh = function (d, b, z) {\n var fnl = b2(d, b + 28), fn = strFromU8(d.subarray(b + 46, b + 46 + fnl), !(b2(d, b + 8) & 2048)), es = b + 46 + fnl, bs = b4(d, b + 20);\n var _a = z && bs == 4294967295 ? z64e(d, es) : [bs, b4(d, b + 24), b4(d, b + 42)], sc = _a[0], su = _a[1], off = _a[2];\n return [b2(d, b + 10), sc, su, fn, es + b2(d, b + 30) + b2(d, b + 32), off];\n};\n// read zip64 extra field\nvar z64e = function (d, b) {\n for (; b2(d, b) != 1; b += 4 + b2(d, b + 2))\n ;\n return [b8(d, b + 12), b8(d, b + 4), b8(d, b + 20)];\n};\n// extra field length\nvar exfl = function (ex) {\n var le = 0;\n if (ex) {\n for (var k in ex) {\n var l = ex[k].length;\n if (l > 65535)\n err(9);\n le += l + 4;\n }\n }\n return le;\n};\n// write zip header\nvar wzh = function (d, b, f, fn, u, c, ce, co) {\n var fl = fn.length, ex = f.extra, col = co && co.length;\n var exl = exfl(ex);\n wbytes(d, b, ce != null ? 0x2014B50 : 0x4034B50), b += 4;\n if (ce != null)\n d[b++] = 20, d[b++] = f.os;\n d[b] = 20, b += 2; // spec compliance? what's that?\n d[b++] = (f.flag << 1) | (c < 0 && 8), d[b++] = u && 8;\n d[b++] = f.compression & 255, d[b++] = f.compression >> 8;\n var dt = new Date(f.mtime == null ? Date.now() : f.mtime), y = dt.getFullYear() - 1980;\n if (y < 0 || y > 119)\n err(10);\n wbytes(d, b, (y << 25) | ((dt.getMonth() + 1) << 21) | (dt.getDate() << 16) | (dt.getHours() << 11) | (dt.getMinutes() << 5) | (dt.getSeconds() >> 1)), b += 4;\n if (c != -1) {\n wbytes(d, b, f.crc);\n wbytes(d, b + 4, c < 0 ? -c - 2 : c);\n wbytes(d, b + 8, f.size);\n }\n wbytes(d, b + 12, fl);\n wbytes(d, b + 14, exl), b += 16;\n if (ce != null) {\n wbytes(d, b, col);\n wbytes(d, b + 6, f.attrs);\n wbytes(d, b + 10, ce), b += 14;\n }\n d.set(fn, b);\n b += fl;\n if (exl) {\n for (var k in ex) {\n var exf = ex[k], l = exf.length;\n wbytes(d, b, +k);\n wbytes(d, b + 2, l);\n d.set(exf, b + 4), b += 4 + l;\n }\n }\n if (col)\n d.set(co, b), b += col;\n return b;\n};\n// write zip footer (end of central directory)\nvar wzf = function (o, b, c, d, e) {\n wbytes(o, b, 0x6054B50); // skip disk\n wbytes(o, b + 8, c);\n wbytes(o, b + 10, c);\n wbytes(o, b + 12, d);\n wbytes(o, b + 16, e);\n};\n/**\n * A pass-through stream to keep data uncompressed in a ZIP archive.\n */\nvar ZipPassThrough = /*#__PURE__*/ (function () {\n /**\n * Creates a pass-through stream that can be added to ZIP archives\n * @param filename The filename to associate with this data stream\n */\n function ZipPassThrough(filename) {\n this.filename = filename;\n this.c = crc();\n this.size = 0;\n this.compression = 0;\n }\n /**\n * Processes a chunk and pushes to the output stream. You can override this\n * method in a subclass for custom behavior, but by default this passes\n * the data through. You must call this.ondata(err, chunk, final) at some\n * point in this method.\n * @param chunk The chunk to process\n * @param final Whether this is the last chunk\n */\n ZipPassThrough.prototype.process = function (chunk, final) {\n this.ondata(null, chunk, final);\n };\n /**\n * Pushes a chunk to be added. If you are subclassing this with a custom\n * compression algorithm, note that you must push data from the source\n * file only, pre-compression.\n * @param chunk The chunk to push\n * @param final Whether this is the last chunk\n */\n ZipPassThrough.prototype.push = function (chunk, final) {\n if (!this.ondata)\n err(5);\n this.c.p(chunk);\n this.size += chunk.length;\n if (final)\n this.crc = this.c.d();\n this.process(chunk, final || false);\n };\n return ZipPassThrough;\n}());\nexport { ZipPassThrough };\n// I don't extend because TypeScript extension adds 1kB of runtime bloat\n/**\n * Streaming DEFLATE compression for ZIP archives. Prefer using AsyncZipDeflate\n * for better performance\n */\nvar ZipDeflate = /*#__PURE__*/ (function () {\n /**\n * Creates a DEFLATE stream that can be added to ZIP archives\n * @param filename The filename to associate with this data stream\n * @param opts The compression options\n */\n function ZipDeflate(filename, opts) {\n var _this = this;\n if (!opts)\n opts = {};\n ZipPassThrough.call(this, filename);\n this.d = new Deflate(opts, function (dat, final) {\n _this.ondata(null, dat, final);\n });\n this.compression = 8;\n this.flag = dbf(opts.level);\n }\n ZipDeflate.prototype.process = function (chunk, final) {\n try {\n this.d.push(chunk, final);\n }\n catch (e) {\n this.ondata(e, null, final);\n }\n };\n /**\n * Pushes a chunk to be deflated\n * @param chunk The chunk to push\n * @param final Whether this is the last chunk\n */\n ZipDeflate.prototype.push = function (chunk, final) {\n ZipPassThrough.prototype.push.call(this, chunk, final);\n };\n return ZipDeflate;\n}());\nexport { ZipDeflate };\n/**\n * Asynchronous streaming DEFLATE compression for ZIP archives\n */\nvar AsyncZipDeflate = /*#__PURE__*/ (function () {\n /**\n * Creates an asynchronous DEFLATE stream that can be added to ZIP archives\n * @param filename The filename to associate with this data stream\n * @param opts The compression options\n */\n function AsyncZipDeflate(filename, opts) {\n var _this = this;\n if (!opts)\n opts = {};\n ZipPassThrough.call(this, filename);\n this.d = new AsyncDeflate(opts, function (err, dat, final) {\n _this.ondata(err, dat, final);\n });\n this.compression = 8;\n this.flag = dbf(opts.level);\n this.terminate = this.d.terminate;\n }\n AsyncZipDeflate.prototype.process = function (chunk, final) {\n this.d.push(chunk, final);\n };\n /**\n * Pushes a chunk to be deflated\n * @param chunk The chunk to push\n * @param final Whether this is the last chunk\n */\n AsyncZipDeflate.prototype.push = function (chunk, final) {\n ZipPassThrough.prototype.push.call(this, chunk, final);\n };\n return AsyncZipDeflate;\n}());\nexport { AsyncZipDeflate };\n// TODO: Better tree shaking\n/**\n * A zippable archive to which files can incrementally be added\n */\nvar Zip = /*#__PURE__*/ (function () {\n /**\n * Creates an empty ZIP archive to which files can be added\n * @param cb The callback to call whenever data for the generated ZIP archive\n * is available\n */\n function Zip(cb) {\n this.ondata = cb;\n this.u = [];\n this.d = 1;\n }\n /**\n * Adds a file to the ZIP archive\n * @param file The file stream to add\n */\n Zip.prototype.add = function (file) {\n var _this = this;\n if (!this.ondata)\n err(5);\n // finishing or finished\n if (this.d & 2)\n this.ondata(err(4 + (this.d & 1) * 8, 0, 1), null, false);\n else {\n var f = strToU8(file.filename), fl_1 = f.length;\n var com = file.comment, o = com && strToU8(com);\n var u = fl_1 != file.filename.length || (o && (com.length != o.length));\n var hl_1 = fl_1 + exfl(file.extra) + 30;\n if (fl_1 > 65535)\n this.ondata(err(11, 0, 1), null, false);\n var header = new u8(hl_1);\n wzh(header, 0, file, f, u, -1);\n var chks_1 = [header];\n var pAll_1 = function () {\n for (var _i = 0, chks_2 = chks_1; _i < chks_2.length; _i++) {\n var chk = chks_2[_i];\n _this.ondata(null, chk, false);\n }\n chks_1 = [];\n };\n var tr_1 = this.d;\n this.d = 0;\n var ind_1 = this.u.length;\n var uf_1 = mrg(file, {\n f: f,\n u: u,\n o: o,\n t: function () {\n if (file.terminate)\n file.terminate();\n },\n r: function () {\n pAll_1();\n if (tr_1) {\n var nxt = _this.u[ind_1 + 1];\n if (nxt)\n nxt.r();\n else\n _this.d = 1;\n }\n tr_1 = 1;\n }\n });\n var cl_1 = 0;\n file.ondata = function (err, dat, final) {\n if (err) {\n _this.ondata(err, dat, final);\n _this.terminate();\n }\n else {\n cl_1 += dat.length;\n chks_1.push(dat);\n if (final) {\n var dd = new u8(16);\n wbytes(dd, 0, 0x8074B50);\n wbytes(dd, 4, file.crc);\n wbytes(dd, 8, cl_1);\n wbytes(dd, 12, file.size);\n chks_1.push(dd);\n uf_1.c = cl_1, uf_1.b = hl_1 + cl_1 + 16, uf_1.crc = file.crc, uf_1.size = file.size;\n if (tr_1)\n uf_1.r();\n tr_1 = 1;\n }\n else if (tr_1)\n pAll_1();\n }\n };\n this.u.push(uf_1);\n }\n };\n /**\n * Ends the process of adding files and prepares to emit the final chunks.\n * This *must* be called after adding all desired files for the resulting\n * ZIP file to work properly.\n */\n Zip.prototype.end = function () {\n var _this = this;\n if (this.d & 2) {\n this.ondata(err(4 + (this.d & 1) * 8, 0, 1), null, true);\n return;\n }\n if (this.d)\n this.e();\n else\n this.u.push({\n r: function () {\n if (!(_this.d & 1))\n return;\n _this.u.splice(-1, 1);\n _this.e();\n },\n t: function () { }\n });\n this.d = 3;\n };\n Zip.prototype.e = function () {\n var bt = 0, l = 0, tl = 0;\n for (var _i = 0, _a = this.u; _i < _a.length; _i++) {\n var f = _a[_i];\n tl += 46 + f.f.length + exfl(f.extra) + (f.o ? f.o.length : 0);\n }\n var out = new u8(tl + 22);\n for (var _b = 0, _c = this.u; _b < _c.length; _b++) {\n var f = _c[_b];\n wzh(out, bt, f, f.f, f.u, -f.c - 2, l, f.o);\n bt += 46 + f.f.length + exfl(f.extra) + (f.o ? f.o.length : 0), l += f.b;\n }\n wzf(out, bt, this.u.length, tl, l);\n this.ondata(null, out, true);\n this.d = 2;\n };\n /**\n * A method to terminate any internal workers used by the stream. Subsequent\n * calls to add() will fail.\n */\n Zip.prototype.terminate = function () {\n for (var _i = 0, _a = this.u; _i < _a.length; _i++) {\n var f = _a[_i];\n f.t();\n }\n this.d = 2;\n };\n return Zip;\n}());\nexport { Zip };\nexport function zip(data, opts, cb) {\n if (!cb)\n cb = opts, opts = {};\n if (typeof cb != 'function')\n err(7);\n var r = {};\n fltn(data, '', r, opts);\n var k = Object.keys(r);\n var lft = k.length, o = 0, tot = 0;\n var slft = lft, files = new Array(lft);\n var term = [];\n var tAll = function () {\n for (var i = 0; i < term.length; ++i)\n term[i]();\n };\n var cbd = function (a, b) {\n mt(function () { cb(a, b); });\n };\n mt(function () { cbd = cb; });\n var cbf = function () {\n var out = new u8(tot + 22), oe = o, cdl = tot - o;\n tot = 0;\n for (var i = 0; i < slft; ++i) {\n var f = files[i];\n try {\n var l = f.c.length;\n wzh(out, tot, f, f.f, f.u, l);\n var badd = 30 + f.f.length + exfl(f.extra);\n var loc = tot + badd;\n out.set(f.c, loc);\n wzh(out, o, f, f.f, f.u, l, tot, f.m), o += 16 + badd + (f.m ? f.m.length : 0), tot = loc + l;\n }\n catch (e) {\n return cbd(e, null);\n }\n }\n wzf(out, o, files.length, cdl, oe);\n cbd(null, out);\n };\n if (!lft)\n cbf();\n var _loop_1 = function (i) {\n var fn = k[i];\n var _a = r[fn], file = _a[0], p = _a[1];\n var c = crc(), size = file.length;\n c.p(file);\n var f = strToU8(fn), s = f.length;\n var com = p.comment, m = com && strToU8(com), ms = m && m.length;\n var exl = exfl(p.extra);\n var compression = p.level == 0 ? 0 : 8;\n var cbl = function (e, d) {\n if (e) {\n tAll();\n cbd(e, null);\n }\n else {\n var l = d.length;\n files[i] = mrg(p, {\n size: size,\n crc: c.d(),\n c: d,\n f: f,\n m: m,\n u: s != fn.length || (m && (com.length != ms)),\n compression: compression\n });\n o += 30 + s + exl + l;\n tot += 76 + 2 * (s + exl) + (ms || 0) + l;\n if (!--lft)\n cbf();\n }\n };\n if (s > 65535)\n cbl(err(11, 0, 1), null);\n if (!compression)\n cbl(null, file);\n else if (size < 160000) {\n try {\n cbl(null, deflateSync(file, p));\n }\n catch (e) {\n cbl(e, null);\n }\n }\n else\n term.push(deflate(file, p, cbl));\n };\n // Cannot use lft because it can decrease\n for (var i = 0; i < slft; ++i) {\n _loop_1(i);\n }\n return tAll;\n}\n/**\n * Synchronously creates a ZIP file. Prefer using `zip` for better performance\n * with more than one file.\n * @param data The directory structure for the ZIP archive\n * @param opts The main options, merged with per-file options\n * @returns The generated ZIP archive\n */\nexport function zipSync(data, opts) {\n if (!opts)\n opts = {};\n var r = {};\n var files = [];\n fltn(data, '', r, opts);\n var o = 0;\n var tot = 0;\n for (var fn in r) {\n var _a = r[fn], file = _a[0], p = _a[1];\n var compression = p.level == 0 ? 0 : 8;\n var f = strToU8(fn), s = f.length;\n var com = p.comment, m = com && strToU8(com), ms = m && m.length;\n var exl = exfl(p.extra);\n if (s > 65535)\n err(11);\n var d = compression ? deflateSync(file, p) : file, l = d.length;\n var c = crc();\n c.p(file);\n files.push(mrg(p, {\n size: file.length,\n crc: c.d(),\n c: d,\n f: f,\n m: m,\n u: s != fn.length || (m && (com.length != ms)),\n o: o,\n compression: compression\n }));\n o += 30 + s + exl + l;\n tot += 76 + 2 * (s + exl) + (ms || 0) + l;\n }\n var out = new u8(tot + 22), oe = o, cdl = tot - o;\n for (var i = 0; i < files.length; ++i) {\n var f = files[i];\n wzh(out, f.o, f, f.f, f.u, f.c.length);\n var badd = 30 + f.f.length + exfl(f.extra);\n out.set(f.c, f.o + badd);\n wzh(out, o, f, f.f, f.u, f.c.length, f.o, f.m), o += 16 + badd + (f.m ? f.m.length : 0);\n }\n wzf(out, o, files.length, cdl, oe);\n return out;\n}\n/**\n * Streaming pass-through decompression for ZIP archives\n */\nvar UnzipPassThrough = /*#__PURE__*/ (function () {\n function UnzipPassThrough() {\n }\n UnzipPassThrough.prototype.push = function (data, final) {\n this.ondata(null, data, final);\n };\n UnzipPassThrough.compression = 0;\n return UnzipPassThrough;\n}());\nexport { UnzipPassThrough };\n/**\n * Streaming DEFLATE decompression for ZIP archives. Prefer AsyncZipInflate for\n * better performance.\n */\nvar UnzipInflate = /*#__PURE__*/ (function () {\n /**\n * Creates a DEFLATE decompression that can be used in ZIP archives\n */\n function UnzipInflate() {\n var _this = this;\n this.i = new Inflate(function (dat, final) {\n _this.ondata(null, dat, final);\n });\n }\n UnzipInflate.prototype.push = function (data, final) {\n try {\n this.i.push(data, final);\n }\n catch (e) {\n this.ondata(e, null, final);\n }\n };\n UnzipInflate.compression = 8;\n return UnzipInflate;\n}());\nexport { UnzipInflate };\n/**\n * Asynchronous streaming DEFLATE decompression for ZIP archives\n */\nvar AsyncUnzipInflate = /*#__PURE__*/ (function () {\n /**\n * Creates a DEFLATE decompression that can be used in ZIP archives\n */\n function AsyncUnzipInflate(_, sz) {\n var _this = this;\n if (sz < 320000) {\n this.i = new Inflate(function (dat, final) {\n _this.ondata(null, dat, final);\n });\n }\n else {\n this.i = new AsyncInflate(function (err, dat, final) {\n _this.ondata(err, dat, final);\n });\n this.terminate = this.i.terminate;\n }\n }\n AsyncUnzipInflate.prototype.push = function (data, final) {\n if (this.i.terminate)\n data = slc(data, 0);\n this.i.push(data, final);\n };\n AsyncUnzipInflate.compression = 8;\n return AsyncUnzipInflate;\n}());\nexport { AsyncUnzipInflate };\n/**\n * A ZIP archive decompression stream that emits files as they are discovered\n */\nvar Unzip = /*#__PURE__*/ (function () {\n /**\n * Creates a ZIP decompression stream\n * @param cb The callback to call whenever a file in the ZIP archive is found\n */\n function Unzip(cb) {\n this.onfile = cb;\n this.k = [];\n this.o = {\n 0: UnzipPassThrough\n };\n this.p = et;\n }\n /**\n * Pushes a chunk to be unzipped\n * @param chunk The chunk to push\n * @param final Whether this is the last chunk\n */\n Unzip.prototype.push = function (chunk, final) {\n var _this = this;\n if (!this.onfile)\n err(5);\n if (!this.p)\n err(4);\n if (this.c > 0) {\n var len = Math.min(this.c, chunk.length);\n var toAdd = chunk.subarray(0, len);\n this.c -= len;\n if (this.d)\n this.d.push(toAdd, !this.c);\n else\n this.k[0].push(toAdd);\n chunk = chunk.subarray(len);\n if (chunk.length)\n return this.push(chunk, final);\n }\n else {\n var f = 0, i = 0, is = void 0, buf = void 0;\n if (!this.p.length)\n buf = chunk;\n else if (!chunk.length)\n buf = this.p;\n else {\n buf = new u8(this.p.length + chunk.length);\n buf.set(this.p), buf.set(chunk, this.p.length);\n }\n var l = buf.length, oc = this.c, add = oc && this.d;\n var _loop_2 = function () {\n var _a;\n var sig = b4(buf, i);\n if (sig == 0x4034B50) {\n f = 1, is = i;\n this_1.d = null;\n this_1.c = 0;\n var bf = b2(buf, i + 6), cmp_1 = b2(buf, i + 8), u = bf & 2048, dd = bf & 8, fnl = b2(buf, i + 26), es = b2(buf, i + 28);\n if (l > i + 30 + fnl + es) {\n var chks_3 = [];\n this_1.k.unshift(chks_3);\n f = 2;\n var sc_1 = b4(buf, i + 18), su_1 = b4(buf, i + 22);\n var fn_1 = strFromU8(buf.subarray(i + 30, i += 30 + fnl), !u);\n if (sc_1 == 4294967295) {\n _a = dd ? [-2] : z64e(buf, i), sc_1 = _a[0], su_1 = _a[1];\n }\n else if (dd)\n sc_1 = -1;\n i += es;\n this_1.c = sc_1;\n var d_1;\n var file_1 = {\n name: fn_1,\n compression: cmp_1,\n start: function () {\n if (!file_1.ondata)\n err(5);\n if (!sc_1)\n file_1.ondata(null, et, true);\n else {\n var ctr = _this.o[cmp_1];\n if (!ctr)\n file_1.ondata(err(14, 'unknown compression type ' + cmp_1, 1), null, false);\n d_1 = sc_1 < 0 ? new ctr(fn_1) : new ctr(fn_1, sc_1, su_1);\n d_1.ondata = function (err, dat, final) { file_1.ondata(err, dat, final); };\n for (var _i = 0, chks_4 = chks_3; _i < chks_4.length; _i++) {\n var dat = chks_4[_i];\n d_1.push(dat, false);\n }\n if (_this.k[0] == chks_3 && _this.c)\n _this.d = d_1;\n else\n d_1.push(et, true);\n }\n },\n terminate: function () {\n if (d_1 && d_1.terminate)\n d_1.terminate();\n }\n };\n if (sc_1 >= 0)\n file_1.size = sc_1, file_1.originalSize = su_1;\n this_1.onfile(file_1);\n }\n return \"break\";\n }\n else if (oc) {\n if (sig == 0x8074B50) {\n is = i += 12 + (oc == -2 && 8), f = 3, this_1.c = 0;\n return \"break\";\n }\n else if (sig == 0x2014B50) {\n is = i -= 4, f = 3, this_1.c = 0;\n return \"break\";\n }\n }\n };\n var this_1 = this;\n for (; i < l - 4; ++i) {\n var state_1 = _loop_2();\n if (state_1 === \"break\")\n break;\n }\n this.p = et;\n if (oc < 0) {\n var dat = f ? buf.subarray(0, is - 12 - (oc == -2 && 8) - (b4(buf, is - 16) == 0x8074B50 && 4)) : buf.subarray(0, i);\n if (add)\n add.push(dat, !!f);\n else\n this.k[+(f == 2)].push(dat);\n }\n if (f & 2)\n return this.push(buf.subarray(i), final);\n this.p = buf.subarray(i);\n }\n if (final) {\n if (this.c)\n err(13);\n this.p = null;\n }\n };\n /**\n * Registers a decoder with the stream, allowing for files compressed with\n * the compression type provided to be expanded correctly\n * @param decoder The decoder constructor\n */\n Unzip.prototype.register = function (decoder) {\n this.o[decoder.compression] = decoder;\n };\n return Unzip;\n}());\nexport { Unzip };\nvar mt = typeof queueMicrotask == 'function' ? queueMicrotask : typeof setTimeout == 'function' ? setTimeout : function (fn) { fn(); };\nexport function unzip(data, opts, cb) {\n if (!cb)\n cb = opts, opts = {};\n if (typeof cb != 'function')\n err(7);\n var term = [];\n var tAll = function () {\n for (var i = 0; i < term.length; ++i)\n term[i]();\n };\n var files = {};\n var cbd = function (a, b) {\n mt(function () { cb(a, b); });\n };\n mt(function () { cbd = cb; });\n var e = data.length - 22;\n for (; b4(data, e) != 0x6054B50; --e) {\n if (!e || data.length - e > 65558) {\n cbd(err(13, 0, 1), null);\n return tAll;\n }\n }\n ;\n var lft = b2(data, e + 8);\n if (lft) {\n var c = lft;\n var o = b4(data, e + 16);\n var z = o == 4294967295 || c == 65535;\n if (z) {\n var ze = b4(data, e - 12);\n z = b4(data, ze) == 0x6064B50;\n if (z) {\n c = lft = b4(data, ze + 32);\n o = b4(data, ze + 48);\n }\n }\n var fltr = opts && opts.filter;\n var _loop_3 = function (i) {\n var _a = zh(data, o, z), c_1 = _a[0], sc = _a[1], su = _a[2], fn = _a[3], no = _a[4], off = _a[5], b = slzh(data, off);\n o = no;\n var cbl = function (e, d) {\n if (e) {\n tAll();\n cbd(e, null);\n }\n else {\n if (d)\n files[fn] = d;\n if (!--lft)\n cbd(null, files);\n }\n };\n if (!fltr || fltr({\n name: fn,\n size: sc,\n originalSize: su,\n compression: c_1\n })) {\n if (!c_1)\n cbl(null, slc(data, b, b + sc));\n else if (c_1 == 8) {\n var infl = data.subarray(b, b + sc);\n // Synchronously decompress under 512KB, or barely-compressed data\n if (su < 524288 || sc > 0.8 * su) {\n try {\n cbl(null, inflateSync(infl, { out: new u8(su) }));\n }\n catch (e) {\n cbl(e, null);\n }\n }\n else\n term.push(inflate(infl, { size: su }, cbl));\n }\n else\n cbl(err(14, 'unknown compression type ' + c_1, 1), null);\n }\n else\n cbl(null, null);\n };\n for (var i = 0; i < c; ++i) {\n _loop_3(i);\n }\n }\n else\n cbd(null, {});\n return tAll;\n}\n/**\n * Synchronously decompresses a ZIP archive. Prefer using `unzip` for better\n * performance with more than one file.\n * @param data The raw compressed ZIP file\n * @param opts The ZIP extraction options\n * @returns The decompressed files\n */\nexport function unzipSync(data, opts) {\n var files = {};\n var e = data.length - 22;\n for (; b4(data, e) != 0x6054B50; --e) {\n if (!e || data.length - e > 65558)\n err(13);\n }\n ;\n var c = b2(data, e + 8);\n if (!c)\n return {};\n var o = b4(data, e + 16);\n var z = o == 4294967295 || c == 65535;\n if (z) {\n var ze = b4(data, e - 12);\n z = b4(data, ze) == 0x6064B50;\n if (z) {\n c = b4(data, ze + 32);\n o = b4(data, ze + 48);\n }\n }\n var fltr = opts && opts.filter;\n for (var i = 0; i < c; ++i) {\n var _a = zh(data, o, z), c_2 = _a[0], sc = _a[1], su = _a[2], fn = _a[3], no = _a[4], off = _a[5], b = slzh(data, off);\n o = no;\n if (!fltr || fltr({\n name: fn,\n size: sc,\n originalSize: su,\n compression: c_2\n })) {\n if (!c_2)\n files[fn] = slc(data, b, b + sc);\n else if (c_2 == 8)\n files[fn] = inflateSync(data.subarray(b, b + sc), { out: new u8(su) });\n else\n err(14, 'unknown compression type ' + c_2);\n }\n }\n return files;\n}\n","import type { FeatureCollection, GeoJsonProperties } from 'geojson';\nimport { unzipSync } from 'fflate';\n\nconst ICON_URL = '__geolibre_kml_icon_url';\nconst ICON_SCALE = '__geolibre_kml_icon_scale';\n\ninterface PlacemarkMetadata {\n name?: string;\n description?: string;\n iconHref?: string;\n iconScale?: number;\n}\n\nfunction children(element: Element, name: string): Element[] {\n return Array.from(element.children).filter(\n (child) => child.localName.toLowerCase() === name.toLowerCase(),\n );\n}\n\nfunction child(element: Element, name: string): Element | undefined {\n return children(element, name)[0];\n}\n\nfunction childText(element: Element, name: string): string | undefined {\n const value = child(element, name)?.textContent?.trim();\n return value || undefined;\n}\n\nfunction archiveEntry(\n entries: Record,\n href: string,\n): [string, Uint8Array] | undefined {\n const normalize = (value: string) =>\n value\n .split(/[?#]/)[0]\n .replace(/\\\\/g, '/')\n .replace(/^\\.?\\//, '')\n .toLowerCase();\n const target = normalize(href);\n const exact = Object.entries(entries).find(([name]) => normalize(name) === target);\n if (exact) return exact;\n const base = target.split('/').pop();\n const matches = Object.entries(entries).filter(\n ([name]) => normalize(name).split('/').pop() === base,\n );\n return matches.length === 1 ? matches[0] : undefined;\n}\n\nfunction imageMime(name: string): string | null {\n const extension = name.split(/[?#]/)[0].split('.').pop()?.toLowerCase();\n if (extension === 'png') return 'image/png';\n if (extension === 'jpg' || extension === 'jpeg') return 'image/jpeg';\n if (extension === 'gif') return 'image/gif';\n if (extension === 'webp') return 'image/webp';\n if (extension === 'bmp') return 'image/bmp';\n return null;\n}\n\nfunction bytesToDataUrl(bytes: Uint8Array, mime: string): Promise {\n return new Promise((resolve, reject) => {\n const reader = new FileReader();\n reader.onload = () => resolve(String(reader.result));\n reader.onerror = () => reject(reader.error ?? new Error('Could not read a KMZ icon.'));\n reader.readAsDataURL(new Blob([bytes as BlobPart], { type: mime }));\n });\n}\n\nfunction placemarkMetadata(text: string): PlacemarkMetadata[] {\n const document = new DOMParser().parseFromString(text, 'application/xml');\n if (document.querySelector('parsererror')) return [];\n const styles = new Map();\n const elements = Array.from(document.getElementsByTagName('*'));\n for (const style of elements.filter((element) => element.localName === 'Style')) {\n const id = style.getAttribute('id');\n const iconStyle = child(style, 'IconStyle');\n if (!id || !iconStyle) continue;\n const icon = child(iconStyle, 'Icon');\n const href = icon ? childText(icon, 'href') : undefined;\n const scaleValue = Number(childText(iconStyle, 'scale'));\n styles.set(id, {\n href,\n ...(Number.isFinite(scaleValue) && scaleValue > 0 ? { scale: scaleValue } : {}),\n });\n }\n\n return elements.filter((element) => element.localName === 'Placemark').map((placemark) => {\n const styleUrl = childText(placemark, 'styleUrl')?.replace(/^#/, '');\n const style = styleUrl ? styles.get(styleUrl) : undefined;\n return {\n name: childText(placemark, 'name'),\n description: childText(placemark, 'description'),\n iconHref: style?.href,\n iconScale: style?.scale,\n };\n });\n}\n\nfunction featureName(properties: GeoJsonProperties): string | undefined {\n const value = properties?.name ?? properties?.Name ?? properties?.NAME;\n return typeof value === 'string' ? value : undefined;\n}\n\n/**\n * Restore KMZ placemark descriptions and embedded icons that GDAL's GeoJSON\n * conversion omits. Features are paired by name and occurrence order.\n */\nexport async function enhanceKmzGeoJSON(\n source: unknown,\n collection: FeatureCollection,\n sourceName?: string,\n): Promise {\n if (\n !source ||\n typeof source !== 'object' ||\n !('arrayBuffer' in source) ||\n typeof source.arrayBuffer !== 'function'\n ) {\n return collection;\n }\n const name =\n sourceName ?? ('name' in source && typeof source.name === 'string' ? source.name : '');\n if (name && !name.toLowerCase().endsWith('.kmz')) return collection;\n\n let entries: Record;\n try {\n entries = unzipSync(new Uint8Array(await source.arrayBuffer()));\n } catch {\n return collection;\n }\n const kml = Object.entries(entries).find(([entry]) => entry.toLowerCase().endsWith('.kml'));\n if (!kml) return collection;\n const metadata = placemarkMetadata(new TextDecoder().decode(kml[1]));\n if (!metadata.length) return collection;\n\n const byName = new Map();\n for (const item of metadata) {\n if (!item.name) continue;\n const queue = byName.get(item.name) ?? [];\n queue.push(item);\n byName.set(item.name, queue);\n }\n\n const iconUrls = new Map>();\n const resolveIcon = (href: string) => {\n const cached = iconUrls.get(href);\n if (cached) return cached;\n const promise = (async () => {\n const found = archiveEntry(entries, href);\n if (!found) return null;\n const mime = imageMime(found[0]);\n return mime ? bytesToDataUrl(found[1], mime) : null;\n })();\n iconUrls.set(href, promise);\n return promise;\n };\n\n await Promise.all(\n collection.features.map(async (feature, index) => {\n const properties = (feature.properties ??= {});\n const nameValue = featureName(properties);\n const item = (nameValue ? byName.get(nameValue)?.shift() : undefined) ?? metadata[index];\n if (!item) return;\n for (const key of Object.keys(properties)) {\n const lower = key.toLowerCase();\n if ((lower === 'name' || lower === 'description') && key !== lower) {\n delete properties[key];\n }\n }\n if (item.name) properties.name = item.name;\n if (item.description) properties.description = item.description;\n if (item.iconScale) properties[ICON_SCALE] = item.iconScale;\n if (item.iconHref) {\n const url = await resolveIcon(item.iconHref);\n if (url) properties[ICON_URL] = url;\n }\n }),\n );\n return collection;\n}\n\nfunction iconHash(value: string): string {\n let hash = 2166136261;\n for (let index = 0; index < value.length; index += 1) {\n hash = Math.imul(hash ^ value.charCodeAt(index), 16777619);\n }\n return (hash >>> 0).toString(16);\n}\n\n/**\n * Register embedded KMZ icons on the map and return a data-driven icon-image\n * expression, or null when the collection has none.\n */\nexport async function prepareKmzIcons(\n map: {\n hasImage(id: string): boolean;\n addImage(id: string, image: HTMLImageElement, options?: { pixelRatio?: number }): void;\n },\n collection: FeatureCollection,\n): Promise {\n const urls = new Set();\n for (const feature of collection.features) {\n const value = feature.properties?.[ICON_URL];\n if (typeof value === 'string') urls.add(value);\n }\n if (!urls.size) return null;\n\n const matches: unknown[] = [];\n await Promise.all(\n Array.from(urls).map(\n (url) =>\n new Promise((resolve) => {\n const id = `maplibre-vector-kml-${iconHash(url)}`;\n matches.push(url, id);\n if (map.hasImage(id)) {\n resolve();\n return;\n }\n const image = new Image();\n image.onload = () => {\n // ArcGIS KMZ exports bake their KML scale into a 2x raster (the\n // sample's icons are 60 px for an approximately 30 px symbol).\n if (!map.hasImage(id)) map.addImage(id, image, { pixelRatio: 2 });\n resolve();\n };\n image.onerror = () => resolve();\n image.src = url;\n }),\n ),\n );\n return ['match', ['get', ICON_URL], ...matches, ''];\n}\n","import type { AutoThreshold, RenderMode } from '../core/types';\n\n/**\n * Default thresholds for `'auto'` render mode.\n */\nexport const DEFAULT_AUTO_THRESHOLD: Required = {\n featureCount: 50_000,\n byteSize: 25 * 1024 * 1024,\n};\n\n/**\n * Inputs for the render mode decision.\n */\nexport interface RenderModeInputs {\n /** Mode requested for the layer ('auto' when unspecified) */\n requested?: RenderMode;\n /** Control-level default mode */\n defaultMode?: RenderMode;\n /** Known feature count */\n featureCount?: number;\n /** Known source size in bytes */\n byteSize?: number;\n /** Threshold overrides */\n threshold?: AutoThreshold;\n /** Whether the tiles pipeline (DuckDB) is usable for this layer */\n tilesAvailable?: boolean;\n}\n\n/**\n * Resolves the effective render mode for a layer.\n *\n * Explicit per-layer modes win, then the control default, then 'auto'.\n * In auto mode, tiles are chosen when either the feature count or byte\n * size exceeds its threshold (and tiles are available).\n *\n * @param inputs - Decision inputs\n * @returns The resolved render mode ('geojson' or 'tiles')\n */\nexport function decideRenderMode(inputs: RenderModeInputs): 'geojson' | 'tiles' {\n const {\n requested,\n defaultMode,\n featureCount,\n byteSize,\n threshold,\n tilesAvailable = true,\n } = inputs;\n\n const mode = requested && requested !== 'auto' ? requested : (defaultMode ?? 'auto');\n\n if (mode === 'geojson') return 'geojson';\n if (mode === 'tiles') return tilesAvailable ? 'tiles' : 'geojson';\n\n if (!tilesAvailable) return 'geojson';\n\n const limits = { ...DEFAULT_AUTO_THRESHOLD, ...threshold };\n const tooManyFeatures = featureCount !== undefined && featureCount > limits.featureCount;\n const tooLarge = byteSize !== undefined && byteSize > limits.byteSize;\n\n return tooManyFeatures || tooLarge ? 'tiles' : 'geojson';\n}\n","import type { Map as MapLibreMap, PropertyValueSpecification } from 'maplibre-gl';\nimport type { VectorLayerInfo, VectorLayerStyle } from '../core/types';\n\n/**\n * A paint value: a flat scalar, or a MapLibre data-driven color expression\n * (used for attribute-driven fill/line/circle colors).\n */\nexport type PaintValue =\n | string\n | number\n | PropertyValueSpecification\n | PropertyValueSpecification;\n\n/**\n * Default style applied to new layers.\n */\nexport const DEFAULT_STYLE: VectorLayerStyle = {\n fillColor: '#3388ff',\n fillOpacity: 0.4,\n lineColor: '#3388ff',\n lineWidth: 2,\n circleColor: '#3388ff',\n circleRadius: 5,\n circleOpacity: 0.85,\n pointMode: 'circle',\n heatmapRadius: 30,\n heatmapIntensity: 1,\n clusterRadius: 50,\n clusterMaxZoom: 14,\n};\n\n// A cold->hot ramp over heatmap-density (0..1) for the heatmap renderer.\nconst HEATMAP_COLOR: PropertyValueSpecification = [\n 'interpolate',\n ['linear'],\n ['heatmap-density'],\n 0,\n 'rgba(33,102,172,0)',\n 0.2,\n 'rgb(103,169,207)',\n 0.4,\n 'rgb(209,229,240)',\n 0.6,\n 'rgb(253,219,199)',\n 0.8,\n 'rgb(239,138,98)',\n 1,\n 'rgb(178,24,43)',\n] as unknown as PropertyValueSpecification;\n\n// Cluster bubble radius steps up with the aggregated point count.\nconst CLUSTER_RADIUS: PropertyValueSpecification = [\n 'step',\n ['get', 'point_count'],\n 16,\n 50,\n 22,\n 200,\n 30,\n] as unknown as PropertyValueSpecification;\n\n/**\n * A single setPaintProperty operation.\n */\nexport interface PaintOp {\n layerId: string;\n property: string;\n value: PaintValue;\n}\n\n/**\n * Suffixes of the map layers created for each vector layer.\n */\nexport const LAYER_SUFFIXES = [\n 'fill',\n 'extrusion',\n 'outline',\n 'line',\n 'circle',\n 'heatmap',\n 'cluster',\n 'cluster-count',\n 'label',\n] as const;\nexport type LayerSuffix = (typeof LAYER_SUFFIXES)[number];\n\n/** Default size, in pixels, of attribute label text. */\nexport const DEFAULT_LABEL_SIZE = 12;\n/** Default color of attribute label text. */\nexport const DEFAULT_LABEL_COLOR = '#333333';\n/** Default color of the halo drawn behind attribute label text. */\nexport const DEFAULT_LABEL_HALO_COLOR = '#ffffff';\n/** Default width, in pixels, of the attribute label text halo. */\nexport const DEFAULT_LABEL_HALO_WIDTH = 1;\n\n/** Resolve a style's point render mode, defaulting to 'circle'. */\nexport function pointModeOf(style: VectorLayerStyle): 'circle' | 'heatmap' | 'cluster' {\n return style.pointMode ?? 'circle';\n}\n\n/**\n * Whether a style requests attribute labels (a non-empty `labelField`).\n *\n * @param style - The layer style\n * @returns True when a label layer should be created\n */\nexport function hasLabels(style: VectorLayerStyle): boolean {\n return typeof style.labelField === 'string' && style.labelField.trim().length > 0;\n}\n\n/**\n * Builds the `text-field` expression for a label layer: the feature's\n * `labelField` value coerced to a string, with missing values rendered as\n * empty text (so a cluster aggregate or a feature lacking the field shows\n * nothing rather than breaking the layer).\n *\n * @param style - The layer style (its `labelField` drives the expression)\n * @returns A MapLibre `text-field` expression\n */\nexport function labelTextField(style: VectorLayerStyle): PropertyValueSpecification {\n return [\n 'to-string',\n ['coalesce', ['get', style.labelField ?? ''], ''],\n ] as unknown as PropertyValueSpecification;\n}\n\n/**\n * Builds the symbol-layer layout for a label layer.\n *\n * @param style - The layer style\n * @param visible - Whether the layer starts visible\n * @returns The MapLibre layout object for the label symbol layer\n */\nexport function buildLabelLayout(\n style: VectorLayerStyle,\n visible: boolean,\n): Record {\n const allowOverlap = style.labelAllowOverlap ?? false;\n return {\n visibility: visible ? 'visible' : 'none',\n 'text-field': labelTextField(style),\n 'text-size': style.labelSize ?? DEFAULT_LABEL_SIZE,\n 'symbol-placement': style.labelPlacement === 'line' ? 'line' : 'point',\n 'text-allow-overlap': allowOverlap,\n 'text-ignore-placement': allowOverlap,\n };\n}\n\n/**\n * Builds the map layer id for a vector layer and suffix.\n *\n * @param layerId - The vector layer id\n * @param suffix - The map layer role\n * @returns The map layer id\n */\nexport function mapLayerId(layerId: string, suffix: LayerSuffix): string {\n return `${layerId}-${suffix}`;\n}\n\n/**\n * Clamps a master opacity value to the valid [0, 1] range.\n *\n * @param opacity - The requested opacity\n * @returns The clamped opacity (non-finite values become 1)\n */\nexport function clampOpacity(opacity: number): number {\n if (!Number.isFinite(opacity)) return 1;\n return Math.min(1, Math.max(0, opacity));\n}\n\n/**\n * Builds the initial paint object for a given map layer role.\n *\n * @param suffix - The map layer role\n * @param style - The layer style\n * @param opacity - Master opacity multiplied into every opacity property\n * @returns The MapLibre paint object\n */\nexport function buildPaint(\n suffix: LayerSuffix,\n style: VectorLayerStyle,\n opacity = 1,\n): Record {\n const master = clampOpacity(opacity);\n // A data-driven color expression, when present, overrides the flat color so\n // attribute-driven (categorized/graduated) styling renders.\n const fillColor = style.fillColorExpression ?? style.fillColor;\n const lineColor = style.lineColorExpression ?? style.lineColor;\n const circleColor = style.circleColorExpression ?? style.circleColor;\n switch (suffix) {\n case 'fill':\n return {\n 'fill-color': fillColor,\n 'fill-opacity': style.fillOpacity * master,\n };\n case 'extrusion':\n return {\n // Data-driven extrusion color wins over the flat one; both fall back to\n // the fill color so an extruded layer is never left uncolored.\n 'fill-extrusion-color':\n style.extrusionColorExpression ?? style.extrusionColor ?? fillColor,\n 'fill-extrusion-opacity': (style.extrusionOpacity ?? 1) * master,\n // A constant or a data-driven expression (e.g. ['get', 'height']);\n // unset means 0, which renders flat until a height is provided.\n 'fill-extrusion-height': style.extrusionHeight ?? 0,\n 'fill-extrusion-base': style.extrusionBase ?? 0,\n };\n case 'outline':\n return {\n 'line-color': lineColor,\n 'line-width': style.lineWidth,\n 'line-opacity': master,\n };\n case 'line':\n return {\n 'line-color': lineColor,\n 'line-width': style.lineWidth,\n 'line-opacity': master,\n };\n case 'circle':\n return {\n 'circle-color': circleColor,\n 'circle-radius': style.circleRadius,\n 'circle-opacity': style.circleOpacity * master,\n 'circle-stroke-color': '#ffffff',\n 'circle-stroke-width': 1,\n 'circle-stroke-opacity': master,\n };\n case 'heatmap':\n return {\n 'heatmap-radius': style.heatmapRadius ?? 30,\n 'heatmap-intensity': style.heatmapIntensity ?? 1,\n 'heatmap-opacity': master,\n 'heatmap-color': HEATMAP_COLOR,\n };\n case 'cluster':\n return {\n // Use the resolved circleColor (data-driven expression or flat) so an\n // initial cluster render honors the same color contract as a later patch.\n 'circle-color': circleColor,\n 'circle-radius': CLUSTER_RADIUS,\n 'circle-opacity': style.circleOpacity * master,\n 'circle-stroke-color': '#ffffff',\n 'circle-stroke-width': 1,\n 'circle-stroke-opacity': master,\n };\n case 'cluster-count':\n return {\n 'text-color': '#ffffff',\n 'text-opacity': master,\n };\n case 'label':\n return {\n 'text-color': style.labelColor ?? DEFAULT_LABEL_COLOR,\n 'text-halo-color': style.labelHaloColor ?? DEFAULT_LABEL_HALO_COLOR,\n 'text-halo-width': Math.max(0, style.labelHaloWidth ?? DEFAULT_LABEL_HALO_WIDTH),\n 'text-opacity': master,\n };\n }\n}\n\n/**\n * Maps a style patch to the setPaintProperty operations it implies.\n *\n * Only operations for map layers that exist on the vector layer are\n * returned. Style opacities are multiplied by the layer's master\n * opacity so a patch cannot undo a host-applied opacity.\n *\n * @param info - The vector layer\n * @param patch - Partial style update\n * @param opacity - Master opacity multiplied into opacity properties\n * @returns The list of paint operations to apply\n */\nexport function stylePatchToPaintOps(\n info: Pick,\n patch: Partial,\n opacity = 1,\n): PaintOp[] {\n const master = clampOpacity(opacity);\n const ops: PaintOp[] = [];\n const has = (suffix: LayerSuffix) => info.layerIds.includes(mapLayerId(info.id, suffix));\n const push = (suffix: LayerSuffix, property: string, value: PaintValue | undefined) => {\n if (value !== undefined && has(suffix)) {\n ops.push({ layerId: mapLayerId(info.id, suffix), property, value });\n }\n };\n\n // A data-driven color expression in the patch overrides the flat color.\n const fillColor = patch.fillColorExpression ?? patch.fillColor;\n const lineColor = patch.lineColorExpression ?? patch.lineColor;\n const circleColor = patch.circleColorExpression ?? patch.circleColor;\n\n push('fill', 'fill-color', fillColor);\n push('fill', 'fill-opacity', patch.fillOpacity === undefined ? undefined : patch.fillOpacity * master);\n // Extrusion paint. Toggling extrusionEnabled itself is structural (handled by\n // the layer manager, which rebuilds the polygon layers); these ops cover\n // restyle edits while extrusion stays on, applied only when the layer has the\n // 'extrusion' map layer.\n push('extrusion', 'fill-extrusion-color', patch.extrusionColorExpression ?? patch.extrusionColor);\n push(\n 'extrusion',\n 'fill-extrusion-opacity',\n patch.extrusionOpacity === undefined ? undefined : patch.extrusionOpacity * master,\n );\n push('extrusion', 'fill-extrusion-height', patch.extrusionHeight);\n push('extrusion', 'fill-extrusion-base', patch.extrusionBase);\n push('outline', 'line-color', lineColor);\n push('outline', 'line-width', patch.lineWidth);\n push('line', 'line-color', lineColor);\n push('line', 'line-width', patch.lineWidth);\n push('circle', 'circle-color', circleColor);\n push('circle', 'circle-radius', patch.circleRadius);\n push('circle', 'circle-opacity', patch.circleOpacity === undefined ? undefined : patch.circleOpacity * master);\n // Heatmap radius/intensity are plain paint updates (no rebuild needed); the\n // cluster bubble tracks the circle color and opacity. pointMode and cluster\n // radius/maxZoom changes are structural and handled by the layer manager.\n push('heatmap', 'heatmap-radius', patch.heatmapRadius);\n push('heatmap', 'heatmap-intensity', patch.heatmapIntensity);\n push('cluster', 'circle-color', circleColor);\n push('cluster', 'circle-opacity', patch.circleOpacity === undefined ? undefined : patch.circleOpacity * master);\n // Label paint. text-size, placement, and the text-field itself are layout\n // (not paint) and are applied by the layer manager, which also adds or\n // removes the label layer when the labelField is set or cleared.\n push('label', 'text-color', patch.labelColor);\n push('label', 'text-halo-color', patch.labelHaloColor);\n push(\n 'label',\n 'text-halo-width',\n patch.labelHaloWidth === undefined ? undefined : Math.max(0, patch.labelHaloWidth),\n );\n\n return ops;\n}\n\n/**\n * Maps a master opacity change to the setPaintProperty operations it\n * implies, multiplying the style's own opacities where applicable.\n *\n * @param info - The vector layer\n * @param style - The layer's current style\n * @param opacity - The new master opacity (0-1)\n * @returns The list of paint operations to apply\n */\nexport function opacityToPaintOps(\n info: Pick,\n style: VectorLayerStyle,\n opacity: number,\n): PaintOp[] {\n const master = clampOpacity(opacity);\n const ops: PaintOp[] = [];\n const has = (suffix: LayerSuffix) => info.layerIds.includes(mapLayerId(info.id, suffix));\n const push = (suffix: LayerSuffix, property: string, value: string | number) => {\n if (has(suffix)) {\n ops.push({ layerId: mapLayerId(info.id, suffix), property, value });\n }\n };\n\n push('fill', 'fill-opacity', style.fillOpacity * master);\n push('extrusion', 'fill-extrusion-opacity', (style.extrusionOpacity ?? 1) * master);\n push('outline', 'line-opacity', master);\n push('line', 'line-opacity', master);\n push('circle', 'circle-opacity', style.circleOpacity * master);\n push('circle', 'circle-stroke-opacity', master);\n push('heatmap', 'heatmap-opacity', master);\n push('cluster', 'circle-opacity', style.circleOpacity * master);\n push('cluster', 'circle-stroke-opacity', master);\n push('cluster-count', 'text-opacity', master);\n push('label', 'text-opacity', master);\n\n return ops;\n}\n\n/**\n * Applies a style patch to the map layers of a vector layer.\n *\n * @param map - The MapLibre map\n * @param info - The vector layer\n * @param patch - Partial style update\n * @param opacity - Master opacity multiplied into opacity properties\n */\nexport function applyStyle(\n map: MapLibreMap,\n info: Pick,\n patch: Partial,\n opacity = 1,\n): void {\n for (const op of stylePatchToPaintOps(info, patch, opacity)) {\n map.setPaintProperty(op.layerId, op.property, op.value);\n }\n}\n\n/**\n * Applies a master opacity change to the map layers of a vector layer.\n *\n * @param map - The MapLibre map\n * @param info - The vector layer\n * @param style - The layer's current style\n * @param opacity - The new master opacity (0-1)\n */\nexport function applyOpacity(\n map: MapLibreMap,\n info: Pick,\n style: VectorLayerStyle,\n opacity: number,\n): void {\n for (const op of opacityToPaintOps(info, style, opacity)) {\n map.setPaintProperty(op.layerId, op.property, op.value);\n }\n}\n","import type {\n FilterSpecification,\n Map as MapLibreMap,\n SourceSpecification,\n} from 'maplibre-gl';\nimport type { FeatureCollection } from 'geojson';\nimport type { GeometryCategory, VectorLayerStyle } from '../core/types';\nimport type { Bbox } from '../utils/geometry';\nimport { buildLabelLayout, buildPaint, hasLabels, mapLayerId, pointModeOf } from './styleBuilder';\n\n/** Map layer roles created by the geometry-type loop (excludes heatmap/cluster). */\ntype GeometrySuffix = 'fill' | 'extrusion' | 'outline' | 'line' | 'circle';\n\n/**\n * Builds the map source id for a vector layer.\n *\n * @param layerId - The vector layer id\n * @returns The map source id\n */\nexport function sourceIdFor(layerId: string): string {\n return `${layerId}-source`;\n}\n\n/**\n * Returns the map layer roles needed for a geometry category.\n *\n * Mixed or unknown geometry gets all roles with geometry-type filters so\n * each feature renders with the appropriate layer.\n *\n * When `extrude` is set, polygon features render as a single `fill-extrusion`\n * layer (the flat `fill`/`outline` pair is replaced); other geometries are\n * unaffected.\n *\n * @param category - The geometry category\n * @param extrude - Render polygons as 3D extrusions instead of a flat fill\n * @returns The layer suffixes to create\n */\nexport function suffixesForGeometry(\n category: GeometryCategory,\n extrude = false,\n): GeometrySuffix[] {\n switch (category) {\n case 'polygon':\n return extrude ? ['extrusion'] : ['fill', 'outline'];\n case 'line':\n return ['line'];\n case 'point':\n return ['circle'];\n default:\n return extrude ? ['extrusion', 'line', 'circle'] : ['fill', 'outline', 'line', 'circle'];\n }\n}\n\nconst SUFFIX_TYPES: Record = {\n fill: 'fill',\n extrusion: 'fill-extrusion',\n outline: 'line',\n line: 'line',\n circle: 'circle',\n};\n\nconst SUFFIX_FILTERS: Record = {\n fill: ['==', ['geometry-type'], 'Polygon'],\n extrusion: ['==', ['geometry-type'], 'Polygon'],\n outline: ['==', ['geometry-type'], 'Polygon'],\n line: ['==', ['geometry-type'], 'LineString'],\n circle: ['==', ['geometry-type'], 'Point'],\n};\n\nconst POINT_FILTER: FilterSpecification = ['==', ['geometry-type'], 'Point'];\nconst CLUSTER_FILTER: FilterSpecification = ['has', 'point_count'];\nconst UNCLUSTERED_FILTER: FilterSpecification = ['!', ['has', 'point_count']];\n\n/**\n * Options for adding the map layers of a vector layer.\n */\nexport interface AddLayersOptions {\n /** The vector layer id */\n layerId: string;\n /** Geometry category determining which map layers are created */\n geometryType: GeometryCategory;\n /** Layer style */\n style: VectorLayerStyle;\n /** Whether the layer starts visible */\n visible: boolean;\n /** Master opacity (0-1) multiplied into every style opacity */\n opacity?: number;\n /** source-layer name for vector tile sources (omit for geojson) */\n sourceLayer?: string;\n /** Existing map layer id to insert the new layers before */\n beforeId?: string;\n /** Per-feature KMZ icon-image expression for point layers. */\n kmlIconImage?: unknown[] | null;\n}\n\n/**\n * Adds a GeoJSON source to the map.\n *\n * @param map - The MapLibre map\n * @param layerId - The vector layer id\n * @param data - The FeatureCollection to render\n * @param attribution - Optional attribution string\n * @returns The created source id\n */\nexport function addGeoJSONSource(\n map: MapLibreMap,\n layerId: string,\n data: FeatureCollection,\n attribution?: string,\n cluster?: { radius: number; maxZoom: number },\n): string {\n const sourceId = sourceIdFor(layerId);\n const spec: SourceSpecification = { type: 'geojson', data };\n if (attribution) spec.attribution = attribution;\n if (cluster) {\n spec.cluster = true;\n spec.clusterRadius = cluster.radius;\n spec.clusterMaxZoom = cluster.maxZoom;\n }\n map.addSource(sourceId, spec);\n return sourceId;\n}\n\n/**\n * Cluster options for a GeoJSON source when a point layer's style requests\n * clustering, or undefined otherwise (the source stays unclustered). Only\n * applies to geojson-rendered point layers.\n *\n * @param geometryType - The layer's geometry category\n * @param style - The layer style\n * @param sourceLayer - Set for vector-tile sources (clustering is geojson-only)\n * @returns Cluster options, or undefined\n */\nexport function clusterOptionsFor(\n geometryType: GeometryCategory,\n style: VectorLayerStyle,\n sourceLayer?: string,\n): { radius: number; maxZoom: number } | undefined {\n if (sourceLayer || geometryType !== 'point') return undefined;\n if (pointModeOf(style) !== 'cluster') return undefined;\n return { radius: style.clusterRadius ?? 50, maxZoom: style.clusterMaxZoom ?? 14 };\n}\n\n/**\n * Options for adding a dynamic vector tile source.\n */\nexport interface AddVectorSourceOptions {\n /** Tile URL template (e.g. duckdb://layer/{z}/{x}/{y}) */\n tileUrl: string;\n /** Maximum zoom at which tiles are generated */\n maxzoom: number;\n /** Layer extent used to skip out-of-bounds tile requests */\n bounds?: Bbox;\n /** Optional attribution string */\n attribution?: string;\n}\n\n/**\n * Adds a vector tile source backed by the duckdb:// protocol.\n *\n * @param map - The MapLibre map\n * @param layerId - The vector layer id\n * @param options - Source options\n * @returns The created source id\n */\nexport function addVectorTileSource(\n map: MapLibreMap,\n layerId: string,\n options: AddVectorSourceOptions,\n): string {\n const sourceId = sourceIdFor(layerId);\n const spec: SourceSpecification = {\n type: 'vector',\n tiles: [options.tileUrl],\n minzoom: 0,\n maxzoom: options.maxzoom,\n };\n if (options.bounds) spec.bounds = options.bounds;\n if (options.attribution) spec.attribution = options.attribution;\n map.addSource(sourceId, spec);\n return sourceId;\n}\n\n/**\n * Adds the styled map layers for a vector layer source.\n *\n * @param map - The MapLibre map\n * @param options - Layer creation options\n * @returns The created map layer ids\n */\nexport function addGeometryLayers(map: MapLibreMap, options: AddLayersOptions): string[] {\n const { layerId, geometryType, style, visible, opacity, sourceLayer, beforeId, kmlIconImage } =\n options;\n const sourceId = sourceIdFor(layerId);\n const layout = { visibility: visible ? 'visible' : 'none' };\n\n // Only honor beforeId when the target layer exists; addLayer throws\n // otherwise (e.g. a label layer absent from the active style).\n const before = beforeId && map.getLayer(beforeId) ? beforeId : undefined;\n\n const add = (id: string, spec: Record): string => {\n // eslint-disable-next-line @typescript-eslint/no-explicit-any\n map.addLayer({ id, source: sourceId, layout, ...spec } as any, before);\n return id;\n };\n\n // Geojson point layers honor the style's pointMode (heatmap/cluster). Tiles\n // (sourceLayer set) and other geometries always use the standard roles.\n const pointMode = !sourceLayer && geometryType === 'point' ? pointModeOf(style) : 'circle';\n\n // An attribute label layer is appended last so it draws on top of the\n // geometry. Added for every geometry type and render mode; the symbol layer\n // references the same source (and source-layer for tiles).\n const withLabel = (ids: string[]): string[] => {\n if (hasLabels(style)) {\n ids.push(addLabelLayer(map, { layerId, style, visible, opacity, sourceLayer, beforeId }));\n }\n return ids;\n };\n\n if (pointMode === 'heatmap') {\n return withLabel([\n add(mapLayerId(layerId, 'heatmap'), {\n type: 'heatmap',\n filter: POINT_FILTER,\n paint: buildPaint('heatmap', style, opacity),\n }),\n ]);\n }\n\n if (pointMode === 'cluster') {\n return withLabel([\n add(mapLayerId(layerId, 'cluster'), {\n type: 'circle',\n filter: CLUSTER_FILTER,\n paint: buildPaint('cluster', style, opacity),\n }),\n add(mapLayerId(layerId, 'cluster-count'), {\n type: 'symbol',\n filter: CLUSTER_FILTER,\n layout: {\n ...layout,\n 'text-field': ['get', 'point_count_abbreviated'],\n 'text-size': 12,\n 'text-allow-overlap': true,\n 'text-ignore-placement': true,\n },\n paint: buildPaint('cluster-count', style, opacity),\n }),\n add(mapLayerId(layerId, 'circle'), {\n type: 'circle',\n filter: UNCLUSTERED_FILTER,\n paint: buildPaint('circle', style, opacity),\n }),\n ]);\n }\n\n const ids = suffixesForGeometry(geometryType, style.extrusionEnabled === true).map((suffix) =>\n add(mapLayerId(layerId, suffix), {\n type: SUFFIX_TYPES[suffix],\n ...(sourceLayer ? { 'source-layer': sourceLayer } : {}),\n filter:\n suffix === 'circle' && kmlIconImage\n ? ['all', SUFFIX_FILTERS.circle, ['!', ['has', '__geolibre_kml_icon_url']]]\n : SUFFIX_FILTERS[suffix],\n paint: buildPaint(suffix, style, opacity),\n }),\n );\n if (geometryType === 'point' && kmlIconImage) {\n ids.push(\n add(`${layerId}-kml-icon`, {\n type: 'symbol',\n filter: ['all', POINT_FILTER, ['has', '__geolibre_kml_icon_url']],\n layout: {\n ...layout,\n 'icon-image': kmlIconImage,\n 'icon-size': 1,\n 'icon-allow-overlap': true,\n 'icon-ignore-placement': true,\n },\n paint: { 'icon-opacity': opacity },\n }),\n );\n }\n return withLabel(ids);\n}\n\n/**\n * Options for adding the attribute label layer of a vector layer.\n */\nexport interface AddLabelLayerOptions {\n /** The vector layer id */\n layerId: string;\n /** Layer style (its label* fields drive the symbol layer) */\n style: VectorLayerStyle;\n /** Whether the layer starts visible */\n visible: boolean;\n /** Master opacity (0-1) multiplied into the text opacity */\n opacity?: number;\n /** source-layer name for vector tile sources (omit for geojson) */\n sourceLayer?: string;\n /** Existing map layer id to insert the label layer before */\n beforeId?: string;\n}\n\n/**\n * Adds the attribute label `symbol` layer for a vector layer, rendering the\n * style's `labelField` value as text for every feature.\n *\n * @param map - The MapLibre map\n * @param options - Label layer creation options\n * @returns The created label map layer id\n */\nexport function addLabelLayer(map: MapLibreMap, options: AddLabelLayerOptions): string {\n const { layerId, style, visible, opacity, sourceLayer, beforeId } = options;\n const id = mapLayerId(layerId, 'label');\n const before = beforeId && map.getLayer(beforeId) ? beforeId : undefined;\n map.addLayer(\n {\n id,\n type: 'symbol',\n source: sourceIdFor(layerId),\n ...(sourceLayer ? { 'source-layer': sourceLayer } : {}),\n layout: buildLabelLayout(style, visible),\n paint: buildPaint('label', style, opacity),\n // eslint-disable-next-line @typescript-eslint/no-explicit-any\n } as any,\n before,\n );\n return id;\n}\n\n/**\n * Sets the visibility of all map layers of a vector layer.\n *\n * @param map - The MapLibre map\n * @param layerIds - The map layer ids\n * @param visible - Whether the layers should be visible\n */\nexport function setLayersVisibility(\n map: MapLibreMap,\n layerIds: string[],\n visible: boolean,\n): void {\n for (const id of layerIds) {\n // A structural point-renderer rebuild removes the previous native layers\n // before its async icon preparation completes. Visibility can be\n // reconciled during that handoff, so ignore ids that have already gone.\n if (map.getLayer(id)) {\n map.setLayoutProperty(id, 'visibility', visible ? 'visible' : 'none');\n }\n }\n}\n\n/**\n * Removes the map layers and source of a vector layer.\n *\n * @param map - The MapLibre map\n * @param layerIds - The map layer ids to remove\n * @param sourceId - The source id to remove\n */\nexport function removeLayersAndSource(\n map: MapLibreMap,\n layerIds: string[],\n sourceId: string,\n): void {\n for (const id of layerIds) {\n if (map.getLayer(id)) map.removeLayer(id);\n }\n if (map.getSource(sourceId)) map.removeSource(sourceId);\n}\n","/**\n * Lazy access to the maplibre-gl module without a static value import.\n *\n * The global `maplibregl` (UMD build or host app) is preferred so\n * module-level registries like addProtocol land on the SAME module\n * instance that owns the map; a bundled second copy of maplibre-gl\n * would register them where the host map never looks. Falls back to\n * importing the peer dependency.\n */\n\nimport type { LngLat, Map as MapLibreMap } from 'maplibre-gl';\n\n/**\n * The subset of the maplibre-gl module surface this library uses.\n */\nexport interface MaplibreModule {\n addProtocol(\n name: string,\n loadFn: (\n params: { url: string },\n abortController: AbortController,\n ) => Promise<{ data: Uint8Array }>,\n ): void;\n removeProtocol(name: string): void;\n Popup: new (options?: {\n closeButton?: boolean;\n maxWidth?: string;\n className?: string;\n }) => {\n setLngLat(lngLat: LngLat | [number, number]): unknown;\n setDOMContent(node: Node): unknown;\n addTo(map: MapLibreMap): unknown;\n remove(): void;\n };\n}\n\nlet modulePromise: Promise | undefined;\n\n/**\n * Resolves the maplibre-gl module, preferring the global instance.\n *\n * @returns The maplibre-gl module\n */\nexport function getMaplibre(): Promise {\n if (!modulePromise) {\n const globalMaplibre = (globalThis as Record).maplibregl as\n | MaplibreModule\n | undefined;\n if (globalMaplibre && typeof globalMaplibre.addProtocol === 'function') {\n modulePromise = Promise.resolve(globalMaplibre);\n } else {\n modulePromise = import('maplibre-gl').then(\n (module) => (module.default ?? module) as unknown as MaplibreModule,\n );\n }\n modulePromise.catch(() => {\n modulePromise = undefined;\n });\n }\n return modulePromise;\n}\n","import { getMaplibre } from '../utils/maplibre';\n\n/**\n * Custom protocol scheme used for dynamic DuckDB tiles.\n */\nexport const TILE_PROTOCOL = 'duckdb';\n\n/**\n * Produces an MVT tile for a z/x/y request.\n */\nexport type TileProvider = (\n z: number,\n x: number,\n y: number,\n signal: AbortSignal,\n) => Promise;\n\nconst providers = new Map();\nlet protocolRegistered = false;\n\n/**\n * Builds the tile URL template for a registered tile provider.\n *\n * The key is URI-encoded so it round-trips through parseTileUrl even\n * when it contains reserved characters.\n *\n * @param providerKey - The provider registry key\n * @returns The duckdb:// tile URL template\n */\nexport function tileUrlFor(providerKey: string): string {\n return `${TILE_PROTOCOL}://${encodeURIComponent(providerKey)}/{z}/{x}/{y}`;\n}\n\n/**\n * Parsed components of a duckdb:// tile URL.\n */\nexport interface ParsedTileUrl {\n providerKey: string;\n z: number;\n x: number;\n y: number;\n}\n\n/**\n * Parses a duckdb:// tile URL into its components.\n *\n * @param url - The request URL\n * @returns The parsed components, or null when the URL is not a tile URL\n */\nexport function parseTileUrl(url: string): ParsedTileUrl | null {\n const match = new RegExp(`^${TILE_PROTOCOL}://([^/]+)/(\\\\d+)/(\\\\d+)/(\\\\d+)(?:\\\\.pbf)?$`).exec(\n url,\n );\n if (!match) return null;\n return {\n providerKey: decodeURIComponent(match[1]),\n z: Number(match[2]),\n x: Number(match[3]),\n y: Number(match[4]),\n };\n}\n\n/**\n * Handles a tile request for the duckdb:// protocol.\n *\n * Unknown layers resolve to an empty tile so requests in flight during\n * layer removal do not surface errors.\n *\n * @param url - The request URL\n * @param signal - Abort signal from MapLibre\n * @returns The tile bytes\n */\nexport async function loadTile(url: string, signal: AbortSignal): Promise {\n const parsed = parseTileUrl(url);\n if (!parsed) {\n throw new Error(`Invalid ${TILE_PROTOCOL}:// tile URL: ${url}`);\n }\n\n const provider = providers.get(parsed.providerKey);\n if (!provider) return new Uint8Array(0);\n\n return provider(parsed.z, parsed.x, parsed.y, signal);\n}\n\n/**\n * Registers a tile provider, installing the duckdb:// protocol handler\n * on first use.\n *\n * The registry is process-wide, so callers must pass a globally unique\n * key (not the public layer id, which can repeat across controls).\n *\n * Resolves once the protocol handler is installed, so a tile source\n * added afterwards is guaranteed to find it.\n *\n * @param providerKey - Globally unique provider registry key\n * @param provider - The tile provider\n */\nexport async function registerTileProvider(\n providerKey: string,\n provider: TileProvider,\n): Promise {\n providers.set(providerKey, provider);\n if (!protocolRegistered) {\n const api = await getMaplibre();\n if (!protocolRegistered) {\n api.addProtocol(TILE_PROTOCOL, async (params, abortController) => {\n const data = await loadTile(params.url, abortController.signal);\n return { data };\n });\n protocolRegistered = true;\n }\n }\n}\n\n/**\n * Removes a tile provider, uninstalling the protocol handler when no\n * providers remain.\n *\n * @param providerKey - The provider registry key\n */\nexport function unregisterTileProvider(providerKey: string): void {\n providers.delete(providerKey);\n if (providers.size === 0 && protocolRegistered) {\n void getMaplibre()\n .then((api) => {\n // Re-check: a provider may have been registered meanwhile.\n if (providers.size === 0 && protocolRegistered) {\n api.removeProtocol(TILE_PROTOCOL);\n protocolRegistered = false;\n }\n })\n .catch(() => {\n // Leave state unchanged; a later unregister can retry teardown.\n });\n }\n}\n\n/**\n * Returns whether a tile provider is registered for a key.\n *\n * @param providerKey - The provider registry key\n * @returns True when a provider is registered\n */\nexport function hasTileProvider(providerKey: string): boolean {\n return providers.has(providerKey);\n}\n","import type { Map as MapLibreMap } from 'maplibre-gl';\nimport type { Bbox } from './geometry';\n\n/**\n * Globe-safe camera fitting.\n *\n * A globe can only ever show half the planet's longitudes at once, so an extent\n * wider than a hemisphere has no camera that contains it. MapLibre's\n * `fitBounds` does not treat that as the special case it is: past roughly a\n * hemisphere its globe camera solver stops pulling back and starts zooming *in*\n * again. Measured against a live map on a 576x648 viewport with 40px padding,\n * sampling the box outline to see how much of it lands inside the padded\n * viewport:\n *\n * | bbox width | globe zoom | outline in frame | flat-map zoom |\n * | ---------- | ---------- | ---------------- | ------------- |\n * | 90 deg | 2.27 | 42/42 | 1.95 |\n * | 150 deg | 1.97 | 42/42 | 1.22 |\n * | 170 deg | 2.00 | 42/42 | 1.07 |\n * | 175 deg | 2.01 | 34/42 | 1.03 |\n * | 259 deg | 3.10 | 10/42 | 0.43 |\n * | 360 deg | 2.36 | 46/84 | 0.00 |\n *\n * So MapLibre frames narrow and continent-scale extents correctly and only\n * breaks down past a hemisphere, where it leaves the data behind the horizon\n * and the layer reads as \"added, but nothing on the map\". It takes very little\n * to get there: a mostly-US point layer with three records in Europe and Asia\n * already spans 259 degrees.\n *\n * {@link fitMapToBbox} therefore caps the zoom at the flat Web Mercator fit for\n * exactly those extents, so the camera settles on a whole-globe view instead.\n * Fits MapLibre already handles are passed through untouched. The cap is a\n * ceiling and never a floor, so it cannot tighten a fit; and under the mercator\n * projection it equals what `fitBounds` computes anyway, making it a no-op\n * there.\n */\n\n/**\n * The latitude at which Web Mercator is truncated; the projection runs to\n * infinity at the poles.\n */\nconst MAX_MERCATOR_LATITUDE = 85.051129;\n\n/** The tile size MapLibre's zoom scale is defined against. */\nconst TILE_SIZE = 512;\n\n/**\n * The widest longitude span a globe can show at once: half the planet. Past\n * this, no camera contains the extent and MapLibre's globe fit degrades (see\n * the measurements above), so the flat-map ceiling takes over. The measured\n * boundary sits a little under this (containment ends around 175 degrees on a\n * 576x648 viewport, since the padding eats into the visible hemisphere), but\n * the geometric limit is used rather than a viewport-tuned constant: extents in\n * that narrow band keep MapLibre's own fit, which puts only their extreme\n * east/west edges just outside the padding.\n */\nconst GLOBE_VISIBLE_LONGITUDE_SPAN = 180;\n\n/** Normalized (0..1) Web Mercator northing for a latitude in degrees. */\nfunction mercatorY(latitude: number): number {\n const clamped = Math.min(MAX_MERCATOR_LATITUDE, Math.max(-MAX_MERCATOR_LATITUDE, latitude));\n return 0.5 - Math.log(Math.tan(Math.PI / 4 + (clamped * Math.PI) / 360)) / (2 * Math.PI);\n}\n\n/**\n * The longitude span of a bbox in degrees, taking the short way round so an\n * extent crossing the antimeridian (`west` greater than `east`, e.g.\n * `[170, …, -170, …]`) reads as the ~20 degrees it covers rather than the ~340\n * degree complement. A full-world box (`[-180, …, 180, …]`) still reads as 360.\n *\n * @param west - The bbox's western edge in degrees\n * @param east - The bbox's eastern edge in degrees\n * @returns The span in degrees, in [0, 360]\n */\nexport function longitudeSpan(west: number, east: number): number {\n const span = east - west;\n if (span >= 360) return 360;\n return ((span % 360) + 360) % 360;\n}\n\n/**\n * Computes the zoom at which a bbox fits a viewport under flat Web Mercator.\n *\n * @param bbox - The extent to fit, as [west, south, east, north] in EPSG:4326.\n * A `west` greater than `east` is read as crossing the antimeridian.\n * @param viewport - The map viewport size in CSS pixels\n * @param padding - Padding to keep free on every side, in CSS pixels\n * @returns The fitting zoom, or undefined when the inputs cannot produce one\n * (an unmeasurable viewport, or an extent with no width and no height)\n */\nexport function mercatorFitZoom(\n bbox: Bbox,\n viewport: { width: number; height: number },\n padding: number,\n): number | undefined {\n if (!bbox.every((value) => Number.isFinite(value))) return undefined;\n const [west, south, east, north] = bbox;\n const usableWidth = viewport.width - 2 * padding;\n const usableHeight = viewport.height - 2 * padding;\n if (!(usableWidth > 0) || !(usableHeight > 0)) return undefined;\n\n // Either span may be zero (a point layer, or a horizontal line); such an\n // axis simply places no constraint on the zoom.\n const worldFractionX = longitudeSpan(west, east) / 360;\n const worldFractionY = Math.abs(mercatorY(south) - mercatorY(north));\n\n const scales: number[] = [];\n if (worldFractionX > 0) scales.push(usableWidth / (TILE_SIZE * worldFractionX));\n if (worldFractionY > 0) scales.push(usableHeight / (TILE_SIZE * worldFractionY));\n if (scales.length === 0) return undefined;\n\n const zoom = Math.log2(Math.min(...scales));\n return Number.isFinite(zoom) ? zoom : undefined;\n}\n\n/** The camera options {@link fitMapToBbox} forwards to `map.fitBounds`. */\nexport interface FitBboxOptions {\n /** Padding to keep free on every side, in CSS pixels. */\n padding: number;\n /** Animation length in milliseconds. */\n duration?: number;\n /** The closest zoom the fit may settle on, before the flat-map ceiling. */\n maxZoom?: number;\n}\n\n/**\n * Reads the map's viewport in CSS pixels, when it can be measured. A canvas\n * that has never been laid out (jsdom, a detached container) reports zero and\n * yields undefined, so the caller skips the ceiling rather than computing one\n * from a bogus size.\n */\nfunction viewportOf(map: MapLibreMap): { width: number; height: number } | undefined {\n const canvas = typeof map.getCanvas === 'function' ? map.getCanvas() : undefined;\n const width = canvas?.clientWidth ?? 0;\n const height = canvas?.clientHeight ?? 0;\n return width > 0 && height > 0 ? { width, height } : undefined;\n}\n\n/**\n * The zoom ceiling to send with a fit: the caller's own, tightened to the\n * flat-map fit for an extent too wide for any globe camera to contain.\n */\nfunction ceilingFor(\n map: MapLibreMap,\n bbox: Bbox,\n options: FitBboxOptions,\n): number | undefined {\n const [west, , east] = bbox;\n const fitsOnAGlobe =\n !Number.isFinite(west) ||\n !Number.isFinite(east) ||\n longitudeSpan(west, east) <= GLOBE_VISIBLE_LONGITUDE_SPAN;\n if (fitsOnAGlobe) return options.maxZoom;\n\n const viewport = viewportOf(map);\n const flatZoom = viewport ? mercatorFitZoom(bbox, viewport, options.padding) : undefined;\n if (flatZoom === undefined) return options.maxZoom;\n return Math.min(flatZoom, options.maxZoom ?? Number.POSITIVE_INFINITY);\n}\n\n/**\n * Fits the map to a bbox, capping the zoom at the flat-map fit when the extent\n * is wider than a globe can show, so it cannot be framed on empty space.\n *\n * @param map - The map to move\n * @param bbox - The extent to fit, as [west, south, east, north] in EPSG:4326\n * @param options - Padding, animation length, and an optional zoom ceiling\n */\nexport function fitMapToBbox(map: MapLibreMap, bbox: Bbox, options: FitBboxOptions): void {\n const maxZoom = ceilingFor(map, bbox, options);\n\n map.fitBounds(\n [\n [bbox[0], bbox[1]],\n [bbox[2], bbox[3]],\n ],\n {\n padding: options.padding,\n ...(options.duration === undefined ? {} : { duration: options.duration }),\n ...(maxZoom === undefined ? {} : { maxZoom }),\n },\n );\n}\n","/**\n * Clamps a value between a minimum and maximum.\n *\n * @param value - The value to clamp\n * @param min - The minimum allowed value\n * @param max - The maximum allowed value\n * @returns The clamped value\n *\n * @example\n * ```typescript\n * clamp(5, 0, 10); // returns 5\n * clamp(-5, 0, 10); // returns 0\n * clamp(15, 0, 10); // returns 10\n * ```\n */\nexport function clamp(value: number, min: number, max: number): number {\n return Math.min(Math.max(value, min), max);\n}\n\n/**\n * Formats a numeric value with appropriate decimal places based on step size.\n *\n * @param value - The value to format\n * @param step - The step size to determine decimal places\n * @returns The formatted value as a string\n *\n * @example\n * ```typescript\n * formatNumericValue(5, 1); // returns \"5\"\n * formatNumericValue(0.5, 0.1); // returns \"0.5\"\n * formatNumericValue(0.55, 0.01); // returns \"0.55\"\n * ```\n */\nexport function formatNumericValue(value: number, step: number): string {\n if (step === 0) return value.toString();\n const decimals = Math.max(0, -Math.floor(Math.log10(step)));\n return value.toFixed(decimals);\n}\n\n/**\n * Generates a unique ID string.\n *\n * @param prefix - Optional prefix for the ID\n * @returns A unique ID string\n *\n * @example\n * ```typescript\n * generateId('control'); // returns \"control-abc123\"\n * generateId(); // returns \"abc123\"\n * ```\n */\nexport function generateId(prefix?: string): string {\n const id = Math.random().toString(36).substring(2, 9);\n return prefix ? `${prefix}-${id}` : id;\n}\n\n/**\n * Debounces a function call.\n *\n * @param fn - The function to debounce\n * @param delay - The delay in milliseconds\n * @returns A debounced version of the function\n *\n * @example\n * ```typescript\n * const debouncedUpdate = debounce(() => updateMap(), 100);\n * window.addEventListener('resize', debouncedUpdate);\n * ```\n */\nexport function debounce void>(\n fn: T,\n delay: number\n): (...args: Parameters) => void {\n let timeoutId: ReturnType | null = null;\n\n return (...args: Parameters) => {\n if (timeoutId) {\n clearTimeout(timeoutId);\n }\n timeoutId = setTimeout(() => {\n fn(...args);\n timeoutId = null;\n }, delay);\n };\n}\n\n/**\n * Throttles a function call.\n *\n * @param fn - The function to throttle\n * @param limit - The minimum time between calls in milliseconds\n * @returns A throttled version of the function\n *\n * @example\n * ```typescript\n * const throttledScroll = throttle(() => handleScroll(), 100);\n * window.addEventListener('scroll', throttledScroll);\n * ```\n */\nexport function throttle void>(\n fn: T,\n limit: number\n): (...args: Parameters) => void {\n let inThrottle = false;\n\n return (...args: Parameters) => {\n if (!inThrottle) {\n fn(...args);\n inThrottle = true;\n setTimeout(() => {\n inThrottle = false;\n }, limit);\n }\n };\n}\n\n/**\n * Creates a CSS class string from an object of class names.\n *\n * @param classes - Object with class names as keys and boolean values\n * @returns A space-separated string of class names\n *\n * @example\n * ```typescript\n * classNames({ active: true, disabled: false, visible: true });\n * // returns \"active visible\"\n * ```\n */\nexport function classNames(classes: Record): string {\n return Object.entries(classes)\n .filter(([, value]) => value)\n .map(([key]) => key)\n .join(' ');\n}\n","/**\n * Remote file size probing.\n *\n * DuckDB-WASM's HTTP filesystem handles remote file sizes as 32-bit\n * values; files of 2 GiB or larger fail to open with an opaque\n * \"Cannot read properties of null (reading 'byteLength')\" error.\n * Probing the size up front (before the ~20 MB engine download even\n * starts) turns that into an immediate, actionable message.\n */\n\n/**\n * Largest remote file DuckDB-WASM can open.\n */\nexport const MAX_REMOTE_FILE_BYTES = 2 ** 31 - 1;\n\nconst sizes = new Map();\n\n/**\n * Returns the remote file size from a HEAD request, cached per URL.\n *\n * @param url - The http(s) URL to probe\n * @returns The content length in bytes, or undefined when the HEAD is\n * blocked or reports no length\n */\nexport async function probeRemoteSize(url: string): Promise {\n if (!/^https?:\\/\\//i.test(url)) return undefined;\n if (!sizes.has(url)) {\n let size: number | undefined;\n try {\n const response = await fetch(url, { method: 'HEAD' });\n const length = response.headers.get('content-length');\n if (length) size = Number(length);\n } catch {\n // HEAD unavailable (CORS or method blocked); let DuckDB try.\n }\n sizes.set(url, size);\n }\n return sizes.get(url);\n}\n\n/**\n * Probes a remote file's size and rejects files DuckDB-WASM cannot\n * open (2 GiB or larger).\n *\n * @param url - The http(s) URL to check\n * @returns The content length in bytes, when known\n * @throws Error with an actionable message for oversized files\n */\nexport async function assertRemoteFileSupported(url: string): Promise {\n const size = await probeRemoteSize(url);\n if (size !== undefined && size > MAX_REMOTE_FILE_BYTES) {\n const gib = (size / 1024 ** 3).toFixed(2);\n throw new Error(\n `This file is ${gib} GiB; DuckDB-WASM cannot open remote files of 2 GiB or larger. ` +\n `Use a smaller file or partition (e.g. split by region).`,\n );\n }\n return size;\n}\n","import type { Map as MapLibreMap, MapLayerMouseEvent } from 'maplibre-gl';\nimport type { FeatureCollection } from 'geojson';\nimport type {\n RenderMode,\n VectorControlEvent,\n VectorControlOptions,\n VectorDataSource,\n VectorLayerInfo,\n VectorLayerOptions,\n VectorLayerStyle,\n VectorLayerSelector,\n} from './types';\nimport { VectorLayerSelectionCancelledError } from './errors';\nimport { openLayerPicker, type LayerPickerHandle } from '../ui/layerPicker';\nimport type { EngineProvider } from '../engine/types';\nimport type { VectorSourceDescriptor } from './types';\nimport { detectSource } from '../formats/detect';\nimport { sniffRemoteGeoJSON } from '../formats/geojsonSniff';\nimport { enhanceKmzGeoJSON, prepareKmzIcons } from '../formats/kmzMetadata';\nimport { decideRenderMode } from '../render/renderMode';\nimport {\n DEFAULT_LABEL_SIZE,\n DEFAULT_STYLE,\n applyOpacity,\n applyStyle,\n clampOpacity,\n hasLabels,\n labelTextField,\n mapLayerId,\n pointModeOf,\n} from '../render/styleBuilder';\nimport {\n addGeoJSONSource,\n addGeometryLayers,\n addLabelLayer,\n addVectorTileSource,\n clusterOptionsFor,\n removeLayersAndSource,\n setLayersVisibility,\n sourceIdFor,\n} from '../render/mapSources';\nimport { registerTileProvider, tileUrlFor, unregisterTileProvider } from '../tiles/protocol';\nimport {\n collectFieldNames,\n crsFromGeoJSON,\n summarizeFeatureCollection,\n toFeatureCollection,\n} from '../utils/geometry';\nimport { fitMapToBbox } from '../utils/fit';\nimport { generateId } from '../utils/helpers';\nimport { getMaplibre } from '../utils/maplibre';\nimport { assertRemoteFileSupported } from '../utils/remote';\n\n/**\n * Emits a control event with optional layer/error context.\n */\nexport type LayerManagerEmitter = (\n type: VectorControlEvent,\n extra?: { layer?: VectorLayerInfo; error?: Error; message?: string },\n) => void;\n\n/**\n * Dependencies injected into the layer manager.\n */\nexport interface LayerManagerDeps {\n map: MapLibreMap;\n options: VectorControlOptions;\n emit: LayerManagerEmitter;\n getEngine: EngineProvider;\n}\n\ninterface LayerRecord {\n info: VectorLayerInfo;\n source: VectorDataSource;\n /** Original URL when a host urlLoader materialized the source as a Blob. */\n remoteUrl?: string;\n sourceLayer?: string;\n fileName?: string;\n /** Sidecar files for a loose shapefile, registered alongside its `.shp`. */\n companionFiles?: File[];\n /**\n * The FeatureCollection backing a geojson-rendered layer, cached so a\n * structural restyle (pointMode/cluster change) can rebuild the source and\n * layers without re-fetching or reading it back from the map.\n */\n geojson?: FeatureCollection;\n /** Set once the source has been ingested into the engine */\n tableName?: string;\n /**\n * Globally unique key in the duckdb:// provider registry. Distinct\n * from the public layer id, which can repeat across controls.\n */\n providerKey?: string;\n /** Per-map-layer picker handlers, for cleanup */\n pickerHandlers?: PickerHandler[];\n}\n\ninterface PickerHandler {\n layerId: string;\n click: (e: MapLayerMouseEvent) => void;\n enter: () => void;\n leave: () => void;\n}\n\nconst DEFAULT_MAX_TILE_ZOOM = 16;\n\n/**\n * Builds a SQL-safe table name from a layer id.\n *\n * @param layerId - The vector layer id\n * @returns A sanitized table name\n */\nexport function tableNameFor(layerId: string): string {\n return `t_${layerId}`.replace(/[^a-zA-Z0-9_]/g, '_');\n}\n\n/**\n * Describes where a data source came from, so hosts can persist and\n * later recreate URL-backed layers (files and objects cannot be\n * recreated from the descriptor).\n *\n * @param source - The data source passed to addData\n * @param sourcePath - Host-meaningful path a File/Blob was read from, echoed\n * on the descriptor so the host can re-read it on project restore. Ignored\n * for URL and GeoJSON-object sources.\n * @returns The public source descriptor\n */\nexport function describeSource(\n source: VectorDataSource,\n sourcePath?: string,\n): VectorSourceDescriptor {\n if (typeof source === 'string') {\n return { kind: 'url', url: source };\n }\n const path = sourcePath?.trim() ? sourcePath : undefined;\n if (typeof File !== 'undefined' && source instanceof File) {\n return { kind: 'file', fileName: source.name, ...(path ? { path } : {}) };\n }\n if (typeof Blob !== 'undefined' && source instanceof Blob) {\n return { kind: 'file', ...(path ? { path } : {}) };\n }\n return { kind: 'geojson' };\n}\n\n/**\n * Detects a loose `.shp` file that cannot be read because its required\n * `.shx`/`.dbf` siblings were not provided.\n *\n * A shapefile is a set of files. A lone `.shp` (or one missing the index or\n * attribute sidecar) makes GDAL fail with an opaque \"GDALOpen() called on\n * x.shp recursively\" error; callers use this to surface an actionable message\n * instead. A zipped shapefile (`.zip`) carries its components, so it is never\n * flagged.\n *\n * @param source - The data source passed to addData.\n * @param options - The layer options, whose `companionFiles` hold the sidecars.\n * @returns True when the source is a `.shp` lacking its `.shx` or `.dbf`.\n */\nexport function isLooseShapefileMissingSiblings(\n source: VectorDataSource,\n options: VectorLayerOptions,\n): boolean {\n if (typeof File === 'undefined' || !(source instanceof File)) return false;\n if (!/\\.shp$/i.test(source.name)) return false;\n const extensions = new Set(\n (options.companionFiles ?? []).map((file) =>\n file.name.slice(file.name.lastIndexOf('.') + 1).toLowerCase(),\n ),\n );\n return !extensions.has('shx') || !extensions.has('dbf');\n}\n\n/**\n * Owns the vector layers of a control: loading data, creating map\n * sources/layers, visibility, styling, render-mode switching, and\n * cleanup. Communicates with DuckDB only through the injected engine\n * provider, which is resolved lazily on first non-GeoJSON load.\n */\nexport class LayerManager {\n /**\n * Carries a materialized URL through multi-layer container expansion without\n * exposing an internal option on the public addData API.\n */\n private readonly _materializedUrls = new WeakMap();\n private _map: MapLibreMap;\n private _options: VectorControlOptions;\n private _emit: LayerManagerEmitter;\n private _getEngine: EngineProvider;\n private _records = new Map();\n private _popup?: { remove(): void };\n private _popupOwnerId?: string;\n private _pendingTiles = 0;\n private _tileStatusTimer?: ReturnType;\n // Multi-layer pickers currently on screen (or queued), so dispose() can\n // close them instead of orphaning a modal in the map container.\n private _openPickers = new Set();\n\n /**\n * Creates a layer manager.\n *\n * @param deps - Injected dependencies\n */\n constructor(deps: LayerManagerDeps) {\n this._map = deps.map;\n this._options = deps.options;\n this._emit = deps.emit;\n this._getEngine = deps.getEngine;\n }\n\n /**\n * Returns metadata for all loaded layers.\n */\n getLayers(): VectorLayerInfo[] {\n return Array.from(this._records.values(), (record) => ({ ...record.info }));\n }\n\n /**\n * Returns metadata for a single layer.\n *\n * @param id - The layer id\n */\n getLayer(id: string): VectorLayerInfo | undefined {\n const record = this._records.get(id);\n return record ? { ...record.info } : undefined;\n }\n\n /**\n * Recreates every managed source and layer removed by MapLibre's setStyle.\n * The layer records retain their original data source or engine table, so a\n * basemap swap can rebuild the presentation without losing user state.\n */\n async restoreLayersAfterStyleChange(): Promise {\n for (const record of this._records.values()) {\n const sourceExists = Boolean(this._map.getSource(record.info.sourceId));\n const layersExist = record.info.layerIds.every((id) => Boolean(this._map.getLayer(id)));\n if (sourceExists && layersExist) continue;\n\n this._detachPicker(record);\n if (sourceExists) {\n for (const id of record.info.layerIds) {\n if (this._map.getLayer(id)) this._map.removeLayer(id);\n }\n record.info.layerIds = addGeometryLayers(this._map, {\n layerId: record.info.id,\n geometryType: record.info.geometryType,\n style: record.info.style,\n visible: record.info.visible,\n opacity: record.info.opacity,\n sourceLayer: record.info.renderMode === 'tiles' ? record.info.id : undefined,\n beforeId:\n record.info.beforeId && this._map.getLayer(record.info.beforeId)\n ? record.info.beforeId\n : undefined,\n });\n this._attachPicker(record);\n this._emit('layerupdated', { layer: { ...record.info } });\n continue;\n }\n record.info.layerIds = [];\n if (record.info.renderMode === 'tiles') {\n await this._presentTiles(record);\n } else {\n await this._presentGeoJSON(record);\n }\n this._emit('layerupdated', { layer: { ...record.info } });\n }\n }\n\n /**\n * Materializes a layer's features as a GeoJSON FeatureCollection, so a host\n * can persist the data of a layer loaded from a local file (which a saved\n * project cannot otherwise recreate). The data comes from the cached\n * collection (point geojson layers), the DuckDB table (engine/tiles layers),\n * or the layer's map source (line/polygon geojson layers). Returns null for\n * an unknown id, or a layer whose data is not held locally (e.g. a GeoParquet\n * streamed in place, which is queried from its source per tile).\n *\n * @param id - The layer id.\n * @returns The features as a FeatureCollection, or null when unavailable.\n */\n async getLayerGeoJSON(id: string): Promise {\n const record = this._records.get(id);\n if (!record) return null;\n if (record.geojson) {\n return enhanceKmzGeoJSON(\n record.source,\n record.geojson,\n record.fileName ??\n (record.info.source.kind === 'file' ? record.info.source.fileName : undefined),\n );\n }\n if (record.tableName) {\n const engine = await this._getEngine();\n return enhanceKmzGeoJSON(\n record.source,\n await engine.exportGeoJSON(record.tableName),\n record.fileName ??\n (record.info.source.kind === 'file' ? record.info.source.fileName : undefined),\n );\n }\n // A line/polygon geojson layer keeps no cached copy (to avoid pinning the\n // heap), but its data lives in the map source it was added with.\n const source = this._map.getSource(record.info.sourceId);\n const serialized = source?.serialize() as { data?: unknown } | undefined;\n const data = serialized?.data;\n if (data && typeof data === 'object' && (data as FeatureCollection).type) {\n return data as FeatureCollection;\n }\n return null;\n }\n\n /**\n * Reads the non-null values of one layer attribute without materializing\n * engine-backed geometry. This keeps classification and other\n * attribute-driven host controls usable for large tiled layers.\n *\n * @param id - The layer id.\n * @param property - An attribute field name.\n * @returns The values, or null when the layer or field is unavailable.\n */\n async getLayerPropertyValues(id: string, property: string): Promise {\n const record = this._records.get(id);\n if (!record || !record.info.fields?.includes(property)) return null;\n if (record.tableName) {\n const engine = await this._getEngine();\n return engine.getPropertyValues(record.tableName, property);\n }\n const collection = await this.getLayerGeoJSON(id);\n if (!collection) return null;\n return collection.features\n .map((feature) => feature.properties?.[property])\n .filter((value) => value !== null && value !== undefined);\n }\n\n /**\n * Loads a data source and adds it to the map.\n *\n * @param source - URL string, File/Blob, or GeoJSON object\n * @param options - Layer options\n * @returns Metadata of the added layer\n */\n async addData(\n source: VectorDataSource,\n options: VectorLayerOptions = {},\n ): Promise {\n const detected = detectSource(source, options.format);\n const id = options.id ?? generateId('vector');\n if (this._records.has(id)) {\n throw new Error(`Layer \"${id}\" already exists`);\n }\n let remoteUrl =\n typeof source === 'object' && source !== null\n ? this._materializedUrls.get(source as object)\n : undefined;\n if (\n typeof source === 'string' &&\n /^https?:\\/\\//i.test(source) &&\n this._options.urlLoader\n ) {\n remoteUrl = source;\n this._emit('loading', { message: `Downloading ${detected.name}...` });\n try {\n const loaded = await this._options.urlLoader(source);\n if (!loaded) {\n remoteUrl = undefined;\n } else {\n const isGeoJSON = /(?:^|[/+])(?:geo)?json(?:;|$)/i.test(loaded.type);\n if (detected.format === 'unknown' && isGeoJSON) detected.format = 'geojson';\n const fileName =\n isGeoJSON && !/\\.[a-z0-9]+$/i.test(detected.name)\n ? `${detected.name}.geojson`\n : detected.name;\n source =\n typeof File !== 'undefined' && loaded instanceof File\n ? loaded\n : new File([loaded], fileName, { type: loaded.type });\n this._materializedUrls.set(source, remoteUrl);\n }\n } catch (err) {\n const error = err instanceof Error ? err : new Error(String(err));\n this._emit('error', { error });\n throw error;\n }\n }\n\n // A shapefile is several files. A lone `.shp` (or one missing its `.shx`/\n // `.dbf` siblings) cannot be read, and GDAL fails with an opaque\n // \"GDALOpen() called on x.shp recursively\" error. Surface an actionable\n // message instead, before any engine work, telling the user to select the\n // companion files too (or load the shapefile as a single `.zip`).\n if (detected.format === 'shapefile' && isLooseShapefileMissingSiblings(source, options)) {\n const error = new Error(\n 'A shapefile is a set of files. Select the .shp together with its ' +\n '.shx and .dbf files (and .prj, .cpg if present), or load the ' +\n 'shapefile as a single .zip archive.',\n );\n this._emit('error', { error });\n throw error;\n }\n\n // Extensionless remote URLs (OGC API Features / ArcGIS `f=geojson`, custom\n // service endpoints with query strings) return GeoJSON the file-name\n // detector classifies as 'unknown', which would route to the DuckDB engine\n // and its remote spatial-extension install -- a hang in sandboxed/offline\n // environments. Sniff the response first so a GeoJSON endpoint stays on the\n // pure-JS path; the fetched data is reused so it is not re-downloaded.\n let prefetchedGeoJSON: { collection: FeatureCollection; byteSize?: number } | undefined;\n if (\n detected.format === 'unknown' &&\n !options.format &&\n options.renderMode !== 'tiles' &&\n typeof source === 'string' &&\n !source.startsWith('data:')\n ) {\n const sniffed = await sniffRemoteGeoJSON(source);\n if (sniffed) {\n detected.format = 'geojson';\n prefetchedGeoJSON = sniffed;\n }\n }\n\n // Reject remote files DuckDB-WASM cannot open BEFORE the engine\n // download starts, so the error is immediate.\n const engineBound = !(detected.format === 'geojson' && options.renderMode !== 'tiles');\n if (engineBound && typeof source === 'string') {\n try {\n await assertRemoteFileSupported(source);\n } catch (err) {\n const error = err instanceof Error ? err : new Error(String(err));\n this._emit('error', { error });\n throw error;\n }\n }\n\n // Multi-layer containers (GeoPackage tables, KML folders, ...)\n // expand into one vector layer per source layer.\n const expanded = await this._maybeExpandLayers(source, options, detected, id);\n if (expanded) return expanded;\n\n const name = options.name ?? detected.name;\n const style: VectorLayerStyle = { ...DEFAULT_STYLE, ...options.style };\n const visible = options.visible ?? true;\n\n const record: LayerRecord = {\n info: {\n id,\n name,\n source: remoteUrl\n ? { kind: 'url', url: remoteUrl }\n : describeSource(source, options.sourcePath),\n format: detected.format,\n renderMode: 'geojson',\n geometryType: 'unknown',\n visible,\n opacity: clampOpacity(options.opacity ?? 1),\n picker: options.picker ?? this._options.enablePicker ?? true,\n ingestMode: options.ingestMode ?? this._options.defaultIngestMode ?? 'table',\n sourceLayer: options.sourceLayer,\n sourceCrs: options.sourceCrs?.trim() || undefined,\n beforeId: options.beforeId ?? this._options.beforeId,\n style,\n sourceId: sourceIdFor(id),\n layerIds: [],\n },\n source,\n remoteUrl,\n sourceLayer: options.sourceLayer,\n fileName: typeof File !== 'undefined' && source instanceof File ? source.name : undefined,\n companionFiles: options.companionFiles,\n };\n\n this._emit('loading', { message: `Loading ${name}...` });\n\n try {\n if (detected.format === 'geojson' && options.renderMode !== 'tiles') {\n await this._addGeoJSON(record, options, prefetchedGeoJSON);\n } else {\n await this._addViaEngine(record, options);\n }\n } catch (err) {\n const error = err instanceof Error ? err : new Error(String(err));\n this._emit('error', { error });\n throw error;\n }\n\n this._records.set(id, record);\n if ((options.fitBounds ?? true) && record.info.bbox) {\n this._fitBounds(record.info.bbox);\n }\n this._emit('layeradded', { layer: { ...record.info } });\n return { ...record.info };\n }\n\n /**\n * Removes a layer from the map and the engine.\n *\n * @param id - The layer id\n */\n removeLayer(id: string): void {\n const record = this._records.get(id);\n if (!record) return;\n\n this._detachPicker(record);\n removeLayersAndSource(this._map, record.info.layerIds, record.info.sourceId);\n if (record.providerKey) unregisterTileProvider(record.providerKey);\n if (record.tableName) {\n const tableName = record.tableName;\n this._getEngine()\n .then((engine) => engine.dropTable(tableName))\n .catch(() => {\n // The engine is already gone or never loaded; nothing to clean up.\n });\n }\n this._records.delete(id);\n this._emit('layerremoved', { layer: { ...record.info } });\n }\n\n /**\n * Removes all layers.\n */\n removeAll(): void {\n for (const id of Array.from(this._records.keys())) {\n this.removeLayer(id);\n }\n }\n\n /**\n * Shows or hides a layer.\n *\n * @param id - The layer id\n * @param visible - Whether the layer should be visible\n */\n setLayerVisibility(id: string, visible: boolean): void {\n const record = this._records.get(id);\n if (!record) return;\n // Structural point-style changes replace the native MapLibre layers. The\n // cached flag can already match the requested value while a newly rebuilt\n // heatmap/circle layer has defaulted back to visible, so always reconcile\n // the current layer ids instead of treating an equal flag as a no-op.\n setLayersVisibility(this._map, record.info.layerIds, visible);\n const changed = record.info.visible !== visible;\n record.info.visible = visible;\n if (changed) this._emit('layerupdated', { layer: { ...record.info } });\n }\n\n /**\n * Zooms the map to a layer's extent.\n *\n * @param id - The layer id\n */\n zoomToLayer(id: string): void {\n const record = this._records.get(id);\n if (!record?.info.bbox) return;\n this._fitBounds(record.info.bbox);\n }\n\n /**\n * Applies a style patch to a layer.\n *\n * @param id - The layer id\n * @param patch - Partial style update\n */\n setLayerStyle(id: string, patch: Partial): void {\n const record = this._records.get(id);\n if (!record) return;\n const prev = record.info.style;\n const next = { ...prev, ...patch };\n record.info.style = next;\n // pointMode (and cluster radius/maxZoom) are structural: they change the\n // layer types and/or the source's clustering, which setPaintProperty cannot\n // express, so rebuild the layers instead of patching paint. The rebuild\n // re-adds the label layer from the current style, so no separate label\n // handling is needed on that branch.\n if (this._isStructuralPointChange(record, prev, next)) {\n // `_rebuildPointLayers` only replaces `record.info.layerIds` once it\n // resolves (it awaits KMZ icon preparation), so the event has to wait for\n // it. Emitting synchronously here would report the ids of the layers the\n // rebuild has just removed, and nothing emits again afterwards: a host\n // that mirrors `layerIds` to order or toggle the map layers would leave\n // the new heatmap/cluster layers unmanaged — they keep whatever stacking\n // the rebuild appended them with, above layers meant to sit over them.\n // `finally`, not `then`, so a failed rebuild still reports the record's\n // current state instead of going silent.\n void this._rebuildPointLayers(record).finally(() => {\n this._emit('layerupdated', { layer: { ...record.info } });\n });\n return;\n }\n if (this._isExtrusionToggle(record, prev, next)) {\n // Flipping extrusion on or off swaps a polygon layer between flat fill and\n // a fill-extrusion layer, which setPaintProperty cannot express; rebuild\n // the map layers (the source is unchanged). The rebuild re-adds the label\n // layer from the current style, so no separate label handling is needed.\n this._rebuildGeometryLayers(record);\n } else {\n applyStyle(this._map, record.info, patch, record.info.opacity);\n this._applyLabelChange(record, prev, next, patch);\n }\n this._emit('layerupdated', { layer: { ...record.info } });\n }\n\n /**\n * Reconciles the attribute label layer after a style patch: adds it when a\n * labelField is newly set, removes it when cleared, and otherwise applies\n * the label layout changes (text-field, size, placement, overlap) that\n * `applyStyle` (which only touches paint) cannot.\n */\n private _applyLabelChange(\n record: LayerRecord,\n prev: VectorLayerStyle,\n next: VectorLayerStyle,\n patch: Partial,\n ): void {\n const had = hasLabels(prev);\n const has = hasLabels(next);\n const labelId = mapLayerId(record.info.id, 'label');\n\n if (has && (!had || !this._map.getLayer(labelId))) {\n this._addLabelLayer(record);\n // The label layer joined layerIds, so re-wire the picker to cover it\n // (picker handlers are attached per layer id; see _attachPicker).\n this._refreshPicker(record);\n return;\n }\n if (!has) {\n if (had && this._map.getLayer(labelId)) {\n this._map.removeLayer(labelId);\n record.info.layerIds = record.info.layerIds.filter((id) => id !== labelId);\n // Drop the now-stale picker handler for the removed label layer.\n this._refreshPicker(record);\n }\n return;\n }\n\n // Both before and after have labels: apply the layout-side changes (paint\n // changes already went through applyStyle).\n if (patch.labelField !== undefined) {\n this._map.setLayoutProperty(labelId, 'text-field', labelTextField(next));\n }\n if (patch.labelSize !== undefined) {\n this._map.setLayoutProperty(labelId, 'text-size', next.labelSize ?? DEFAULT_LABEL_SIZE);\n }\n if (patch.labelPlacement !== undefined) {\n this._map.setLayoutProperty(\n labelId,\n 'symbol-placement',\n next.labelPlacement === 'line' ? 'line' : 'point',\n );\n }\n if (patch.labelAllowOverlap !== undefined) {\n const allow = next.labelAllowOverlap ?? false;\n this._map.setLayoutProperty(labelId, 'text-allow-overlap', allow);\n this._map.setLayoutProperty(labelId, 'text-ignore-placement', allow);\n }\n }\n\n /**\n * Adds the attribute label layer for a record and records its id, choosing\n * the source-layer for tile-rendered layers.\n */\n private _addLabelLayer(record: LayerRecord): void {\n const labelId = mapLayerId(record.info.id, 'label');\n if (this._map.getLayer(labelId)) return;\n addLabelLayer(this._map, {\n layerId: record.info.id,\n style: record.info.style,\n visible: record.info.visible,\n opacity: record.info.opacity,\n sourceLayer: record.info.renderMode === 'tiles' ? record.info.id : undefined,\n beforeId: record.info.beforeId,\n });\n if (!record.info.layerIds.includes(labelId)) record.info.layerIds.push(labelId);\n }\n\n /**\n * Re-attaches the picker so its handlers cover the current `layerIds` after a\n * label layer is added or removed at runtime. A no-op when the picker is off.\n */\n private _refreshPicker(record: LayerRecord): void {\n if (!record.info.picker) return;\n this._detachPicker(record);\n this._attachPicker(record);\n }\n\n /**\n * Whether a style change requires rebuilding a geojson point layer's map\n * layers (a pointMode switch, or a cluster radius/maxZoom change while\n * clustered) rather than a plain paint update.\n */\n private _isStructuralPointChange(\n record: LayerRecord,\n prev: VectorLayerStyle,\n next: VectorLayerStyle,\n ): boolean {\n if (record.info.renderMode !== 'geojson' || record.info.geometryType !== 'point') {\n return false;\n }\n if (pointModeOf(prev) !== pointModeOf(next)) return true;\n return (\n pointModeOf(next) === 'cluster' &&\n ((prev.clusterRadius ?? 50) !== (next.clusterRadius ?? 50) ||\n (prev.clusterMaxZoom ?? 14) !== (next.clusterMaxZoom ?? 14))\n );\n }\n\n /**\n * Whether a style change toggles 3D extrusion on a layer with polygon\n * geometry, which swaps the flat `fill`/`outline` layers for a single\n * `fill-extrusion` layer (and back). Such a change is structural — the map\n * layer types differ — so it cannot be a plain paint update. Restyle edits\n * made while extrusion stays on (color/height/base/opacity) are paint ops.\n */\n private _isExtrusionToggle(\n record: LayerRecord,\n prev: VectorLayerStyle,\n next: VectorLayerStyle,\n ): boolean {\n const geometry = record.info.geometryType;\n if (geometry !== 'polygon' && geometry !== 'mixed' && geometry !== 'unknown') {\n return false;\n }\n return (prev.extrusionEnabled === true) !== (next.extrusionEnabled === true);\n }\n\n /**\n * Rebuilds a layer's map layers from the existing source, so an extrusion\n * toggle re-creates the polygon layers (flat fill vs fill-extrusion) without\n * re-fetching or re-adding the source. Preserves the picker.\n */\n private _rebuildGeometryLayers(record: LayerRecord): void {\n this._detachPicker(record);\n for (const id of record.info.layerIds) {\n if (this._map.getLayer(id)) this._map.removeLayer(id);\n }\n record.info.layerIds = addGeometryLayers(this._map, {\n layerId: record.info.id,\n geometryType: record.info.geometryType,\n style: record.info.style,\n visible: record.info.visible,\n opacity: record.info.opacity,\n sourceLayer: record.info.renderMode === 'tiles' ? record.info.id : undefined,\n beforeId: record.info.beforeId,\n });\n this._attachPicker(record);\n }\n\n /**\n * Rebuilds a geojson point layer's source and map layers from the data\n * already held by the source, so a pointMode/cluster change takes effect\n * without re-fetching. Preserves the picker.\n */\n private async _rebuildPointLayers(record: LayerRecord): Promise {\n // Use the cached FeatureCollection: reading it back from the map via\n // source.serialize() is unreliable for a clustered source.\n const collection = record.geojson;\n if (!collection) return;\n const sourceId = record.info.sourceId;\n this._detachPicker(record);\n removeLayersAndSource(this._map, record.info.layerIds, sourceId);\n addGeoJSONSource(\n this._map,\n record.info.id,\n collection,\n this._options.attribution,\n clusterOptionsFor(record.info.geometryType, record.info.style),\n );\n const kmlIconImage = await prepareKmzIcons(this._map, collection);\n record.info.layerIds = addGeometryLayers(this._map, {\n layerId: record.info.id,\n geometryType: record.info.geometryType,\n style: record.info.style,\n visible: record.info.visible,\n opacity: record.info.opacity,\n beforeId: record.info.beforeId,\n kmlIconImage,\n });\n this._attachPicker(record);\n }\n\n /**\n * Sets a layer's master opacity, multiplied into every style opacity\n * (fill, circle, and line layers alike).\n *\n * @param id - The layer id\n * @param opacity - The new opacity (0-1)\n */\n setLayerOpacity(id: string, opacity: number): void {\n const record = this._records.get(id);\n if (!record) return;\n const clamped = clampOpacity(opacity);\n if (record.info.opacity === clamped) return;\n record.info.opacity = clamped;\n applyOpacity(this._map, record.info, record.info.style, clamped);\n this._emit('layerupdated', { layer: { ...record.info } });\n }\n\n /**\n * Enables or disables the attribute popup for a layer.\n *\n * @param id - The layer id\n * @param enabled - Whether clicking a feature opens a popup\n */\n setLayerPicker(id: string, enabled: boolean): void {\n const record = this._records.get(id);\n if (!record || record.info.picker === enabled) return;\n record.info.picker = enabled;\n this._detachPicker(record);\n if (enabled) this._attachPicker(record);\n this._emit('layerupdated', { layer: { ...record.info } });\n }\n\n /**\n * Moves a layer's map layers before another map layer (or to the top\n * when omitted).\n *\n * @param id - The layer id\n * @param beforeId - Target map layer id, or undefined for the top\n */\n setLayerBeforeId(id: string, beforeId?: string): void {\n const record = this._records.get(id);\n if (!record) return;\n const target = beforeId && this._map.getLayer(beforeId) ? beforeId : undefined;\n // Moving in creation order keeps the group's internal stacking.\n for (const layerId of record.info.layerIds) {\n this._map.moveLayer(layerId, target);\n }\n record.info.beforeId = target;\n this._emit('layerupdated', { layer: { ...record.info } });\n }\n\n /**\n * Switches a layer between GeoJSON and dynamic tile rendering.\n *\n * @param id - The layer id\n * @param mode - The requested render mode\n */\n async setRenderMode(id: string, mode: RenderMode): Promise {\n const record = this._records.get(id);\n if (!record) return;\n\n const target = decideRenderMode({\n requested: mode,\n defaultMode: this._options.defaultRenderMode,\n featureCount: record.info.featureCount,\n byteSize: record.info.byteSize,\n threshold: this._options.autoThreshold,\n });\n if (target === record.info.renderMode) return;\n\n this._emit('loading', { message: `Switching ${record.info.name} to ${target}...` });\n\n try {\n this._detachPicker(record);\n removeLayersAndSource(this._map, record.info.layerIds, record.info.sourceId);\n if (record.providerKey) unregisterTileProvider(record.providerKey);\n record.info.layerIds = [];\n\n if (target === 'tiles') {\n await this._presentTiles(record);\n } else {\n await this._presentGeoJSON(record);\n }\n } catch (err) {\n const error = err instanceof Error ? err : new Error(String(err));\n this._emit('error', { error });\n throw error;\n }\n\n this._emit('layerupdated', { layer: { ...record.info } });\n }\n\n /**\n * Re-fetches a URL-backed layer's data and re-renders it in place,\n * preserving the layer id, source id, style, render mode, and stacking\n * position. File and in-memory GeoJSON sources are static between loads,\n * so for those the current info is returned unchanged.\n *\n * @param id - The layer id\n * @returns The refreshed layer info, or undefined when no such layer exists\n */\n async reloadLayer(id: string): Promise {\n const record = this._records.get(id);\n if (!record) return undefined;\n // Only URL sources can change between loads; files/objects are static.\n if (typeof record.source !== 'string' && !record.remoteUrl) return { ...record.info };\n\n this._emit('loading', { message: `Refreshing ${record.info.name}...` });\n\n try {\n if (record.remoteUrl && this._options.urlLoader) {\n const loaded = await this._options.urlLoader(record.remoteUrl);\n if (loaded) {\n record.source =\n typeof File !== 'undefined' && loaded instanceof File\n ? loaded\n : new File([loaded], this._defaultFileName(record), { type: loaded.type });\n this._materializedUrls.set(record.source as object, record.remoteUrl);\n } else {\n record.source = record.remoteUrl;\n record.remoteUrl = undefined;\n }\n }\n // Tear down the current presentation (mirrors setRenderMode).\n this._detachPicker(record);\n removeLayersAndSource(this._map, record.info.layerIds, record.info.sourceId);\n if (record.providerKey) {\n unregisterTileProvider(record.providerKey);\n record.providerKey = undefined;\n }\n record.info.layerIds = [];\n\n // Drop the stale engine table so the next ingest re-reads the source.\n if (record.tableName) {\n const tableName = record.tableName;\n record.tableName = undefined;\n const engine = await this._getEngine();\n await engine.dropTable(tableName).catch(() => {\n // Table already gone; nothing to clean up.\n });\n }\n\n // Re-run the load pipeline, preserving the resolved render mode so a\n // refresh does not flip a tiles layer to geojson (or vice versa).\n const reloadOptions: VectorLayerOptions = {\n renderMode: record.info.renderMode,\n ingestMode: record.info.ingestMode,\n sourceLayer: record.sourceLayer,\n sourceCrs: record.info.sourceCrs,\n };\n if (record.info.format === 'geojson' && record.info.renderMode !== 'tiles') {\n await this._addGeoJSON(record, reloadOptions);\n } else {\n await this._addViaEngine(record, reloadOptions);\n }\n } catch (err) {\n const error = err instanceof Error ? err : new Error(String(err));\n this._emit('error', { error });\n throw error;\n }\n\n this._emit('layerupdated', { layer: { ...record.info } });\n return { ...record.info };\n }\n\n /**\n * Removes all layers and map resources without emitting events.\n * Called when the control is removed from the map.\n */\n dispose(): void {\n for (const record of this._records.values()) {\n this._detachPicker(record);\n removeLayersAndSource(this._map, record.info.layerIds, record.info.sourceId);\n if (record.providerKey) unregisterTileProvider(record.providerKey);\n }\n this._records.clear();\n // A picker still on screen belongs to the map container, which outlives\n // the control; close it so no modal is left over the map.\n for (const picker of this._openPickers) picker.close();\n this._openPickers.clear();\n this._popup?.remove();\n this._popup = undefined;\n if (this._tileStatusTimer) {\n clearTimeout(this._tileStatusTimer);\n this._tileStatusTimer = undefined;\n }\n }\n\n /**\n * Expands a multi-layer container into one vector layer per selected\n * source layer, when the source is engine-readable, no sourceLayer was\n * requested, and the container reports more than one layer.\n *\n * Which layers those are comes from {@link VectorLayerOptions.sourceLayers}\n * when the caller named them, otherwise from the layer selector (the\n * built-in picker unless the host replaced or disabled it), otherwise all\n * of them.\n *\n * @returns The first created layer's info, or null when the source\n * is single-layer (callers continue with the normal flow)\n * @throws VectorLayerSelectionCancelledError when the user dismissed the\n * picker without choosing a layer.\n */\n private async _maybeExpandLayers(\n source: VectorDataSource,\n options: VectorLayerOptions,\n detected: { format: VectorLayerInfo['format']; name: string },\n id: string,\n ): Promise {\n // Single-layer by construction: native readers and the pure-JS\n // GeoJSON path. Explicit sourceLayer means the caller chose.\n const singleLayerFormats = ['geojson', 'geoparquet', 'csv'];\n if (options.sourceLayer || singleLayerFormats.includes(detected.format)) return null;\n\n const engine = await this._getEngine();\n const engineSource = await this._engineSource(source);\n const layerNames = await engine.listLayers(engineSource, tableNameFor(id), {\n format: detected.format,\n fileName:\n typeof File !== 'undefined' && source instanceof File ? source.name : undefined,\n // A loose shapefile must register its sidecars on this first probe too:\n // the engine caches the registration by source, so a companion-less\n // probe would leave the cached `.shp` unreadable for the later ingest.\n companionFiles: options.companionFiles,\n });\n if (layerNames.length <= 1) return null;\n\n const sourceName = options.name ?? detected.name;\n const selected = await this._selectContainerLayers(layerNames, options, detected, sourceName);\n\n this._emit('loading', {\n message:\n selected.length === 1\n ? `Loading 1 layer from ${sourceName}...`\n : `Loading ${selected.length} layers from ${sourceName}...`,\n });\n\n const infos: VectorLayerInfo[] = [];\n // The container-level selection is already resolved, so it is dropped from\n // the per-layer options; each sub-load names its single `sourceLayer`.\n const layerOptions: VectorLayerOptions = { ...options };\n delete layerOptions.sourceLayers;\n for (const layerName of selected) {\n const subId = `${id}-${layerName.replace(/[^a-zA-Z0-9_-]/g, '_')}`;\n infos.push(\n await this.addData(source, {\n ...layerOptions,\n id: subId,\n name: layerName,\n sourceLayer: layerName,\n fitBounds: false,\n }),\n );\n }\n\n // Zoom once to the combined extent of all created layers.\n if (options.fitBounds ?? true) {\n const boxes = infos.map((info) => info.bbox).filter(Boolean) as Array<\n [number, number, number, number]\n >;\n if (boxes.length > 0) {\n this._fitBounds([\n Math.min(...boxes.map((b) => b[0])),\n Math.min(...boxes.map((b) => b[1])),\n Math.max(...boxes.map((b) => b[2])),\n Math.max(...boxes.map((b) => b[3])),\n ]);\n }\n }\n\n return infos[0];\n }\n\n /**\n * Resolves which layers of a multi-layer container to load.\n *\n * An explicit `sourceLayers` list wins; otherwise the layer selector runs\n * (the built-in modal picker unless the host replaced it, or `false`\n * disabled prompting); otherwise every layer is loaded. Whatever the source,\n * the result is intersected with the container's real layers and ordered by\n * the container, so a selector cannot invent a layer or reorder the load.\n *\n * @throws VectorLayerSelectionCancelledError when the selector returned an\n * empty selection (the user dismissed the picker).\n */\n private async _selectContainerLayers(\n layerNames: string[],\n options: VectorLayerOptions,\n detected: { format: VectorLayerInfo['format'] },\n sourceName: string,\n ): Promise {\n const inContainerOrder = (names: readonly string[]): string[] => {\n const wanted = new Set(names.map((name) => name.toLowerCase()));\n return layerNames.filter((name) => wanted.has(name.toLowerCase()));\n };\n\n if (options.sourceLayers) {\n const requested = inContainerOrder(options.sourceLayers);\n if (requested.length === 0) {\n throw new Error(\n `None of the requested layers (${options.sourceLayers.join(', ')}) exist in ` +\n `${sourceName}. Available layers: ${layerNames.join(', ')}.`,\n );\n }\n return requested;\n }\n\n const selector = this._layerSelector();\n if (!selector) return layerNames;\n\n const chosen = await selector(layerNames, { sourceName, format: detected.format });\n // null/undefined means \"no opinion\": keep the load-everything default so a\n // host selector that only handles some formats can defer on the rest.\n if (chosen == null) return layerNames;\n const selected = inContainerOrder(chosen);\n if (selected.length === 0) {\n throw new VectorLayerSelectionCancelledError(\n `No layers were selected from ${sourceName}.`,\n );\n }\n return selected;\n }\n\n /**\n * The layer selector in force: the host's when it supplied one, none when it\n * set `selectLayers: false` (load every layer), else the built-in modal\n * picker rendered over the map container.\n */\n private _layerSelector(): VectorLayerSelector | null {\n const configured = this._options.selectLayers;\n if (configured === false) return null;\n if (configured) return configured;\n return (layers, context) => {\n const container = this._map.getContainer?.();\n // No container to render into (a headless/mock map): fall back to\n // loading every layer rather than blocking on a modal nobody can see.\n if (!container) return null;\n const picker = openLayerPicker({ container, layers, sourceName: context.sourceName });\n this._openPickers.add(picker);\n return picker.selection.finally(() => this._openPickers.delete(picker));\n };\n }\n\n /**\n * Loads a GeoJSON source entirely in JavaScript (no DuckDB), falling\n * back to the engine when auto mode trips the size thresholds.\n *\n * @param prefetched - A collection already fetched by the URL GeoJSON\n * sniff, reused so an extensionless GeoJSON endpoint is not requested\n * twice.\n */\n private async _addGeoJSON(\n record: LayerRecord,\n options: VectorLayerOptions,\n prefetched?: { collection: FeatureCollection; byteSize?: number },\n ): Promise {\n const resolved = prefetched ?? (await this._resolveGeoJSON(record.source));\n const { byteSize } = resolved;\n let collection = resolved.collection;\n const summary = summarizeFeatureCollection(collection);\n\n record.info.featureCount = summary.featureCount;\n record.info.byteSize = byteSize;\n record.info.bbox = summary.bbox;\n record.info.geometryType = summary.geometryType;\n record.info.fields = collectFieldNames(collection);\n\n const mode = decideRenderMode({\n requested: options.renderMode,\n defaultMode: this._options.defaultRenderMode,\n featureCount: summary.featureCount,\n byteSize,\n threshold: this._options.autoThreshold,\n });\n\n if (mode === 'tiles') {\n // The tile path re-reads the original source through the DuckDB engine,\n // which reprojects to WGS84 from the source metadata as part of ingest, so\n // a projected collection is handled there without the in-memory reproject\n // below (and its metres bbox above is replaced by the engine's).\n await this._presentTiles(record);\n return;\n }\n\n // A projected GeoJSON declares its CRS via a legacy `crs` member and carries\n // raw projected coordinates (metres) that MapLibre cannot render, so spin up\n // the DuckDB engine (only in this case, keeping the WGS84 fast path\n // engine-free) and reproject to EPSG:4326 before rendering. Without this the\n // raw coordinates trip MapLibre's \"Invalid LngLat\" guard in the fitBounds\n // that follows, and the panel is left stuck loading.\n const sourceCrs = crsFromGeoJSON(collection);\n if (sourceCrs) {\n this._emit('loading', { message: `Reprojecting ${record.info.name} to WGS84...` });\n const engine = await this._getEngine();\n collection = await engine.reprojectGeoJSON(collection, sourceCrs);\n const reprojectedSummary = summarizeFeatureCollection(collection);\n // Replace the projected-metres bbox with the WGS84 extent so the caller's\n // fitBounds receives valid lon/lat.\n record.info.bbox = reprojectedSummary.bbox;\n }\n\n record.info.renderMode = 'geojson';\n // Only point layers use the cached collection (for a pointMode rebuild), so\n // don't pin a full copy of polygon/line data in the JS heap.\n record.geojson = summary.geometryType === 'point' ? collection : undefined;\n addGeoJSONSource(\n this._map,\n record.info.id,\n collection,\n this._options.attribution,\n clusterOptionsFor(summary.geometryType, record.info.style),\n );\n const kmlIconImage = await prepareKmzIcons(this._map, collection);\n record.info.layerIds = addGeometryLayers(this._map, {\n layerId: record.info.id,\n geometryType: summary.geometryType,\n style: record.info.style,\n visible: record.info.visible,\n opacity: record.info.opacity,\n beforeId: record.info.beforeId,\n kmlIconImage,\n });\n this._attachPicker(record);\n }\n\n /**\n * Loads a source through the DuckDB engine and presents it as GeoJSON\n * or dynamic tiles based on the resolved render mode.\n */\n private async _addViaEngine(record: LayerRecord, options: VectorLayerOptions): Promise {\n const summary = await this._ingest(record);\n\n record.info.featureCount = summary.featureCount;\n record.info.byteSize = summary.byteSize ?? record.info.byteSize;\n record.info.bbox = summary.bbox;\n record.info.geometryType = summary.geometryType;\n\n const mode = decideRenderMode({\n requested: options.renderMode,\n defaultMode: this._options.defaultRenderMode,\n featureCount: summary.featureCount,\n byteSize: record.info.byteSize,\n threshold: this._options.autoThreshold,\n });\n\n if (mode === 'tiles') {\n await this._presentTiles(record);\n } else {\n await this._presentGeoJSON(record);\n }\n }\n\n /**\n * Ingests the record's source into the engine, reusing an existing\n * table when present.\n */\n private async _ingest(record: LayerRecord) {\n const engine = await this._getEngine();\n const tableName = tableNameFor(record.info.id);\n const source = await this._engineSource(record.source);\n this._emit('loading', {\n message:\n record.info.ingestMode === 'stream'\n ? `Opening ${record.info.name} (streaming, reading metadata)...`\n : `Reading ${record.info.name} into DuckDB...`,\n });\n const summary = await engine.ingest(source, tableName, {\n format: record.info.format,\n sourceLayer: record.sourceLayer,\n sourceCrs: record.info.sourceCrs,\n fileName: record.fileName ?? this._defaultFileName(record),\n mode: record.info.ingestMode,\n companionFiles: record.companionFiles,\n });\n record.tableName = summary.tableName;\n record.info.fields = summary.fields;\n // The engine falls back to a table for formats streaming\n // does not apply to.\n record.info.ingestMode = summary.streamed ? 'stream' : 'table';\n return summary;\n }\n\n /**\n * Presents a record as a dynamic tile layer, ingesting it first when\n * needed.\n */\n private async _presentTiles(record: LayerRecord): Promise {\n const engine = await this._getEngine();\n if (!record.tableName) {\n const summary = await this._ingest(record);\n record.info.featureCount = summary.featureCount;\n record.info.bbox = summary.bbox ?? record.info.bbox;\n record.info.geometryType =\n summary.geometryType !== 'unknown' ? summary.geometryType : record.info.geometryType;\n }\n const tableName = record.tableName!;\n if (record.info.ingestMode !== 'stream') {\n this._emit('loading', {\n message: `Indexing ${record.info.name} for tiles (reprojecting + R-Tree)...`,\n });\n }\n await engine.prepareTiles(tableName);\n\n const id = record.info.id;\n // The provider registry is process-wide; key it by a generated\n // unique value so equal layer ids on two controls cannot collide.\n const providerKey = record.providerKey ?? generateId(`${id}-tiles`);\n record.providerKey = providerKey;\n await registerTileProvider(providerKey, (z, x, y, signal) =>\n this._trackTileActivity(engine.getTile(tableName, id, z, x, y, signal)),\n );\n\n record.info.renderMode = 'tiles';\n // Tiles never rebuild from a cached collection; drop any copy from a prior\n // geojson render so it isn't pinned in the heap.\n record.geojson = undefined;\n addVectorTileSource(this._map, id, {\n tileUrl: tileUrlFor(providerKey),\n maxzoom: this._options.maxTileZoom ?? DEFAULT_MAX_TILE_ZOOM,\n bounds: record.info.bbox,\n attribution: this._options.attribution,\n });\n record.info.layerIds = addGeometryLayers(this._map, {\n layerId: id,\n geometryType: record.info.geometryType,\n style: record.info.style,\n visible: record.info.visible,\n opacity: record.info.opacity,\n sourceLayer: id,\n beforeId: record.info.beforeId,\n });\n this._attachPicker(record);\n }\n\n /**\n * Presents a record as a GeoJSON layer, exporting from the engine when\n * the source was ingested, or re-parsing the original source.\n */\n private async _presentGeoJSON(record: LayerRecord): Promise {\n let collection: FeatureCollection;\n if (record.tableName) {\n const engine = await this._getEngine();\n this._emit('loading', { message: `Converting ${record.info.name} to GeoJSON...` });\n collection = await engine.exportGeoJSON(record.tableName);\n collection = await enhanceKmzGeoJSON(\n record.source,\n collection,\n record.fileName ??\n (record.info.source.kind === 'file' ? record.info.source.fileName : undefined),\n );\n } else {\n collection = (await this._resolveGeoJSON(record.source)).collection;\n }\n\n if (record.info.geometryType === 'unknown') {\n record.info.geometryType = summarizeFeatureCollection(collection).geometryType;\n }\n record.info.fields = collectFieldNames(collection);\n\n record.info.renderMode = 'geojson';\n // Only point layers use the cached collection (for a pointMode rebuild).\n record.geojson = record.info.geometryType === 'point' ? collection : undefined;\n addGeoJSONSource(\n this._map,\n record.info.id,\n collection,\n this._options.attribution,\n clusterOptionsFor(record.info.geometryType, record.info.style),\n );\n const kmlIconImage = await prepareKmzIcons(this._map, collection);\n record.info.layerIds = addGeometryLayers(this._map, {\n layerId: record.info.id,\n geometryType: record.info.geometryType,\n style: record.info.style,\n visible: record.info.visible,\n opacity: record.info.opacity,\n beforeId: record.info.beforeId,\n kmlIconImage,\n });\n this._attachPicker(record);\n }\n\n /**\n * Resolves a data source to a FeatureCollection without DuckDB.\n */\n private async _resolveGeoJSON(\n source: VectorDataSource,\n ): Promise<{ collection: FeatureCollection; byteSize?: number }> {\n if (typeof source === 'string') {\n const response = await fetch(source);\n if (!response.ok) {\n throw new Error(`Failed to fetch ${source}: ${response.status} ${response.statusText}`);\n }\n const text = await response.text();\n return { collection: toFeatureCollection(JSON.parse(text)), byteSize: text.length };\n }\n\n if (typeof Blob !== 'undefined' && source instanceof Blob) {\n const text = await source.text();\n return { collection: toFeatureCollection(JSON.parse(text)), byteSize: source.size };\n }\n\n return { collection: toFeatureCollection(source as Exclude) };\n }\n\n /**\n * Converts a data source to something the engine can register\n * (GeoJSON objects and data: URLs become Blobs - DuckDB/GDAL cannot\n * fetch data: URLs).\n */\n private async _engineSource(source: VectorDataSource): Promise {\n if (typeof source === 'string') {\n if (source.startsWith('data:')) {\n return (await fetch(source)).blob();\n }\n return source;\n }\n if (typeof Blob !== 'undefined' && source instanceof Blob) return source;\n return new Blob([JSON.stringify(source)], { type: 'application/geo+json' });\n }\n\n /**\n * Picks a registration file name for sources without one, using an\n * extension matching the format so readers can sniff the type.\n */\n private _defaultFileName(record: LayerRecord): string {\n const extensions: Record = {\n geojson: 'geojson',\n geoparquet: 'parquet',\n geopackage: 'gpkg',\n shapefile: 'zip',\n flatgeobuf: 'fgb',\n csv: 'csv',\n };\n const format = record.info.format;\n const ext = extensions[format] ?? (format !== 'unknown' ? format : 'bin');\n return `${tableNameFor(record.info.id)}.${ext}`;\n }\n\n /**\n * Attaches click-to-inspect handlers to a layer's map layers,\n * opening a popup with the clicked feature's attributes.\n */\n private _attachPicker(record: LayerRecord): void {\n if (!record.info.picker) return;\n record.pickerHandlers = record.info.layerIds.map((layerId) => {\n const click = (e: MapLayerMouseEvent) => {\n const feature = e.features?.[0];\n if (feature) {\n void this._showPopup(record.info, e.lngLat, feature.properties ?? {});\n }\n };\n const enter = () => {\n this._map.getCanvas().style.cursor = 'pointer';\n };\n const leave = () => {\n this._map.getCanvas().style.cursor = '';\n };\n this._map.on('click', layerId, click);\n this._map.on('mouseenter', layerId, enter);\n this._map.on('mouseleave', layerId, leave);\n return { layerId, click, enter, leave };\n });\n }\n\n /**\n * Removes the picker handlers of a layer.\n */\n private _detachPicker(record: LayerRecord): void {\n for (const handler of record.pickerHandlers ?? []) {\n this._map.off('click', handler.layerId, handler.click);\n this._map.off('mouseenter', handler.layerId, handler.enter);\n this._map.off('mouseleave', handler.layerId, handler.leave);\n }\n record.pickerHandlers = undefined;\n // Close a popup owned by this layer so stale attributes do not\n // linger after removal or a render-mode switch.\n if (this._popupOwnerId === record.info.id) {\n this._popup?.remove();\n this._popup = undefined;\n this._popupOwnerId = undefined;\n }\n }\n\n /** Opens (or replaces) the attribute popup for a clicked feature. */\n private async _showPopup(\n info: Pick,\n lngLat: { lng: number; lat: number },\n properties: Record,\n ): Promise {\n const container = document.createElement('div');\n container.className = 'vector-control-popup';\n\n const title = document.createElement('div');\n title.className = 'vector-control-popup-title';\n title.textContent = info.name;\n container.appendChild(title);\n\n const entries = Object.entries(properties).filter(([key]) => !key.startsWith('__geolibre_'));\n if (entries.length === 0) {\n const empty = document.createElement('div');\n empty.className = 'vector-control-popup-empty';\n empty.textContent = 'No attributes';\n container.appendChild(empty);\n } else {\n const table = document.createElement('table');\n table.className = 'vector-control-popup-table';\n for (const [key, value] of entries) {\n const row = table.insertRow();\n const keyCell = row.insertCell();\n keyCell.className = 'vector-control-popup-key';\n keyCell.textContent = key;\n const valueCell = row.insertCell();\n if (\n key.toLowerCase() === 'description' &&\n typeof value === 'string' &&\n /<[^>]+>/.test(value)\n ) {\n const parsed = new DOMParser().parseFromString(value, 'text/html');\n const allowed = new Set([\n 'a',\n 'b',\n 'br',\n 'div',\n 'em',\n 'i',\n 'p',\n 'span',\n 'strong',\n 'table',\n 'tbody',\n 'td',\n 'th',\n 'thead',\n 'tr',\n ]);\n const copy = (node: Node, parent: Node): void => {\n if (node.nodeType === Node.TEXT_NODE) {\n parent.appendChild(document.createTextNode(node.textContent ?? ''));\n return;\n }\n if (!(node instanceof Element)) return;\n const tag = node.localName.toLowerCase();\n if (tag === 'script' || tag === 'style' || tag === 'head' || tag === 'meta') return;\n if (!allowed.has(tag)) {\n for (const childNode of node.childNodes) copy(childNode, parent);\n return;\n }\n const element = document.createElement(tag);\n if (tag === 'a') {\n const href = node.getAttribute('href')?.trim();\n if (href && /^(https?:|mailto:)/i.test(href)) {\n element.setAttribute('href', href);\n element.setAttribute('target', '_blank');\n element.setAttribute('rel', 'noopener noreferrer');\n }\n }\n for (const childNode of node.childNodes) copy(childNode, element);\n parent.appendChild(element);\n };\n for (const childNode of parsed.body.childNodes) copy(childNode, valueCell);\n } else {\n valueCell.textContent = value === null || value === undefined ? '' : String(value);\n }\n }\n container.appendChild(table);\n }\n\n const maplibre = await getMaplibre();\n this._popup?.remove();\n const popup = new maplibre.Popup({ closeButton: true, maxWidth: '520px' });\n popup.setLngLat([lngLat.lng, lngLat.lat]);\n popup.setDOMContent(container);\n popup.addTo(this._map);\n this._popup = popup;\n this._popupOwnerId = info.id;\n }\n\n /**\n * Surfaces tile generation progress through 'loading' events: shows\n * a pending count while tile queries run and clears the status\n * shortly after the queue drains (the delay avoids flicker between\n * consecutive tiles).\n */\n private _trackTileActivity(task: Promise): Promise {\n this._pendingTiles += 1;\n if (this._tileStatusTimer) {\n clearTimeout(this._tileStatusTimer);\n this._tileStatusTimer = undefined;\n }\n this._emit('loading', { message: `Generating tiles (${this._pendingTiles} pending)...` });\n\n const settle = () => {\n this._pendingTiles -= 1;\n if (this._pendingTiles === 0) {\n this._tileStatusTimer = setTimeout(() => {\n this._tileStatusTimer = undefined;\n this._emit('loading', { message: '' });\n }, 400);\n } else {\n this._emit('loading', { message: `Generating tiles (${this._pendingTiles} pending)...` });\n }\n };\n\n return task.then(\n (value) => {\n settle();\n return value;\n },\n (err) => {\n settle();\n throw err;\n },\n );\n }\n\n private _fitBounds(bbox: [number, number, number, number]): void {\n fitMapToBbox(this._map, bbox, { padding: 40, duration: 600, maxZoom: 16 });\n }\n}\n","import type { VectorFormat } from '../core/types';\n\n/**\n * Maximum number of features encoded into a single tile.\n */\nexport const TILE_FEATURE_LIMIT = 50_000;\n\n/**\n * Quotes a SQL identifier.\n *\n * @param name - Identifier to quote\n * @returns The double-quoted identifier\n */\nexport function quoteIdent(name: string): string {\n return `\"${name.replace(/\"/g, '\"\"')}\"`;\n}\n\n/**\n * Quotes a SQL string literal.\n *\n * @param value - String value to quote\n * @returns The single-quoted literal\n */\nexport function quoteLiteral(value: string): string {\n return `'${value.replace(/'/g, \"''\")}'`;\n}\n\n/**\n * Builds the reader expression for a registered file or URL.\n *\n * GeoParquet and CSV use DuckDB's native readers; everything else goes\n * through the spatial extension's ST_Read (GDAL).\n *\n * @param format - The source format\n * @param path - Registered file name or URL\n * @param sourceLayer - Optional layer inside multi-layer containers\n * @returns The FROM-clause reader expression\n */\nexport function readerFor(format: VectorFormat, path: string, sourceLayer?: string): string {\n switch (format) {\n case 'geoparquet':\n return `read_parquet(${quoteLiteral(path)})`;\n case 'csv':\n return `read_csv(${quoteLiteral(path)})`;\n default: {\n const layerArg = sourceLayer ? `, layer = ${quoteLiteral(sourceLayer)}` : '';\n return `ST_Read(${quoteLiteral(path)}${layerArg})`;\n }\n }\n}\n\n/**\n * Builds the GDAL virtual path for a source, wrapping zip archives in\n * /vsizip/ so zipped shapefiles can be read directly.\n *\n * @param format - The source format\n * @param path - Registered file name or URL\n * @returns The path to hand to ST_Read\n */\nexport function gdalPath(format: VectorFormat, path: string): string {\n if (format === 'shapefile' && /\\.zip$/i.test(path.split(/[?#]/)[0])) {\n const prefix = /^https?:\\/\\//i.test(path) ? '/vsizip//vsicurl/' : '/vsizip/';\n return `${prefix}${path}`;\n }\n return path;\n}\n\n/**\n * SQL describing the columns a relation produces (name and type),\n * without materializing it.\n *\n * @param relation - A quoted table name or reader expression\n * @returns The query text\n */\nexport function columnsQueryFromDescribe(relation: string): string {\n return `DESCRIBE SELECT * FROM ${relation}`;\n}\n\nexport type GeometryEncoding = 'geometry' | 'wkb' | 'base64-wkb';\n\nexport interface ReaderColumnInfo {\n name: string;\n type: string;\n}\n\nexport interface DetectedGeometryColumn {\n name: string;\n encoding: GeometryEncoding;\n requiresBase64WkbValidation?: boolean;\n base64WkbCandidates?: string[];\n}\n\nconst WKB_GEOMETRY_COLUMN_NAMES = [\n 'geometry',\n 'geom',\n 'wkb_geometry',\n 'geometry_wkb',\n 'geom_wkb',\n 'wkb',\n];\n\nfunction wkbNameRank(name: string): number {\n const rank = WKB_GEOMETRY_COLUMN_NAMES.indexOf(name.toLowerCase());\n return rank === -1 ? Number.MAX_SAFE_INTEGER : rank;\n}\n\n/**\n * Finds the geometry column produced by a reader. Native DuckDB GEOMETRY\n * columns win; plain Parquet fallbacks may carry WKB as bytes or as a\n * base64-encoded string in a well-known geometry column. String candidates\n * must be value-probed before SQL generation because geometry-like names are\n * sometimes ordinary attributes.\n *\n * @param columns - Column names and types from DESCRIBE\n * @returns Detected geometry column, if one is recognizable\n */\nexport function detectGeometryColumn(\n columns: ReaderColumnInfo[],\n): DetectedGeometryColumn | undefined {\n const native = columns.find((column) => column.type.toUpperCase().startsWith('GEOMETRY'));\n if (native) return { name: native.name, encoding: 'geometry' };\n\n const sortedWkbCandidates = columns\n .filter((column) => wkbNameRank(column.name) !== Number.MAX_SAFE_INTEGER)\n .sort((a, b) => wkbNameRank(a.name) - wkbNameRank(b.name));\n const binaryWkb = sortedWkbCandidates.find((column) =>\n /^(BLOB|BINARY|VARBINARY)/i.test(column.type),\n );\n if (binaryWkb) return { name: binaryWkb.name, encoding: 'wkb' };\n\n const base64WkbCandidates = sortedWkbCandidates\n .filter((column) => /^(VARCHAR|TEXT|STRING)/i.test(column.type))\n .map((column) => column.name);\n if (base64WkbCandidates.length > 0) {\n return {\n name: base64WkbCandidates[0],\n encoding: 'base64-wkb',\n requiresBase64WkbValidation: true,\n base64WkbCandidates,\n };\n }\n return undefined;\n}\n\n/**\n * SQL creating the ingest table from a reader, normalizing the geometry\n * column to `geom`.\n *\n * @param tableName - The table to create\n * @param reader - Reader expression from {@link readerFor}\n * @param geometryColumn - Name of the source geometry column\n * @returns The statement text\n */\nexport function createTableSql(\n tableName: string,\n reader: string,\n geometryColumn: string,\n): string {\n const rename =\n geometryColumn === 'geom'\n ? ''\n : ` RENAME (${quoteIdent(geometryColumn)} AS geom)`;\n return `CREATE OR REPLACE TABLE ${quoteIdent(tableName)} AS SELECT *${rename} FROM ${reader}`;\n}\n\nfunction wkbGeometryExpression(geometry: DetectedGeometryColumn): string {\n if (geometry.requiresBase64WkbValidation) {\n throw new Error('Base64 WKB geometry candidates must be validated before SQL generation.');\n }\n const column = quoteIdent(geometry.name);\n const wkb = geometry.encoding === 'base64-wkb' ? `from_base64(${column})` : column;\n return `ST_GeomFromWKB(${wkb})`;\n}\n\n/**\n * Wraps a geometry expression in `ST_Transform` to WGS84 when a non-WGS84\n * `sourceCrs` was resolved, so the rest of the pipeline (tiles, export) can\n * assume EPSG:4326. Passes the expression through unchanged when `sourceCrs` is\n * null (already WGS84, or CRS unknown). `always_xy` keeps lon/lat axis order.\n *\n * @param geomExpr - The source geometry SQL expression\n * @param sourceCrs - `AUTHORITY:CODE` or a WKT string ST_Transform accepts, or null\n * @returns The (possibly reprojected) geometry expression\n */\nfunction reprojectToWgs84Sql(geomExpr: string, sourceCrs: string | null): string {\n return sourceCrs\n ? `ST_Transform(${geomExpr}, ${quoteLiteral(sourceCrs)}, 'EPSG:4326', always_xy := true)`\n : geomExpr;\n}\n\nfunction createRelationFromGeometrySql(\n relationKind: 'TABLE' | 'VIEW',\n tableName: string,\n reader: string,\n geometry: DetectedGeometryColumn,\n sourceCrs: string | null = null,\n): string {\n // A native GEOMETRY column that needs no reprojection keeps the cheap\n // `* RENAME` form (no per-row expression).\n if (geometry.encoding === 'geometry' && !sourceCrs) {\n return relationKind === 'TABLE'\n ? createTableSql(tableName, reader, geometry.name)\n : createViewSql(tableName, reader, geometry.name);\n }\n const rawGeom =\n geometry.encoding === 'geometry'\n ? quoteIdent(geometry.name)\n : wkbGeometryExpression(geometry);\n return (\n `CREATE OR REPLACE ${relationKind} ${quoteIdent(tableName)} AS ` +\n `SELECT * EXCLUDE (${quoteIdent(geometry.name)}), ` +\n `${reprojectToWgs84Sql(rawGeom, sourceCrs)} AS geom ` +\n `FROM ${reader}`\n );\n}\n\n/**\n * SQL creating the ingest table from a reader with a detected geometry column,\n * reprojecting to WGS84 when `sourceCrs` names a non-WGS84 CRS.\n *\n * @param tableName - The table to create\n * @param reader - Reader expression from {@link readerFor}\n * @param geometry - Detected geometry column and encoding\n * @param sourceCrs - Source CRS to reproject from (`AUTHORITY:CODE` or WKT), or\n * null to leave the geometry in its source coordinates\n * @returns The statement text\n */\nexport function createTableFromGeometrySql(\n tableName: string,\n reader: string,\n geometry: DetectedGeometryColumn,\n sourceCrs: string | null = null,\n): string {\n return createRelationFromGeometrySql('TABLE', tableName, reader, geometry, sourceCrs);\n}\n\n/**\n * SQL creating the ingest table from a CSV with a WKT geometry column.\n *\n * @param tableName - The table to create\n * @param reader - Reader expression\n * @param wktColumn - Name of the WKT column\n * @returns The statement text\n */\nexport function createTableFromWktSql(\n tableName: string,\n reader: string,\n wktColumn: string,\n sourceCrs: string | null = null,\n): string {\n const geom = reprojectToWgs84Sql(`ST_GeomFromText(${quoteIdent(wktColumn)})`, sourceCrs);\n return (\n `CREATE OR REPLACE TABLE ${quoteIdent(tableName)} AS ` +\n `SELECT * EXCLUDE (${quoteIdent(wktColumn)}), ` +\n `${geom} AS geom FROM ${reader}`\n );\n}\n\n/**\n * SQL creating the ingest table from a CSV with longitude/latitude\n * columns.\n *\n * @param tableName - The table to create\n * @param reader - Reader expression\n * @param lonColumn - Longitude column name\n * @param latColumn - Latitude column name\n * @returns The statement text\n */\nexport function createTableFromLonLatSql(\n tableName: string,\n reader: string,\n lonColumn: string,\n latColumn: string,\n sourceCrs: string | null = null,\n): string {\n const geom = reprojectToWgs84Sql(\n `ST_Point(${quoteIdent(lonColumn)}, ${quoteIdent(latColumn)})`,\n sourceCrs,\n );\n return (\n `CREATE OR REPLACE TABLE ${quoteIdent(tableName)} AS ` +\n `SELECT *, ${geom} AS geom ` +\n `FROM ${reader}`\n );\n}\n\n/**\n * SQL creating a streaming view over a reader instead of materializing\n * a table, normalizing the geometry column to `geom`. Used for\n * GeoParquet streaming ingest: queries hit the file in place (with\n * HTTP range reads for remote files).\n *\n * @param tableName - The view to create\n * @param reader - Reader expression from {@link readerFor}\n * @param geometryColumn - Name of the source geometry column\n * @returns The statement text\n */\nexport function createViewSql(\n tableName: string,\n reader: string,\n geometryColumn: string,\n): string {\n const rename =\n geometryColumn === 'geom' ? '' : ` RENAME (${quoteIdent(geometryColumn)} AS geom)`;\n return `CREATE OR REPLACE VIEW ${quoteIdent(tableName)} AS SELECT *${rename} FROM ${reader}`;\n}\n\n/**\n * SQL creating a streaming view from a reader with a detected geometry column.\n *\n * @param tableName - The view to create\n * @param reader - Reader expression from {@link readerFor}\n * @param geometry - Detected geometry column and encoding\n * @returns The statement text\n */\nexport function createViewFromGeometrySql(\n tableName: string,\n reader: string,\n geometry: DetectedGeometryColumn,\n sourceCrs: string | null = null,\n): string {\n return createRelationFromGeometrySql('VIEW', tableName, reader, geometry, sourceCrs);\n}\n\n/**\n * Recognizes a GeoParquet bbox covering column: a STRUCT with\n * xmin/ymin/xmax/ymax fields named `bbox` or ending in `_bbox`\n * (e.g. `geometry_bbox`, `geom_bbox`).\n *\n * @param name - Column name\n * @param type - Column type string from DESCRIBE\n * @returns True when the column is a bbox covering column\n */\nexport function isBboxCoveringColumn(name: string, type: string): boolean {\n const lower = name.toLowerCase();\n if (lower !== 'bbox' && !lower.endsWith('_bbox')) return false;\n const upper = type.toUpperCase();\n return (\n upper.startsWith('STRUCT') &&\n /\\bXMIN\\b/.test(upper) &&\n /\\bYMIN\\b/.test(upper) &&\n /\\bXMAX\\b/.test(upper) &&\n /\\bYMAX\\b/.test(upper)\n );\n}\n\n/**\n * SQL computing feature count and extent from a bbox covering column,\n * avoiding a full geometry scan on streamed sources.\n *\n * @param tableName - The table or view to summarize\n * @param bboxColumn - The bbox covering column name\n * @returns The query text\n */\nexport function bboxSummaryQuery(tableName: string, bboxColumn: string): string {\n const table = quoteIdent(tableName);\n const bbox = quoteIdent(bboxColumn);\n return (\n `SELECT count(*)::DOUBLE AS feature_count, ` +\n `min(${bbox}.xmin)::DOUBLE AS xmin, min(${bbox}.ymin)::DOUBLE AS ymin, ` +\n `max(${bbox}.xmax)::DOUBLE AS xmax, max(${bbox}.ymax)::DOUBLE AS ymax ` +\n `FROM ${table}`\n );\n}\n\n/**\n * SQL sampling the distinct geometry types of a table or view without\n * scanning every row (streamed sources can be large).\n *\n * @param tableName - The table or view to inspect\n * @param sampleSize - Number of rows to sample\n * @returns The query text\n */\nexport function sampledGeometryTypesQuery(tableName: string, sampleSize = 100): string {\n return (\n `SELECT DISTINCT CAST(ST_GeometryType(geom) AS VARCHAR) AS geometry_type ` +\n `FROM (SELECT geom FROM ${quoteIdent(tableName)} WHERE geom IS NOT NULL LIMIT ${sampleSize})`\n );\n}\n\n/**\n * SQL generating an MVT tile from a streamed (EPSG:4326) source.\n *\n * The geometry is transformed per tile; when a bbox covering column is\n * present its predicate is pushed into parquet row-group statistics so\n * only intersecting row groups are read.\n *\n * @param tableName - The streaming view\n * @param layerName - MVT layer name (matches the map source-layer)\n * @param z - Tile zoom\n * @param x - Tile column\n * @param y - Tile row\n * @param bbox4326 - Tile bounds in EPSG:4326 [west, south, east, north]\n * @param propertyColumns - Non-geometry columns to encode as properties\n * @param bboxColumn - Optional bbox covering column for pushdown\n * @returns The query text\n */\nexport function mvtTileStreamQuery(\n tableName: string,\n layerName: string,\n z: number,\n x: number,\n y: number,\n bbox4326: [number, number, number, number],\n propertyColumns: string[],\n bboxColumn?: string,\n): string {\n const table = quoteIdent(tableName);\n const [west, south, east, north] = bbox4326;\n const env3857 = `ST_TileEnvelope(${z}, ${x}, ${y})`;\n const env4326 = `ST_MakeEnvelope(${west}, ${south}, ${east}, ${north})`;\n const props = propertyColumns\n .map((c) => `${quoteLiteral(c)}: TRY_CAST(${quoteIdent(c)} AS VARCHAR)`)\n .join(', ');\n const geometry =\n `ST_AsMVTGeom(ST_Transform(geom, 'EPSG:4326', 'EPSG:3857', always_xy := true), ` +\n `ST_Extent(${env3857}))`;\n const struct = `{'geometry': ${geometry}${props ? `, ${props}` : ''}}`;\n const bboxFilter = bboxColumn\n ? `${quoteIdent(bboxColumn)}.xmin <= ${east} AND ${quoteIdent(bboxColumn)}.xmax >= ${west} ` +\n `AND ${quoteIdent(bboxColumn)}.ymin <= ${north} AND ${quoteIdent(bboxColumn)}.ymax >= ${south} AND `\n : '';\n return (\n `SELECT ST_AsMVT(${struct}, ${quoteLiteral(layerName)}) AS tile FROM (` +\n `SELECT * FROM ${table} ` +\n `WHERE ${bboxFilter}geom IS NOT NULL AND ST_Intersects(geom, ${env4326}) ` +\n `LIMIT ${TILE_FEATURE_LIMIT})`\n );\n}\n\n/**\n * SQL computing feature count and extent of a table.\n *\n * @param tableName - The table to summarize\n * @returns The query text\n */\nexport function summaryQuery(tableName: string): string {\n const table = quoteIdent(tableName);\n return (\n `SELECT count(*)::DOUBLE AS feature_count, ` +\n `ST_XMin(ST_Extent_Agg(geom)) AS xmin, ST_YMin(ST_Extent_Agg(geom)) AS ymin, ` +\n `ST_XMax(ST_Extent_Agg(geom)) AS xmax, ST_YMax(ST_Extent_Agg(geom)) AS ymax ` +\n `FROM ${table} WHERE geom IS NOT NULL`\n );\n}\n\n/**\n * SQL listing the distinct geometry types in a table.\n *\n * @param tableName - The table to inspect\n * @returns The query text\n */\nexport function geometryTypesQuery(tableName: string): string {\n return (\n `SELECT DISTINCT CAST(ST_GeometryType(geom) AS VARCHAR) AS geometry_type ` +\n `FROM ${quoteIdent(tableName)} WHERE geom IS NOT NULL LIMIT 10`\n );\n}\n\n/**\n * SQL exporting a table as GeoJSON geometry strings plus properties.\n *\n * @param tableName - The table to export\n * @param propertyColumns - Non-geometry columns to include\n * @returns The query text\n */\nexport function exportGeoJSONQuery(tableName: string, propertyColumns: string[]): string {\n const props = propertyColumns.map((c) => quoteIdent(c)).join(', ');\n const selectProps = props ? `, ${props}` : '';\n return (\n `SELECT ST_AsGeoJSON(geom) AS __geojson${selectProps} ` +\n `FROM ${quoteIdent(tableName)} WHERE geom IS NOT NULL`\n );\n}\n\n/**\n * SQL reading the non-null values of one attribute column.\n *\n * @param tableName - Source table\n * @param property - Attribute column\n * @returns The query text\n */\nexport function propertyValuesQuery(tableName: string, property: string): string {\n const column = quoteIdent(property);\n return `SELECT ${column} AS __value FROM ${quoteIdent(tableName)} WHERE ${column} IS NOT NULL`;\n}\n\n/**\n * SQL statements preparing a table for tile generation: a Web Mercator\n * geometry column and an R-Tree index.\n *\n * @param tableName - The table to prepare\n * @returns Statements to run in order; the index statement may fail on\n * builds without R-Tree support and should be guarded\n */\nexport function prepareTilesSql(tableName: string): { transform: string[]; index: string } {\n const table = quoteIdent(tableName);\n const indexName = quoteIdent(`idx_${tableName}_3857`);\n return {\n transform: [\n `ALTER TABLE ${table} ADD COLUMN IF NOT EXISTS geom_3857 GEOMETRY`,\n `UPDATE ${table} SET geom_3857 = ST_Transform(geom, 'EPSG:4326', 'EPSG:3857', always_xy := true)`,\n ],\n index: `CREATE INDEX IF NOT EXISTS ${indexName} ON ${table} USING RTREE (geom_3857)`,\n };\n}\n\n/**\n * SQL generating an MVT tile for a z/x/y request using ST_AsMVT.\n *\n * Properties are cast to VARCHAR for MVT encoding robustness.\n *\n * @param tableName - The prepared source table\n * @param layerName - MVT layer name (matches the map source-layer)\n * @param z - Tile zoom\n * @param x - Tile column\n * @param y - Tile row\n * @param propertyColumns - Non-geometry columns to encode as properties\n * @returns The query text\n */\nexport function mvtTileQuery(\n tableName: string,\n layerName: string,\n z: number,\n x: number,\n y: number,\n propertyColumns: string[],\n): string {\n const table = quoteIdent(tableName);\n const env = `ST_TileEnvelope(${z}, ${x}, ${y})`;\n const props = propertyColumns\n .map((c) => `${quoteLiteral(c)}: TRY_CAST(${quoteIdent(c)} AS VARCHAR)`)\n .join(', ');\n const struct = `{'geometry': ST_AsMVTGeom(geom_3857, ST_Extent(${env}))${props ? `, ${props}` : ''}}`;\n return (\n `SELECT ST_AsMVT(${struct}, ${quoteLiteral(layerName)}) AS tile FROM (` +\n `SELECT * FROM ${table} ` +\n `WHERE geom_3857 IS NOT NULL AND ST_Intersects(geom_3857, ${env}) ` +\n `LIMIT ${TILE_FEATURE_LIMIT})`\n );\n}\n\n/**\n * SQL selecting tile-intersecting features as GeoJSON for the JS MVT\n * fallback encoder (used when ST_AsMVT is unavailable).\n *\n * @param tableName - The source table\n * @param bbox - Tile bounds in EPSG:4326 [west, south, east, north]\n * @param propertyColumns - Non-geometry columns to include\n * @returns The query text\n */\nexport function tileFeaturesQuery(\n tableName: string,\n bbox: [number, number, number, number],\n propertyColumns: string[],\n): string {\n const table = quoteIdent(tableName);\n const envelope = `ST_MakeEnvelope(${bbox[0]}, ${bbox[1]}, ${bbox[2]}, ${bbox[3]})`;\n const props = propertyColumns.map((c) => quoteIdent(c)).join(', ');\n const selectProps = props ? `, ${props}` : '';\n return (\n `SELECT ST_AsGeoJSON(geom) AS __geojson${selectProps} FROM ${table} ` +\n `WHERE geom IS NOT NULL AND ST_Intersects(geom, ${envelope}) ` +\n `LIMIT ${TILE_FEATURE_LIMIT}`\n );\n}\n\n/**\n * SQL listing the named layers inside a multi-layer container\n * (GeoPackage tables, KML folders, ...) via ST_Read_Meta.\n *\n * @param path - Registered file name or URL\n * @returns The query text\n */\nexport function layersMetaQuery(path: string): string {\n return (\n `SELECT layer.name AS name FROM ` +\n `(SELECT unnest(layers) AS layer FROM ST_Read_Meta(${quoteLiteral(path)}))`\n );\n}\n\n/**\n * An `ST_Read` reader that keeps geometry as raw WKB (a `wkb_geometry` BLOB)\n * instead of decoding it into DuckDB's GEOMETRY type. Used as a fallback for\n * surface geometries (TIN / PolyhedralSurface) whose WKB DuckDB Spatial cannot\n * parse, so the raw bytes can be decoded in JS instead.\n *\n * @param path - Registered file name or URL\n * @param sourceLayer - Optional OGR layer name for a multi-layer source\n * @returns The reader expression\n */\nexport function keepWkbReaderFor(path: string, sourceLayer?: string): string {\n const layerArg = sourceLayer ? `, layer = ${quoteLiteral(sourceLayer)}` : '';\n return `ST_Read(${quoteLiteral(path)}${layerArg}, keep_wkb = true)`;\n}\n\n/**\n * SQL reading the first layer's first geometry field CRS from `ST_Read_Meta`,\n * used to reproject a surface-geometry fallback layer to WGS84. `wkt` is the\n * fallback when GDAL could not resolve an EPSG code (e.g. a custom ESRI `.prj`);\n * `ST_Transform` accepts a WKT string source just as it does `AUTHORITY:CODE`.\n *\n * @param path - Registered file name or URL\n * @returns The query text\n */\nexport function sourceCrsMetaQuery(path: string): string {\n return (\n `SELECT ` +\n `layers[1].geometry_fields[1].crs.auth_name AS auth_name, ` +\n `layers[1].geometry_fields[1].crs.auth_code AS auth_code, ` +\n `layers[1].geometry_fields[1].crs.wkt AS wkt ` +\n `FROM ST_Read_Meta(${quoteLiteral(path)})`\n );\n}\n\n/**\n * The Parquet file-metadata key the GeoParquet specification writes its column\n * metadata (including the CRS) to.\n */\nexport const GEOPARQUET_METADATA_KEY = 'geo';\n\n/** The column {@link geoParquetCrsQuery} returns the metadata document in. */\nexport const GEOPARQUET_METADATA_COLUMN = 'geo_metadata';\n\n/**\n * SQL reading a Parquet file's `geo` metadata document as text, the only place\n * a GeoParquet source declares its CRS (`read_parquet` reports nothing about it\n * the way `ST_Read_Meta` does for the GDAL formats). Returns no rows for a\n * plain, non-spatial Parquet.\n *\n * The key is matched as a BLOB via `encode` rather than by decoding every key,\n * so a file carrying a non-UTF-8 metadata key cannot fail the whole read; only\n * the matched row's value is decoded.\n *\n * @param path - Registered file name or URL\n * @returns The query text\n */\nexport function geoParquetCrsQuery(path: string): string {\n return (\n `SELECT decode(value) AS ${GEOPARQUET_METADATA_COLUMN} ` +\n `FROM parquet_kv_metadata(${quoteLiteral(path)}) ` +\n `WHERE key = encode(${quoteLiteral(GEOPARQUET_METADATA_KEY)})`\n );\n}\n\n/**\n * SQL probing whether the loaded spatial build supports ST_AsMVT.\n *\n * @returns The probe query text\n */\nexport function mvtProbeQuery(): string {\n return (\n `SELECT ST_AsMVT({'geometry': ST_AsMVTGeom(ST_Point(0, 0), ` +\n `ST_Extent(ST_TileEnvelope(0, 0, 0)))}, 'probe') AS tile`\n );\n}\n\n/**\n * Column names recognized as WKT geometry in CSV files.\n */\nexport const WKT_COLUMN_NAMES = ['geometry', 'wkt', 'geom', 'the_geom', 'wkb_geometry'];\n\n/**\n * Column name pairs recognized as longitude/latitude in CSV files.\n */\nexport const LON_LAT_COLUMN_PAIRS: Array<[string, string]> = [\n ['longitude', 'latitude'],\n ['lon', 'lat'],\n ['lng', 'lat'],\n ['x', 'y'],\n];\n","import { mvtProbeQuery } from './sql';\n\n/**\n * Pinned duckdb-wasm version.\n *\n * IMPORTANT: a higher duckdb-wasm version does NOT guarantee a newer\n * DuckDB core. v1.31.0 ships DuckDB core 1.4.0, which is the first core\n * with ST_AsMVT/ST_AsMVTGeom; some later wasm releases regressed to\n * core 1.3.x. Verify with the runtime probe before changing this pin.\n */\nexport const DUCKDB_WASM_VERSION = '1.31.0';\n\n/**\n * jsDelivr base URL for the pinned duckdb-wasm package. Used as the default\n * when no custom base is configured.\n */\nexport const DUCKDB_CDN_BASE = `https://cdn.jsdelivr.net/npm/@duckdb/duckdb-wasm@${DUCKDB_WASM_VERSION}`;\n\n/**\n * Rewrites the jsDelivr URLs returned by `getJsDelivrBundles()` to a custom\n * base so the `.wasm` and worker assets load from a self-hosted (or mirrored)\n * location instead of the CDN.\n *\n * The base must mirror jsDelivr's layout for duckdb-wasm\n * {@link DUCKDB_WASM_VERSION}: an `/+esm` ES-module bundle plus the `/dist/*`\n * wasm and worker files. A trailing slash on the base is ignored.\n *\n * @param bundles - Bundle map from duckdb-wasm's `getJsDelivrBundles()`.\n * @param base - Target base URL (e.g. `/vendor/duckdb-wasm-1.31.0`).\n * @returns A new bundle map with rebased URLs (the default base is a no-op).\n */\nexport function rebaseDuckDBBundles(bundles: T, base: string): T {\n const normalized = base.replace(/\\/+$/, '');\n if (normalized === DUCKDB_CDN_BASE) return bundles;\n const rebased = JSON.stringify(bundles).split(DUCKDB_CDN_BASE).join(normalized);\n return JSON.parse(rebased) as T;\n}\n\n/**\n * Minimal structural types for the duckdb-wasm API surface we use.\n * Full types are not imported because the package is loaded from a CDN\n * at runtime and is not a dependency.\n */\nexport interface DuckDBConnection {\n query(text: string): Promise;\n close(): Promise;\n}\n\nexport interface ArrowTable {\n numRows: number;\n toArray(): Array>;\n}\n\nexport interface DuckDBDatabase {\n connect(): Promise;\n registerFileBuffer(name: string, buffer: Uint8Array): Promise;\n registerFileURL(name: string, url: string, protocol: number, directIO: boolean): Promise;\n dropFile(name: string): Promise;\n terminate(): Promise;\n}\n\n/**\n * A loaded DuckDB instance with its primary connection.\n */\nexport interface LoadedDuckDB {\n db: DuckDBDatabase;\n conn: DuckDBConnection;\n /** Whether the spatial build supports native ST_AsMVT tiles */\n supportsMVT: boolean;\n /** DuckDB core version string */\n version: string;\n /** The HTTP value of duckdb-wasm's DuckDBDataProtocol enum */\n httpProtocol: number;\n}\n\n/**\n * Builds the SQL that loads the spatial extension.\n *\n * With no path, the extension is installed from DuckDB's remote repository\n * (`INSTALL spatial; LOAD spatial;`). With a path, the remote INSTALL is\n * skipped in favour of `LOAD ''` so the load works offline; the path is\n * normalized (Windows separators) and single-quote-escaped for the literal.\n *\n * @param spatialExtensionPath - Optional path/URL to a prebuilt extension\n * @returns The SQL statement(s) to run on a fresh connection\n */\nexport function spatialExtensionLoadSql(spatialExtensionPath?: string): string {\n if (!spatialExtensionPath) return 'INSTALL spatial; LOAD spatial;';\n const normalized = spatialExtensionPath.replace(/\\\\/g, '/').replace(/'/g, \"''\");\n return `LOAD '${normalized}'`;\n}\n\n/**\n * Imports a module by URL at runtime without bundler interference.\n * Indirection through Function keeps Vite/webpack/rollup from trying to\n * resolve or rewrite the CDN import.\n */\nconst dynamicImport = new Function('url', 'return import(url)') as (\n url: string,\n) => Promise>;\n\n/**\n * Loads a remote ES module from a URL.\n *\n * Exported for reuse by the MVT JS fallback loader.\n *\n * @param url - Module URL\n * @returns The module namespace object\n */\nexport function importFromCdn(url: string): Promise> {\n return dynamicImport(url);\n}\n\nconst cdnScriptPromises = new Map>();\n\n/**\n * Loads a classic (non-module) script from a URL via a `