import { ExtraSamplesValues, arrayFields, fieldTagNames, fieldTypeNames, fieldTypes, geoKeyNames, globals_exports, photometricInterpretations } from "./chunk-QTABLK4X.js"; import "./chunk-C5KGH6RQ.js"; import { ImageCanvas_default, fromResolutionLike } from "./chunk-3TN6D4MD.js"; import { ATTRIBUTION, OSM_default } from "./chunk-43GYE2V5.js"; import { Vector_default, loadFeaturesXhr } from "./chunk-PD2E5XZ4.js"; import { Image_default as Image_default2, orthographic, scale as scale3, translate, translation } from "./chunk-E7S7Q7VV.js"; import "./chunk-V7WRBSQ6.js"; import "./chunk-W7BDJOQY.js"; import "./chunk-7JXPN73Q.js"; import { Feature_default } from "./chunk-E53S5GN6.js"; import { DataTile_default, LRUCache_default, Tile_default as Tile_default2, asArrayLike, asImageLike, toArray } from "./chunk-UNDFRJ2M.js"; import "./chunk-JFXZSSOM.js"; import "./chunk-ZUI5NXIU.js"; import { TileQueue_default } from "./chunk-CAVOO5JW.js"; import "./chunk-M5TTSD4C.js"; import "./chunk-RW3V7S4F.js"; import "./chunk-I6K7MRGV.js"; import "./chunk-PGWX4545.js"; import "./chunk-AYBYZSAV.js"; import { ViewHint_default } from "./chunk-YLJGUH5Z.js"; import { Point_default } from "./chunk-AZGMK675.js"; import { TileEventType_default, TileGrid_default, TileImage_default, TileSourceEvent, Tile_default as Tile_default3, UrlTile_default, XYZ_default, appendParams, createFromTemplates, createFromTileUrlFunctions, createXYZ, expandUrl, extentFromProjection, getForProjection, nullTileUrlFunction, pickUrl, renderXYZTemplate } from "./chunk-3ZDRPUXW.js"; import { Source_default } from "./chunk-6Y7C6NBJ.js"; import { ERROR_THRESHOLD, ImageTile_default, Tile_default, Triangulation_default, calculateSourceExtentResolution, calculateSourceResolution, createOrUpdate2 as createOrUpdate, getCacheKey, getKeyZXY, hash, render } from "./chunk-7XMWB3J4.js"; import { TileState_default } from "./chunk-5D2XPBR2.js"; import { ImageState_default, Image_default, decode, scale as scale2, toSize } from "./chunk-SHUBVYN4.js"; import { DEFAULT_MAX_ZOOM, DEFAULT_TILE_SIZE } from "./chunk-FM44FOIC.js"; import "./chunk-LMC3RO5P.js"; import { apply, create, makeInverse, multiply } from "./chunk-X52LGBOS.js"; import { assert } from "./chunk-QFCIXVZ3.js"; import { Projection_default, add, compareVersions, createTransformFromCoordinateTransform, equivalent, error, fromCode, get, getTransformFromProjections, scale, toLonLat, toUserCoordinate, toUserExtent, transform, transformExtent } from "./chunk-A3RXLHYB.js"; import "./chunk-ZLPTRF2L.js"; import { ceil, clamp, floor, modulo, round } from "./chunk-54BTDBAD.js"; import { createCanvasContext2D, releaseCanvas } from "./chunk-UPTVWZ45.js"; import { WORKER_OFFSCREEN_CANVAS } from "./chunk-5XHD7RSF.js"; import { getUid } from "./chunk-Q5ZULJHM.js"; import { Disposable_default, Event_default, listen, listenOnce, unlistenByKey } from "./chunk-NGFXCWUF.js"; import { EventType_default, linearFindNearest, toPromise } from "./chunk-K25ZO44T.js"; import { applyTransform, buffer, containsExtent, createEmpty, createOrUpdateFromCoordinate, equals, extend, getArea, getBottomLeft, getCenter, getForViewAndSize, getHeight, getIntersection, getTopLeft, getTopRight, getWidth, intersects, isEmpty as isEmpty2, scaleFromCenter, wrapAndSliceX } from "./chunk-SRXHWJOY.js"; import { isEmpty } from "./chunk-5RHQVMYD.js"; import { __commonJS, __toESM } from "./chunk-DC5AMYBS.js"; // node_modules/xml-utils/get-attribute.js var require_get_attribute = __commonJS({ "node_modules/xml-utils/get-attribute.js"(exports, module) { function getAttribute2(tag, attributeName, options) { const debug = options && options.debug || false; if (debug) console.log("[xml-utils] getting " + attributeName + " in " + tag); const xml = typeof tag === "object" ? tag.outer : tag; const opening = xml.slice(0, xml.indexOf(">") + 1); const quotechars = ['"', "'"]; for (let i = 0; i < quotechars.length; i++) { const char = quotechars[i]; const pattern = attributeName + "\\=" + char + "([^" + char + "]*)" + char; if (debug) console.log("[xml-utils] pattern:", pattern); const re = new RegExp(pattern); const match = re.exec(opening); if (debug) console.log("[xml-utils] match:", match); if (match) return match[1]; } } module.exports = getAttribute2; module.exports.default = getAttribute2; } }); // node_modules/xml-utils/index-of-match.js var require_index_of_match = __commonJS({ "node_modules/xml-utils/index-of-match.js"(exports, module) { function indexOfMatch(xml, pattern, startIndex) { const re = new RegExp(pattern); const match = re.exec(xml.slice(startIndex)); if (match) return startIndex + match.index; else return -1; } module.exports = indexOfMatch; module.exports.default = indexOfMatch; } }); // node_modules/xml-utils/index-of-match-end.js var require_index_of_match_end = __commonJS({ "node_modules/xml-utils/index-of-match-end.js"(exports, module) { function indexOfMatchEnd(xml, pattern, startIndex) { const re = new RegExp(pattern); const match = re.exec(xml.slice(startIndex)); if (match) return startIndex + match.index + match[0].length - 1; else return -1; } module.exports = indexOfMatchEnd; module.exports.default = indexOfMatchEnd; } }); // node_modules/xml-utils/count-substring.js var require_count_substring = __commonJS({ "node_modules/xml-utils/count-substring.js"(exports, module) { function countSubstring(string, substring) { const pattern = new RegExp(substring, "g"); const match = string.match(pattern); return match ? match.length : 0; } module.exports = countSubstring; module.exports.default = countSubstring; } }); // node_modules/xml-utils/find-tag-by-name.js var require_find_tag_by_name = __commonJS({ "node_modules/xml-utils/find-tag-by-name.js"(exports, module) { var indexOfMatch = require_index_of_match(); var indexOfMatchEnd = require_index_of_match_end(); var countSubstring = require_count_substring(); function findTagByName(xml, tagName, options) { const debug = options && options.debug || false; const nested = !(options && typeof options.nested === false); const startIndex = options && options.startIndex || 0; if (debug) console.log("[xml-utils] starting findTagByName with", tagName, " and ", options); const start = indexOfMatch(xml, `<${tagName}[ >/]`, startIndex); if (debug) console.log("[xml-utils] start:", start); if (start === -1) return void 0; const afterStart = xml.slice(start + tagName.length); let relativeEnd = indexOfMatchEnd(afterStart, "^[^<]*[ /]>", 0); const selfClosing = relativeEnd !== -1 && afterStart[relativeEnd - 1] === "/"; if (debug) console.log("[xml-utils] selfClosing:", selfClosing); if (selfClosing === false) { if (nested) { let startIndex2 = 0; let openings = 1; let closings = 0; while ((relativeEnd = indexOfMatchEnd(afterStart, "[ /]" + tagName + ">", startIndex2)) !== -1) { const clip = afterStart.substring(startIndex2, relativeEnd + 1); openings += countSubstring(clip, "<" + tagName + "[ \n >]"); closings += countSubstring(clip, ""); if (closings >= openings) break; startIndex2 = relativeEnd; } } else { relativeEnd = indexOfMatchEnd(afterStart, "[ /]" + tagName + ">", 0); } } const end = start + tagName.length + relativeEnd + 1; if (debug) console.log("[xml-utils] end:", end); if (end === -1) return void 0; const outer = xml.slice(start, end); let inner; if (selfClosing) { inner = null; } else { inner = outer.slice(outer.indexOf(">") + 1, outer.lastIndexOf("<")); } return { inner, outer, start, end }; } module.exports = findTagByName; module.exports.default = findTagByName; } }); // node_modules/xml-utils/find-tags-by-name.js var require_find_tags_by_name = __commonJS({ "node_modules/xml-utils/find-tags-by-name.js"(exports, module) { var findTagByName = require_find_tag_by_name(); function findTagsByName2(xml, tagName, options) { const tags = []; const debug = options && options.debug || false; const nested = options && typeof options.nested === "boolean" ? options.nested : true; let startIndex = options && options.startIndex || 0; let tag; while (tag = findTagByName(xml, tagName, { debug, startIndex })) { if (nested) { startIndex = tag.start + 1 + tagName.length; } else { startIndex = tag.end; } tags.push(tag); } if (debug) console.log("findTagsByName found", tags.length, "tags"); return tags; } module.exports = findTagsByName2; module.exports.default = findTagsByName2; } }); // browser-external:http var require_http = __commonJS({ "browser-external:http"(exports, module) { module.exports = Object.create(new Proxy({}, { get(_, key) { if (key !== "__esModule" && key !== "__proto__" && key !== "constructor" && key !== "splice") { console.warn(`Module "http" has been externalized for browser compatibility. Cannot access "http.${key}" in client code. See https://vite.dev/guide/troubleshooting.html#module-externalized-for-browser-compatibility for more details.`); } } })); } }); // browser-external:https var require_https = __commonJS({ "browser-external:https"(exports, module) { module.exports = Object.create(new Proxy({}, { get(_, key) { if (key !== "__esModule" && key !== "__proto__" && key !== "constructor" && key !== "splice") { console.warn(`Module "https" has been externalized for browser compatibility. Cannot access "https.${key}" in client code. See https://vite.dev/guide/troubleshooting.html#module-externalized-for-browser-compatibility for more details.`); } } })); } }); // browser-external:url var require_url = __commonJS({ "browser-external:url"(exports, module) { module.exports = Object.create(new Proxy({}, { get(_, key) { if (key !== "__esModule" && key !== "__proto__" && key !== "constructor" && key !== "splice") { console.warn(`Module "url" has been externalized for browser compatibility. Cannot access "url.${key}" in client code. See https://vite.dev/guide/troubleshooting.html#module-externalized-for-browser-compatibility for more details.`); } } })); } }); // browser-external:fs var require_fs = __commonJS({ "browser-external:fs"(exports, module) { module.exports = Object.create(new Proxy({}, { get(_, key) { if (key !== "__esModule" && key !== "__proto__" && key !== "constructor" && key !== "splice") { console.warn(`Module "fs" has been externalized for browser compatibility. Cannot access "fs.${key}" in client code. See https://vite.dev/guide/troubleshooting.html#module-externalized-for-browser-compatibility for more details.`); } } })); } }); // node_modules/ol/source/BingMaps.js function quadKey(tileCoord) { const z = tileCoord[0]; const digits = new Array(z); let mask = 1 << z - 1; let i, charCode; for (i = 0; i < z; ++i) { charCode = 48; if (tileCoord[1] & mask) { charCode += 1; } if (tileCoord[2] & mask) { charCode += 2; } digits[i] = String.fromCharCode(charCode); mask >>= 1; } return digits.join(""); } var TOS_ATTRIBUTION = 'Terms of Use'; var BingMaps = class extends TileImage_default { /** * @param {Options} options Bing Maps options. */ constructor(options) { const hidpi = options.hidpi !== void 0 ? options.hidpi : false; super({ cacheSize: options.cacheSize, crossOrigin: "anonymous", interpolate: options.interpolate, projection: get("EPSG:3857"), reprojectionErrorThreshold: options.reprojectionErrorThreshold, state: "loading", tileLoadFunction: options.tileLoadFunction, tilePixelRatio: hidpi ? 2 : 1, wrapX: options.wrapX !== void 0 ? options.wrapX : true, transition: options.transition, zDirection: options.zDirection }); this.hidpi_ = hidpi; this.culture_ = options.culture !== void 0 ? options.culture : "en-us"; this.maxZoom_ = options.maxZoom !== void 0 ? options.maxZoom : -1; this.apiKey_ = options.key; this.imagerySet_ = options.imagerySet; this.placeholderTiles_ = options.placeholderTiles; const url = (options.url || "https://dev.virtualearth.net/REST/v1/Imagery/Metadata/") + this.imagerySet_ + "?uriScheme=https&include=ImageryProviders&key=" + this.apiKey_ + "&c=" + this.culture_; fetch(url).then((response) => response.json()).then((json) => this.handleImageryMetadataResponse(json)); } /** * Get the api key used for this source. * * @return {string} The api key. * @api */ getApiKey() { return this.apiKey_; } /** * Get the imagery set associated with this source. * * @return {string} The imagery set. * @api */ getImagerySet() { return this.imagerySet_; } /** * @param {BingMapsImageryMetadataResponse} response Response. */ handleImageryMetadataResponse(response) { if (response.statusCode != 200 || response.statusDescription != "OK" || response.authenticationResultCode != "ValidCredentials" || response.resourceSets.length != 1 || response.resourceSets[0].resources.length != 1) { this.setState("error"); return; } const resource = response.resourceSets[0].resources[0]; const maxZoom2 = this.maxZoom_ == -1 ? resource.zoomMax : this.maxZoom_; const sourceProjection = this.getProjection(); const extent = extentFromProjection(sourceProjection); const scale4 = this.hidpi_ ? 2 : 1; const tileSize = resource.imageWidth == resource.imageHeight ? resource.imageWidth / scale4 : [resource.imageWidth / scale4, resource.imageHeight / scale4]; const tileGrid = createXYZ({ extent, minZoom: resource.zoomMin, maxZoom: maxZoom2, tileSize }); this.tileGrid = tileGrid; const culture = this.culture_; const hidpi = this.hidpi_; const placeholderTiles = this.placeholderTiles_; this.tileUrlFunction = createFromTileUrlFunctions( resource.imageUrlSubdomains.map(function(subdomain) { const quadKeyTileCoord = [0, 0, 0]; const imageUrl = resource.imageUrl.replace("{subdomain}", subdomain).replace("{culture}", culture); return ( /** * @param {import("../tilecoord.js").TileCoord} tileCoord Tile coordinate. * @param {number} pixelRatio Pixel ratio. * @param {import("../proj/Projection.js").default} projection Projection. * @return {string|undefined} Tile URL. */ (function(tileCoord, pixelRatio, projection) { if (!tileCoord) { return void 0; } createOrUpdate( tileCoord[0], tileCoord[1], tileCoord[2], quadKeyTileCoord ); const url = new URL( imageUrl.replace("{quadkey}", quadKey(quadKeyTileCoord)) ); const params = url.searchParams; if (hidpi) { params.set("dpi", "d1"); params.set("device", "mobile"); } if (placeholderTiles === true) { params.delete("n"); } else if (placeholderTiles === false) { params.set("n", "z"); } return url.toString(); }) ); }) ); if (resource.imageryProviders) { const transform2 = getTransformFromProjections( get("EPSG:4326"), this.getProjection() ); this.setAttributions((frameState) => { const attributions = []; const viewState = frameState.viewState; const tileGrid2 = this.getTileGrid(); const z = tileGrid2.getZForResolution( viewState.resolution, this.zDirection ); const tileCoord = tileGrid2.getTileCoordForCoordAndZ( viewState.center, z ); const zoom = tileCoord[0]; resource.imageryProviders.map(function(imageryProvider) { let intersecting = false; const coverageAreas = imageryProvider.coverageAreas; for (let i = 0, ii = coverageAreas.length; i < ii; ++i) { const coverageArea = coverageAreas[i]; if (zoom >= coverageArea.zoomMin && zoom <= coverageArea.zoomMax) { const bbox = coverageArea.bbox; const epsg4326Extent = [bbox[1], bbox[0], bbox[3], bbox[2]]; const extent2 = applyTransform(epsg4326Extent, transform2); if (intersects(extent2, frameState.extent)) { intersecting = true; break; } } } if (intersecting) { attributions.push(imageryProvider.attribution); } }); attributions.push(TOS_ATTRIBUTION); return attributions; }); } this.setState("ready"); } }; var BingMaps_default = BingMaps; // node_modules/ol/source/CartoDB.js var CartoDB = class extends XYZ_default { /** * @param {Options} options CartoDB options. */ constructor(options) { super({ attributions: options.attributions, cacheSize: options.cacheSize, crossOrigin: options.crossOrigin, maxZoom: options.maxZoom !== void 0 ? options.maxZoom : 18, minZoom: options.minZoom, projection: options.projection, transition: options.transition, wrapX: options.wrapX, zDirection: options.zDirection }); this.account_ = options.account; this.mapId_ = options.map || ""; this.config_ = options.config || {}; this.templateCache_ = {}; this.initializeMap_(); } /** * Returns the current config. * @return {!Object} The current configuration. * @api */ getConfig() { return this.config_; } /** * Updates the carto db config. * @param {Object} config a key-value lookup. Values will replace current values * in the config. * @api */ updateConfig(config) { Object.assign(this.config_, config); this.initializeMap_(); } /** * Sets the CartoDB config * @param {Object} config In the case of anonymous maps, a CartoDB configuration * object. * If using named maps, a key-value lookup with the template parameters. * @api */ setConfig(config) { this.config_ = config || {}; this.initializeMap_(); } /** * Issue a request to initialize the CartoDB map. * @private */ initializeMap_() { const paramHash = JSON.stringify(this.config_); if (this.templateCache_[paramHash]) { this.applyTemplate_(this.templateCache_[paramHash]); return; } let mapUrl = "https://" + this.account_ + ".carto.com/api/v1/map"; if (this.mapId_) { mapUrl += "/named/" + this.mapId_; } const client = new XMLHttpRequest(); client.addEventListener( "load", this.handleInitResponse_.bind(this, paramHash) ); client.addEventListener("error", this.handleInitError_.bind(this)); client.open("POST", mapUrl); client.setRequestHeader("Content-type", "application/json"); client.send(JSON.stringify(this.config_)); } /** * Handle map initialization response. * @param {string} paramHash a hash representing the parameter set that was used * for the request * @param {Event} event Event. * @private */ handleInitResponse_(paramHash, event) { const client = ( /** @type {XMLHttpRequest} */ event.target ); if (!client.status || client.status >= 200 && client.status < 300) { let response; try { response = /** @type {CartoDBLayerInfo} */ JSON.parse(client.responseText); } catch { this.setState("error"); return; } this.applyTemplate_(response); this.templateCache_[paramHash] = response; this.setState("ready"); } else { this.setState("error"); } } /** * @private * @param {Event} event Event. */ handleInitError_(event) { this.setState("error"); } /** * Apply the new tile urls returned by carto db * @param {CartoDBLayerInfo} data Result of carto db call. * @private */ applyTemplate_(data) { const tilesUrl = "https://" + data.cdn_url.https + "/" + this.account_ + "/api/v1/map/" + data.layergroupid + "/{z}/{x}/{y}.png"; this.setUrl(tilesUrl); } }; var CartoDB_default = CartoDB; // node_modules/ol/source/Cluster.js var Cluster = class extends Vector_default { /** * @param {Options} [options] Cluster options. */ constructor(options) { options = options || {}; super({ attributions: options.attributions, wrapX: options.wrapX }); this.resolution = void 0; this.distance = options.distance !== void 0 ? options.distance : 20; this.minDistance = options.minDistance || 0; this.interpolationRatio = 0; this.features = []; this.geometryFunction = options.geometryFunction || function(feature) { const geometry = ( /** @type {Point} */ feature.getGeometry() ); assert( !geometry || geometry.getType() === "Point", "The default `geometryFunction` can only handle `Point` or null geometries" ); return geometry; }; this.createCustomCluster_ = options.createCluster; this.source = null; this.boundRefresh_ = this.refresh.bind(this); this.updateDistance(this.distance, this.minDistance); this.setSource(options.source || null); } /** * Remove all features from the source. * @param {boolean} [fast] Skip dispatching of {@link module:ol/source/VectorEventType~VectorEventType#removefeature} events. * @api * @override */ clear(fast) { this.features.length = 0; super.clear(fast); } /** * Get the distance in pixels between clusters. * @return {number} Distance. * @api */ getDistance() { return this.distance; } /** * Get a reference to the wrapped source. * @return {VectorSource|null} Source. * @api */ getSource() { return this.source; } /** * @param {import("../extent.js").Extent} extent Extent. * @param {number} resolution Resolution. * @param {import("../proj/Projection.js").default} projection Projection. * @override */ loadFeatures(extent, resolution, projection) { var _a; (_a = this.source) == null ? void 0 : _a.loadFeatures(extent, resolution, projection); if (resolution !== this.resolution) { this.resolution = resolution; this.refresh(); } } /** * Set the distance within which features will be clusterd together. * @param {number} distance The distance in pixels. * @api */ setDistance(distance) { this.updateDistance(distance, this.minDistance); } /** * Set the minimum distance between clusters. Will be capped at the * configured distance. * @param {number} minDistance The minimum distance in pixels. * @api */ setMinDistance(minDistance) { this.updateDistance(this.distance, minDistance); } /** * The configured minimum distance between clusters. * @return {number} The minimum distance in pixels. * @api */ getMinDistance() { return this.minDistance; } /** * Replace the wrapped source. * @param {VectorSource|null} source The new source for this instance. * @api */ setSource(source) { if (this.source) { this.source.removeEventListener(EventType_default.CHANGE, this.boundRefresh_); } this.source = source; if (source) { source.addEventListener(EventType_default.CHANGE, this.boundRefresh_); } this.refresh(); } /** * Handle the source changing. * @override */ refresh() { this.clear(); this.cluster(); this.addFeatures(this.features); } /** * Update the distances and refresh the source if necessary. * @param {number} distance The new distance. * @param {number} minDistance The new minimum distance. */ updateDistance(distance, minDistance) { const ratio = distance === 0 ? 0 : Math.min(minDistance, distance) / distance; const changed = distance !== this.distance || this.interpolationRatio !== ratio; this.distance = distance; this.minDistance = minDistance; this.interpolationRatio = ratio; if (changed) { this.refresh(); } } /** * @protected */ cluster() { if (this.resolution === void 0 || !this.source) { return; } const extent = createEmpty(); const mapDistance = this.distance * this.resolution; const features = this.source.getFeatures(); const clustered = {}; for (let i = 0, ii = features.length; i < ii; i++) { const feature = features[i]; if (!(getUid(feature) in clustered)) { const geometry = this.geometryFunction(feature); if (geometry) { const coordinates = geometry.getCoordinates(); createOrUpdateFromCoordinate(coordinates, extent); buffer(extent, mapDistance, extent); const neighbors = this.source.getFeaturesInExtent(extent).filter(function(neighbor) { const uid = getUid(neighbor); if (uid in clustered) { return false; } clustered[uid] = true; return true; }); this.features.push(this.createCluster(neighbors, extent)); } } } } /** * @param {Array} features Features * @param {import("../extent.js").Extent} extent The searched extent for these features. * @return {Feature} The cluster feature. * @protected */ createCluster(features, extent) { const centroid = [0, 0]; for (let i = features.length - 1; i >= 0; --i) { const geometry2 = this.geometryFunction(features[i]); if (geometry2) { add(centroid, geometry2.getCoordinates()); } else { features.splice(i, 1); } } scale(centroid, 1 / features.length); const searchCenter = getCenter(extent); const ratio = this.interpolationRatio; const geometry = new Point_default([ centroid[0] * (1 - ratio) + searchCenter[0] * ratio, centroid[1] * (1 - ratio) + searchCenter[1] * ratio ]); if (this.createCustomCluster_) { return this.createCustomCluster_(geometry, features); } return new Feature_default({ geometry, features }); } }; var Cluster_default = Cluster; // node_modules/ol/webgl/Canvas.js var VERTEX_SHADER = ` attribute vec4 a_position; attribute vec4 a_texcoord; uniform mat4 u_matrix; uniform mat4 u_textureMatrix; varying vec2 v_texcoord; void main() { gl_Position = u_matrix * a_position; vec2 texcoord = (u_textureMatrix * a_texcoord).xy; v_texcoord = texcoord; } `; var FRAGMENT_SHADER = ` precision mediump float; varying vec2 v_texcoord; uniform sampler2D u_texture; void main() { if ( v_texcoord.x < 0.0 || v_texcoord.y < 0.0 || v_texcoord.x > 1.0 || v_texcoord.y > 1.0 ) { discard; } gl_FragColor = texture2D(u_texture, v_texcoord); } `; var Canvas = class { /** * @param {WebGLRenderingContext} gl Context to render in. */ constructor(gl) { this.gl_ = gl; this.program_ = createProgram(gl, FRAGMENT_SHADER, VERTEX_SHADER); this.positionLocation = gl.getAttribLocation(this.program_, "a_position"); this.texcoordLocation = gl.getAttribLocation(this.program_, "a_texcoord"); this.matrixLocation = gl.getUniformLocation(this.program_, "u_matrix"); this.textureMatrixLocation = gl.getUniformLocation( this.program_, "u_textureMatrix" ); this.textureLocation = gl.getUniformLocation(this.program_, "u_texture"); this.positionBuffer = gl.createBuffer(); gl.bindBuffer(gl.ARRAY_BUFFER, this.positionBuffer); this.positions = [0, 0, 0, 1, 1, 0, 1, 0, 0, 1, 1, 1]; gl.bufferData( gl.ARRAY_BUFFER, new Float32Array(this.positions), gl.STATIC_DRAW ); this.texcoordBuffer = gl.createBuffer(); gl.bindBuffer(gl.ARRAY_BUFFER, this.texcoordBuffer); this.texcoords = [0, 0, 0, 1, 1, 0, 1, 0, 0, 1, 1, 1]; gl.bufferData( gl.ARRAY_BUFFER, new Float32Array(this.texcoords), gl.STATIC_DRAW ); } /** * 2dContext drawImage call implemented in webgl. * Unlike images, textures do not have a width and height associated * with them so we'll pass in the width and height of the texture. * * @param {WebGLTexture} tex Image to draw. * @param {number} texWidth Image width. * @param {number} texHeight Image height. * @param {number} srcX Top-left x-point to read src image. * @param {number} srcY Top-left y-point to read src image. * @param {number} [srcWidth] Width of source to read. * @param {number} [srcHeight] Height of source to read. * @param {number} [dstX] Top-left x-point of destination. * @param {number} [dstY] Top-left y-point of destination. * @param {number} [dstWidth] Width of written image in destination. * @param {number} [dstHeight] Height of written image in destination. * @param {number} [width] Width of canvas. * @param {number} [height] Height of canvas. */ drawImage(tex, texWidth, texHeight, srcX, srcY, srcWidth, srcHeight, dstX, dstY, dstWidth, dstHeight, width, height) { const gl = this.gl_; if (dstX === void 0) { dstX = srcX; } if (dstY === void 0) { dstY = srcY; } if (srcWidth === void 0) { srcWidth = texWidth; } if (srcHeight === void 0) { srcHeight = texHeight; } if (dstWidth === void 0) { dstWidth = srcWidth; } if (dstHeight === void 0) { dstHeight = srcHeight; } if (width === void 0) { width = gl.canvas.width; } if (height === void 0) { height = gl.canvas.height; } gl.bindTexture(gl.TEXTURE_2D, tex); gl.useProgram(this.program_); gl.bindBuffer(gl.ARRAY_BUFFER, this.positionBuffer); gl.enableVertexAttribArray(this.positionLocation); gl.vertexAttribPointer(this.positionLocation, 2, gl.FLOAT, false, 0, 0); gl.bindBuffer(gl.ARRAY_BUFFER, this.texcoordBuffer); gl.enableVertexAttribArray(this.texcoordLocation); gl.vertexAttribPointer(this.texcoordLocation, 2, gl.FLOAT, false, 0, 0); let matrix = orthographic(0, width, 0, height, -1, 1); matrix = translate(matrix, dstX, dstY, 0); matrix = scale3(matrix, dstWidth, dstHeight, 1); gl.uniformMatrix4fv(this.matrixLocation, false, matrix); let texMatrix = translation(srcX / texWidth, srcY / texHeight, 0); texMatrix = scale3( texMatrix, srcWidth / texWidth, srcHeight / texHeight, 1 ); gl.uniformMatrix4fv(this.textureMatrixLocation, false, texMatrix); gl.uniform1i(this.textureLocation, 0); gl.drawArrays(gl.TRIANGLES, 0, this.positions.length / 2); } }; function createShader(gl, type, source) { const shader = gl.createShader(type); if (shader === null) { throw new Error("Shader compilation failed"); } gl.shaderSource(shader, source); gl.compileShader(shader); if (!gl.getShaderParameter(shader, gl.COMPILE_STATUS)) { const log = gl.getShaderInfoLog(shader); if (log === null) { throw new Error("Shader info log creation failed"); } throw new Error(log); } return shader; } function createProgram(gl, fragmentSource, vertexSource) { const program = gl.createProgram(); const vertexShader = createShader(gl, gl.VERTEX_SHADER, vertexSource); const fragmentShader = createShader(gl, gl.FRAGMENT_SHADER, fragmentSource); if (program === null) { throw new Error("Program creation failed"); } gl.attachShader(program, vertexShader); gl.attachShader(program, fragmentShader); gl.linkProgram(program); if (!gl.getProgramParameter(program, gl.LINK_STATUS)) { const log = gl.getProgramInfoLog(program); if (log === null) { throw new Error("Program info log creation failed"); } throw new Error(); } return program; } // node_modules/ol/reproj/glreproj.js var EDGE_VERTEX_SHADER = ` attribute vec4 a_position; uniform mat4 u_matrix; void main() { gl_Position = u_matrix * a_position; } `; var EDGE_FRAGMENT_SHADER = ` precision mediump float; uniform vec4 u_val; void main() { gl_FragColor = u_val; } `; var TRIANGLE_VERTEX_SHADER = ` attribute vec4 a_position; attribute vec2 a_texcoord; varying vec2 v_texcoord; uniform mat4 u_matrix; void main() { gl_Position = u_matrix * a_position; v_texcoord = a_texcoord; } `; var TRIANGLE_FRAGMENT_SHADER = ` precision mediump float; varying vec2 v_texcoord; uniform sampler2D u_texture; void main() { if (v_texcoord.x < 0.0 || v_texcoord.x > 1.0 || v_texcoord.y < 0.0 || v_texcoord.y > 1.0) { discard; } gl_FragColor = texture2D(u_texture, v_texcoord); } `; function createCanvasContextWebGL(width, height, canvasPool2, settings) { let canvas; if (canvasPool2 && canvasPool2.length) { canvas = /** @type {HTMLCanvasElement} */ canvasPool2.shift(); } else if (WORKER_OFFSCREEN_CANVAS) { canvas = new OffscreenCanvas(width || 300, height || 300); } else { canvas = document.createElement("canvas"); } if (width) { canvas.width = width; } if (height) { canvas.height = height; } return ( /** @type {WebGLRenderingContext} */ canvas.getContext("webgl", settings) ); } function releaseGLCanvas(gl) { const canvas = gl.canvas; canvas.width = 1; canvas.height = 1; gl.clear(gl.COLOR_BUFFER_BIT | gl.DEPTH_BUFFER_BIT | gl.STENCIL_BUFFER_BIT); } var canvasGLPool = []; function render2(gl, width_, height_, pixelRatio, sourceResolution, targetResolution, targetExtent, triangulation, sources, gutter, dataType, renderEdges, interpolate, drawSingle) { const width = Math.round(pixelRatio * width_); const height = Math.round(pixelRatio * height_); gl.canvas.width = width; gl.canvas.height = height; let resultFrameBuffer; let resultTexture; { resultTexture = gl.createTexture(); gl.bindTexture(gl.TEXTURE_2D, resultTexture); gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE); gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE); if (interpolate) { gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.LINEAR); gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.LINEAR); } else { gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.NEAREST); gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.NEAREST); } gl.texImage2D( gl.TEXTURE_2D, 0, gl.RGBA, width, height, 0, gl.RGBA, dataType, null ); resultFrameBuffer = gl.createFramebuffer(); gl.bindFramebuffer(gl.FRAMEBUFFER, resultFrameBuffer); gl.framebufferTexture2D( gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, gl.TEXTURE_2D, resultTexture, 0 ); } if (resultFrameBuffer === null) { throw new Error("Could not create framebuffer"); } if (resultTexture === null) { throw new Error("Could not create texture"); } if (sources.length === 0) { return { width, height, framebuffer: resultFrameBuffer, texture: resultTexture }; } const sourceDataExtent = createEmpty(); sources.forEach(function(src, i, arr) { extend(sourceDataExtent, src.extent); }); let stitchTexture; let stitchWidth; let stitchHeight; const stitchScale = 1 / sourceResolution; if (!drawSingle || sources.length !== 1 || gutter !== 0) { stitchTexture = gl.createTexture(); if (resultTexture === null) { throw new Error("Could not create texture"); } stitchWidth = Math.round(getWidth(sourceDataExtent) * stitchScale); stitchHeight = Math.round(getHeight(sourceDataExtent) * stitchScale); const maxTexSize = gl.getParameter(gl.MAX_TEXTURE_SIZE); const largeSide = Math.max(stitchWidth, stitchHeight); const scaleFactor = largeSide > maxTexSize ? maxTexSize / largeSide : 1; const stitchWidthFixed = Math.round(stitchWidth * scaleFactor); const stitchHeightFixed = Math.round(stitchHeight * scaleFactor); gl.bindTexture(gl.TEXTURE_2D, stitchTexture); gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE); gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE); if (interpolate) { gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.LINEAR); gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.LINEAR); } else { gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.NEAREST); gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.NEAREST); } gl.texImage2D( gl.TEXTURE_2D, 0, gl.RGBA, stitchWidthFixed, stitchHeightFixed, 0, gl.RGBA, dataType, null ); const fb = gl.createFramebuffer(); gl.bindFramebuffer(gl.FRAMEBUFFER, fb); gl.framebufferTexture2D( gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, gl.TEXTURE_2D, stitchTexture, 0 ); const webGLCanvas = new Canvas(gl); sources.forEach(function(src, i, arr) { const xPos = (src.extent[0] - sourceDataExtent[0]) * stitchScale * scaleFactor; const yPos = -(src.extent[3] - sourceDataExtent[3]) * stitchScale * scaleFactor; const srcWidth = getWidth(src.extent) * stitchScale * scaleFactor; const srcHeight = getHeight(src.extent) * stitchScale * scaleFactor; gl.bindFramebuffer(gl.FRAMEBUFFER, fb); gl.viewport(0, 0, stitchWidthFixed, stitchHeightFixed); if (src.clipExtent) { const xPos2 = (src.clipExtent[0] - sourceDataExtent[0]) * stitchScale * scaleFactor; const yPos2 = -(src.clipExtent[3] - sourceDataExtent[3]) * stitchScale * scaleFactor; const width2 = getWidth(src.clipExtent) * stitchScale * scaleFactor; const height2 = getHeight(src.clipExtent) * stitchScale * scaleFactor; gl.enable(gl.SCISSOR_TEST); gl.scissor( interpolate ? xPos2 : Math.round(xPos2), interpolate ? yPos2 : Math.round(yPos2), interpolate ? width2 : Math.round(xPos2 + width2) - Math.round(xPos2), interpolate ? height2 : Math.round(yPos2 + height2) - Math.round(yPos2) ); } webGLCanvas.drawImage( src.texture, src.width, src.height, gutter, gutter, src.width - 2 * gutter, src.height - 2 * gutter, interpolate ? xPos : Math.round(xPos), interpolate ? yPos : Math.round(yPos), interpolate ? srcWidth : Math.round(xPos + srcWidth) - Math.round(xPos), interpolate ? srcHeight : Math.round(yPos + srcHeight) - Math.round(yPos), stitchWidthFixed, stitchHeightFixed ); gl.disable(gl.SCISSOR_TEST); }); gl.deleteFramebuffer(fb); } else { stitchTexture = sources[0].texture; stitchWidth = sources[0].width; stitchHeight = sources[0].width; } const targetTopLeft = getTopLeft(targetExtent); const sourceTopLeft = getTopLeft(sourceDataExtent); const getUVs = (target) => { const u0 = (target[0][0] - targetTopLeft[0]) / targetResolution * pixelRatio; const v0 = -(target[0][1] - targetTopLeft[1]) / targetResolution * pixelRatio; const u1 = (target[1][0] - targetTopLeft[0]) / targetResolution * pixelRatio; const v1 = -(target[1][1] - targetTopLeft[1]) / targetResolution * pixelRatio; const u2 = (target[2][0] - targetTopLeft[0]) / targetResolution * pixelRatio; const v2 = -(target[2][1] - targetTopLeft[1]) / targetResolution * pixelRatio; return { u1, v1, u0, v0, u2, v2 }; }; gl.bindFramebuffer(gl.FRAMEBUFFER, resultFrameBuffer); gl.viewport(0, 0, width, height); { const vertices = []; const texcoords = []; const triProgram = createProgram( gl, TRIANGLE_FRAGMENT_SHADER, TRIANGLE_VERTEX_SHADER ); gl.useProgram(triProgram); const textureLocation = gl.getUniformLocation(triProgram, "u_texture"); gl.bindTexture(gl.TEXTURE_2D, stitchTexture); gl.uniform1i(textureLocation, 0); triangulation.getTriangles().forEach(function(triangle, i, arr) { const source = triangle.source; const target = triangle.target; const { u1, v1, u0, v0, u2, v2 } = getUVs(target); const su0 = (source[0][0] - sourceTopLeft[0]) / sourceResolution / stitchWidth; const sv0 = -(source[0][1] - sourceTopLeft[1]) / sourceResolution / stitchHeight; const su1 = (source[1][0] - sourceTopLeft[0]) / sourceResolution / stitchWidth; const sv1 = -(source[1][1] - sourceTopLeft[1]) / sourceResolution / stitchHeight; const su2 = (source[2][0] - sourceTopLeft[0]) / sourceResolution / stitchWidth; const sv2 = -(source[2][1] - sourceTopLeft[1]) / sourceResolution / stitchHeight; vertices.push(u1, v1, u0, v0, u2, v2); texcoords.push(su1, sv1, su0, sv0, su2, sv2); }); const matrix = orthographic(0, width, height, 0, -1, 1); const matrixLocation = gl.getUniformLocation(triProgram, "u_matrix"); gl.uniformMatrix4fv(matrixLocation, false, matrix); const positionLocation = gl.getAttribLocation(triProgram, "a_position"); const positionBuffer = gl.createBuffer(); gl.bindBuffer(gl.ARRAY_BUFFER, positionBuffer); gl.bufferData(gl.ARRAY_BUFFER, new Float32Array(vertices), gl.STATIC_DRAW); gl.vertexAttribPointer(positionLocation, 2, gl.FLOAT, false, 0, 0); gl.enableVertexAttribArray(positionLocation); const texcoordLocation = gl.getAttribLocation(triProgram, "a_texcoord"); const texcoordBuffer = gl.createBuffer(); gl.bindBuffer(gl.ARRAY_BUFFER, texcoordBuffer); gl.bufferData(gl.ARRAY_BUFFER, new Float32Array(texcoords), gl.STATIC_DRAW); gl.vertexAttribPointer(texcoordLocation, 2, gl.FLOAT, false, 0, 0); gl.enableVertexAttribArray(texcoordLocation); gl.drawArrays(gl.TRIANGLES, 0, vertices.length / 2); } if (renderEdges) { const edgeProgram = createProgram( gl, EDGE_FRAGMENT_SHADER, EDGE_VERTEX_SHADER ); gl.useProgram(edgeProgram); const matrix = orthographic(0, width, height, 0, -1, 1); const matrixLocation = gl.getUniformLocation(edgeProgram, "u_matrix"); gl.uniformMatrix4fv(matrixLocation, false, matrix); const burnval = Array.isArray(renderEdges) ? renderEdges : [0, 0, 0, 255]; const burnvalLocation = gl.getUniformLocation(edgeProgram, "u_val"); const isFloat = true; if (isFloat) { gl.uniform4fv(burnvalLocation, burnval); } else { gl.uniform4iv(burnvalLocation, burnval); } const positionLocation = gl.getAttribLocation(edgeProgram, "a_position"); const positionBuffer = gl.createBuffer(); gl.bindBuffer(gl.ARRAY_BUFFER, positionBuffer); gl.vertexAttribPointer(positionLocation, 2, gl.FLOAT, false, 0, 0); gl.enableVertexAttribArray(positionLocation); const lines = triangulation.getTriangles().reduce(function(lines2, triangle) { const target = triangle.target; const { u1, v1, u0, v0, u2, v2 } = getUVs(target); return lines2.concat([u1, v1, u0, v0, u0, v0, u2, v2, u2, v2, u1, v1]); }, []); gl.bufferData(gl.ARRAY_BUFFER, new Float32Array(lines), gl.STATIC_DRAW); gl.drawArrays(gl.LINES, 0, lines.length / 2); } return { width, height, framebuffer: resultFrameBuffer, texture: resultTexture }; } // node_modules/ol/reproj/DataTile.js var ReprojDataTile = class extends DataTile_default { /** * @param {Options} options Tile options. */ constructor(options) { super({ tileCoord: options.tileCoord, loader: () => Promise.resolve(new Uint8ClampedArray(4)), interpolate: options.interpolate, transition: options.transition }); this.renderEdges_ = options.renderEdges !== void 0 ? options.renderEdges : false; this.pixelRatio_ = options.pixelRatio; this.gutter_ = options.gutter; this.reprojData_ = null; this.reprojError_ = null; this.reprojSize_ = void 0; this.sourceTileGrid_ = options.sourceTileGrid; this.targetTileGrid_ = options.targetTileGrid; this.wrappedTileCoord_ = options.wrappedTileCoord || options.tileCoord; this.sourceTiles_ = []; this.sourcesListenerKeys_ = null; this.sourceZ_ = 0; const sourceProj = options.sourceProj; const sourceProjExtent = sourceProj.getExtent(); const sourceTileGridExtent = options.sourceTileGrid.getExtent(); this.clipExtent_ = sourceProj.canWrapX() ? sourceTileGridExtent ? getIntersection(sourceProjExtent, sourceTileGridExtent) : sourceProjExtent : sourceTileGridExtent; const targetExtent = this.targetTileGrid_.getTileCoordExtent( this.wrappedTileCoord_ ); const maxTargetExtent = this.targetTileGrid_.getExtent(); let maxSourceExtent = this.sourceTileGrid_.getExtent(); const limitedTargetExtent = maxTargetExtent ? getIntersection(targetExtent, maxTargetExtent) : targetExtent; if (getArea(limitedTargetExtent) === 0) { this.state = TileState_default.EMPTY; return; } if (sourceProjExtent) { if (!maxSourceExtent) { maxSourceExtent = sourceProjExtent; } else { maxSourceExtent = getIntersection(maxSourceExtent, sourceProjExtent); } } const targetResolution = this.targetTileGrid_.getResolution( this.wrappedTileCoord_[0] ); const targetProj = options.targetProj; const sourceResolution = calculateSourceExtentResolution( sourceProj, targetProj, limitedTargetExtent, targetResolution ); if (!isFinite(sourceResolution) || sourceResolution <= 0) { this.state = TileState_default.EMPTY; return; } const errorThresholdInPixels = options.errorThreshold !== void 0 ? options.errorThreshold : ERROR_THRESHOLD; this.triangulation_ = new Triangulation_default( sourceProj, targetProj, limitedTargetExtent, maxSourceExtent, sourceResolution * errorThresholdInPixels, targetResolution, options.transformMatrix ); if (this.triangulation_.getTriangles().length === 0) { this.state = TileState_default.EMPTY; return; } this.sourceZ_ = this.sourceTileGrid_.getZForResolution(sourceResolution); let sourceExtent = this.triangulation_.calculateSourceExtent(); if (maxSourceExtent) { if (sourceProj.canWrapX()) { sourceExtent[1] = clamp( sourceExtent[1], maxSourceExtent[1], maxSourceExtent[3] ); sourceExtent[3] = clamp( sourceExtent[3], maxSourceExtent[1], maxSourceExtent[3] ); } else { sourceExtent = getIntersection(sourceExtent, maxSourceExtent); } } if (!getArea(sourceExtent)) { this.state = TileState_default.EMPTY; } else { let worldWidth = 0; let worldsAway = 0; if (sourceProj.canWrapX()) { worldWidth = getWidth(sourceProjExtent); worldsAway = Math.floor( (sourceExtent[0] - sourceProjExtent[0]) / worldWidth ); } const sourceExtents = wrapAndSliceX( sourceExtent.slice(), sourceProj, true ); sourceExtents.forEach((extent) => { const sourceRange = this.sourceTileGrid_.getTileRangeForExtentAndZ( extent, this.sourceZ_ ); const getTile = options.getTileFunction; for (let srcX = sourceRange.minX; srcX <= sourceRange.maxX; srcX++) { for (let srcY = sourceRange.minY; srcY <= sourceRange.maxY; srcY++) { const tile = getTile(this.sourceZ_, srcX, srcY, this.pixelRatio_); if (tile) { const offset = worldsAway * worldWidth; this.sourceTiles_.push({ tile, offset }); } } } ++worldsAway; }); if (this.sourceTiles_.length === 0) { this.state = TileState_default.EMPTY; } } } /** * Get the tile size. * @return {import('../size.js').Size} Tile size. * @override */ getSize() { return this.reprojSize_; } /** * Get the data for the tile. * @return {import("../DataTile.js").Data} Tile data. * @override */ getData() { return this.reprojData_; } /** * Get any loading error. * @return {Error} Loading error. * @override */ getError() { return this.reprojError_; } /** * @private */ reproject_() { const dataSources = []; let imageLike = false; this.sourceTiles_.forEach((source) => { var _a; const tile = source.tile; if (!tile || tile.getState() !== TileState_default.LOADED) { return; } const size2 = tile.getSize(); const gutter = this.gutter_; let tileData; const arrayData = asArrayLike(tile.getData()); if (arrayData) { tileData = arrayData; } else { imageLike = true; tileData = toArray(asImageLike(tile.getData())); } const pixelSize = [size2[0] + 2 * gutter, size2[1] + 2 * gutter]; const isFloat = tileData instanceof Float32Array; const pixelCount = pixelSize[0] * pixelSize[1]; const DataType = isFloat ? Float32Array : Uint8ClampedArray; const tileDataR = new DataType( /** @type {ArrayBuffer} */ tileData.buffer ); const bytesPerElement = DataType.BYTES_PER_ELEMENT; const bytesPerPixel = bytesPerElement * tileDataR.length / pixelCount; const bytesPerRow = tileDataR.byteLength / pixelSize[1]; const bandCount2 = Math.floor( bytesPerRow / bytesPerElement / pixelSize[0] ); const extent = this.sourceTileGrid_.getTileCoordExtent(tile.tileCoord); extent[0] += source.offset; extent[2] += source.offset; const clipExtent = (_a = this.clipExtent_) == null ? void 0 : _a.slice(); if (clipExtent) { clipExtent[0] += source.offset; clipExtent[2] += source.offset; } dataSources.push({ extent, clipExtent, data: tileDataR, dataType: DataType, bytesPerPixel, pixelSize, bandCount: bandCount2 }); }); this.sourceTiles_.length = 0; if (dataSources.length === 0) { this.state = TileState_default.ERROR; this.changed(); return; } const z = this.wrappedTileCoord_[0]; const size = this.targetTileGrid_.getTileSize(z); const targetWidth = typeof size === "number" ? size : size[0]; const targetHeight = typeof size === "number" ? size : size[1]; const outWidth = Math.round(targetWidth * this.pixelRatio_); const outHeight = Math.round(targetHeight * this.pixelRatio_); const targetResolution = this.targetTileGrid_.getResolution(z); const sourceResolution = this.sourceTileGrid_.getResolution(this.sourceZ_); const targetExtent = this.targetTileGrid_.getTileCoordExtent( this.wrappedTileCoord_ ); const bandCount = dataSources[0].bandCount; const dataR = new dataSources[0].dataType(bandCount * outWidth * outHeight); const gl = createCanvasContextWebGL(outWidth, outHeight, canvasGLPool, { premultipliedAlpha: false, antialias: false }); let willInterpolate; const format = gl.RGBA; let textureType; if (dataSources[0].dataType == Float32Array) { textureType = gl.FLOAT; gl.getExtension("WEBGL_color_buffer_float"); gl.getExtension("OES_texture_float"); gl.getExtension("EXT_float_blend"); const extension = gl.getExtension("OES_texture_float_linear"); const canInterpolate = extension !== null; willInterpolate = canInterpolate && this.interpolate; } else { textureType = gl.UNSIGNED_BYTE; willInterpolate = this.interpolate; } const BANDS_PR_REPROJ = 4; const reprojs = Math.ceil(bandCount / BANDS_PR_REPROJ); for (let reproj = reprojs - 1; reproj >= 0; --reproj) { const sources = []; for (let i = 0, len = dataSources.length; i < len; ++i) { const dataSource = dataSources[i]; const pixelSize = dataSource.pixelSize; const width2 = pixelSize[0]; const height2 = pixelSize[1]; const data2 = new dataSource.dataType(BANDS_PR_REPROJ * width2 * height2); const dataS = dataSource.data; let offset2 = reproj * BANDS_PR_REPROJ; for (let j = 0, len2 = data2.length; j < len2; j += BANDS_PR_REPROJ) { data2[j] = dataS[offset2]; data2[j + 1] = dataS[offset2 + 1]; data2[j + 2] = dataS[offset2 + 2]; data2[j + 3] = dataS[offset2 + 3]; offset2 += bandCount; } const texture = gl.createTexture(); gl.bindTexture(gl.TEXTURE_2D, texture); if (willInterpolate) { gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.LINEAR); gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.LINEAR); } else { gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.NEAREST); gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.NEAREST); } gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE); gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE); gl.texImage2D( gl.TEXTURE_2D, 0, format, width2, height2, 0, format, textureType, data2 ); sources.push({ extent: dataSource.extent, clipExtent: dataSource.clipExtent, texture, width: width2, height: height2 }); } const { framebuffer, width, height } = render2( gl, targetWidth, targetHeight, this.pixelRatio_, sourceResolution, targetResolution, targetExtent, this.triangulation_, sources, this.gutter_, textureType, this.renderEdges_, willInterpolate ); const rows = width; const cols = height * BANDS_PR_REPROJ; const data = new dataSources[0].dataType(rows * cols); gl.bindFramebuffer(gl.FRAMEBUFFER, framebuffer); gl.readPixels(0, 0, width, height, gl.RGBA, textureType, data); let offset = reproj * BANDS_PR_REPROJ; for (let i = 0, len = data.length; i < len; i += BANDS_PR_REPROJ) { const flipY = (rows - 1 - (i / cols | 0)) * cols + i % cols; dataR[offset] = data[flipY]; dataR[offset + 1] = data[flipY + 1]; dataR[offset + 2] = data[flipY + 2]; dataR[offset + 3] = data[flipY + 3]; offset += bandCount; } } releaseGLCanvas(gl); canvasGLPool.push(gl.canvas); if (imageLike) { const context = createCanvasContext2D(targetWidth, targetHeight); const imageData = new ImageData(dataR, targetWidth); context.putImageData(imageData, 0, 0); this.reprojData_ = context.canvas; } else { this.reprojData_ = dataR; } this.reprojSize_ = [outWidth, outHeight]; this.state = TileState_default.LOADED; this.changed(); } /** * Load not yet loaded URI. * @override */ load() { if (this.state !== TileState_default.IDLE && this.state !== TileState_default.ERROR) { return; } this.state = TileState_default.LOADING; this.changed(); let leftToLoad = 0; this.sourcesListenerKeys_ = []; this.sourceTiles_.forEach(({ tile }) => { const state = tile.getState(); if (state !== TileState_default.IDLE && state !== TileState_default.LOADING) { return; } leftToLoad++; const sourceListenKey = listen(tile, EventType_default.CHANGE, () => { const state2 = tile.getState(); if (state2 == TileState_default.LOADED || state2 == TileState_default.ERROR || state2 == TileState_default.EMPTY) { unlistenByKey(sourceListenKey); leftToLoad--; if (leftToLoad === 0) { this.unlistenSources_(); this.reproject_(); } } }); this.sourcesListenerKeys_.push(sourceListenKey); }); if (leftToLoad === 0) { setTimeout(this.reproject_.bind(this), 0); } else { this.sourceTiles_.forEach(function({ tile }) { const state = tile.getState(); if (state == TileState_default.IDLE) { tile.load(); } }); } } /** * @private */ unlistenSources_() { this.sourcesListenerKeys_.forEach(unlistenByKey); this.sourcesListenerKeys_ = null; } }; var DataTile_default2 = ReprojDataTile; // node_modules/ol/source/DataTile.js var DataTileSource = class extends Tile_default3 { /** * @param {Options} options DataTile source options. */ constructor(options) { const projection = options.projection === void 0 ? "EPSG:3857" : options.projection; let tileGrid = options.tileGrid; if (tileGrid === void 0 && projection) { tileGrid = createXYZ({ extent: extentFromProjection(projection), maxResolution: options.maxResolution, maxZoom: options.maxZoom, minZoom: options.minZoom, tileSize: options.tileSize }); } super({ cacheSize: 0.1, // don't cache on the source attributions: options.attributions, attributionsCollapsible: options.attributionsCollapsible, projection, tileGrid, state: options.state, wrapX: options.wrapX, transition: options.transition, interpolate: options.interpolate, key: options.key, zDirection: options.zDirection }); this.gutter_ = options.gutter !== void 0 ? options.gutter : 0; this.tileSize_ = options.tileSize ? toSize(options.tileSize) : null; this.tileSizes_ = null; this.tileLoadingKeys_ = {}; this.loader_ = options.loader; this.handleTileChange_ = this.handleTileChange_.bind(this); this.bandCount = options.bandCount === void 0 ? 4 : options.bandCount; this.tileGridForProjection_ = {}; this.crossOrigin_ = options.crossOrigin || "anonymous"; this.transformMatrix = null; } /** * Set the source tile sizes. The length of the array is expected to match the number of * levels in the tile grid. * @protected * @param {Array} tileSizes An array of tile sizes. */ setTileSizes(tileSizes) { this.tileSizes_ = tileSizes; } /** * Get the source tile size at the given zoom level. This may be different than the rendered tile * size. * @protected * @param {number} z Tile zoom level. * @return {import('../size.js').Size} The source tile size. */ getTileSize(z) { if (this.tileSizes_) { return this.tileSizes_[z]; } if (this.tileSize_) { return this.tileSize_; } const tileGrid = this.getTileGrid(); return tileGrid ? toSize(tileGrid.getTileSize(z)) : [256, 256]; } /** * @param {import("../proj/Projection.js").default} projection Projection. * @return {number} Gutter. * @override */ getGutterForProjection(projection) { const thisProj = this.getProjection(); if ((!thisProj || equivalent(thisProj, projection)) && !this.transformMatrix) { return this.gutter_; } return 0; } /** * @param {Loader} loader The data loader. * @protected */ setLoader(loader) { this.loader_ = loader; } /** * @param {number} z Tile coordinate z. * @param {number} x Tile coordinate x. * @param {number} y Tile coordinate y. * @param {import("../proj/Projection.js").default} targetProj The output projection. * @param {import("../proj/Projection.js").default} sourceProj The input projection. * @param {import("../structs/LRUCache.js").default} [tileCache] Tile cache. * @return {!TileType} Tile. */ getReprojTile_(z, x, y, targetProj, sourceProj, tileCache) { const sourceTileGrid = this.tileGrid || this.getTileGridForProjection(sourceProj || targetProj); const reprojTilePixelRatio = Math.max.apply( null, sourceTileGrid.getResolutions().map((r, z2) => { const tileSize = toSize(sourceTileGrid.getTileSize(z2)); const textureSize = this.getTileSize(z2); return Math.max( textureSize[0] / tileSize[0], textureSize[1] / tileSize[1] ); }) ); const targetTileGrid = this.getTileGridForProjection(targetProj); const tileCoord = [z, x, y]; const wrappedTileCoord = this.getTileCoordForTileUrlFunction( tileCoord, targetProj ); const options = Object.assign( { sourceProj: sourceProj || targetProj, sourceTileGrid, targetProj, targetTileGrid, tileCoord, wrappedTileCoord, pixelRatio: reprojTilePixelRatio, gutter: this.gutter_, getTileFunction: (z2, x2, y2, pixelRatio) => this.getTile(z2, x2, y2, pixelRatio, void 0, tileCache), transformMatrix: this.transformMatrix }, /** @type {import("../reproj/DataTile.js").Options} */ this.tileOptions ); const tile = ( /** @type {TileType} */ /** @type {*} */ new DataTile_default2(options) ); tile.key = this.getKey(); return tile; } /** * @param {number} z Tile coordinate z. * @param {number} x Tile coordinate x. * @param {number} y Tile coordinate y. * @param {number} pixelRatio Pixel ratio. * @param {import("../proj/Projection.js").default} [projection] Projection. * @param {import("../structs/LRUCache.js").default} [tileCache] Tile cache. * @return {TileType|null} Tile (or null if outside source extent). * @override */ getTile(z, x, y, pixelRatio, projection, tileCache) { var _a; const sourceProjection = this.getProjection(); if (projection && (sourceProjection && !equivalent(sourceProjection, projection) || this.transformMatrix)) { return this.getReprojTile_( z, x, y, projection, sourceProjection, tileCache ); } const size = this.getTileSize(z); const sourceLoader = this.loader_; const controller = new AbortController(); const loaderOptions = { signal: controller.signal, crossOrigin: this.crossOrigin_ }; const tileCoord = this.getTileCoordForTileUrlFunction([z, x, y]); if (!tileCoord) { return null; } const key = this.getKey(); const cacheKey = getCacheKey(this, key, z, x, y); if (tileCache && tileCache.containsKey(cacheKey)) { return ( /** @type {TileType} */ tileCache.get(cacheKey) ); } const requestZ = tileCoord[0]; const requestX = tileCoord[1]; const requestY = tileCoord[2]; const range = (_a = this.getTileGrid()) == null ? void 0 : _a.getFullTileRange(requestZ); if (range) { loaderOptions.maxY = range.getHeight() - 1; } function loader() { return toPromise(function() { return sourceLoader(requestZ, requestX, requestY, loaderOptions); }); } const options = Object.assign( { tileCoord: [z, x, y], loader, size, controller }, this.tileOptions ); const tile = ( /** @type {TileType} */ /** @type {*} */ new DataTile_default(options) ); tile.key = this.getKey(); tile.addEventListener(EventType_default.CHANGE, this.handleTileChange_); tileCache == null ? void 0 : tileCache.set(cacheKey, tile); return tile; } /** * Handle tile change events. * @param {import("../events/Event.js").default} event Event. */ handleTileChange_(event) { const tile = ( /** @type {import("../Tile.js").default} */ event.target ); const uid = getUid(tile); const tileState = tile.getState(); let type; if (tileState == TileState_default.LOADING) { this.tileLoadingKeys_[uid] = true; type = TileEventType_default.TILELOADSTART; } else if (uid in this.tileLoadingKeys_) { delete this.tileLoadingKeys_[uid]; type = tileState == TileState_default.ERROR ? TileEventType_default.TILELOADERROR : tileState == TileState_default.LOADED ? TileEventType_default.TILELOADEND : void 0; } if (type) { this.dispatchEvent(new TileSourceEvent(type, tile)); } } /** * @param {import("../proj/Projection.js").default} projection Projection. * @return {!import("../tilegrid/TileGrid.js").default} Tile grid. * @override */ getTileGridForProjection(projection) { const thisProj = this.getProjection(); if (this.tileGrid && (!thisProj || equivalent(thisProj, projection)) && !this.transformMatrix) { return this.tileGrid; } const projKey = getUid(projection); if (!(projKey in this.tileGridForProjection_)) { this.tileGridForProjection_[projKey] = getForProjection(projection); } return this.tileGridForProjection_[projKey]; } /** * Sets the tile grid to use when reprojecting the tiles to the given * projection instead of the default tile grid for the projection. * * This can be useful when the default tile grid cannot be created * (e.g. projection has no extent defined) or * for optimization reasons (custom tile size, resolutions, ...). * * @param {import("../proj.js").ProjectionLike} projection Projection. * @param {import("../tilegrid/TileGrid.js").default} tilegrid Tile grid to use for the projection. * @api */ setTileGridForProjection(projection, tilegrid) { const proj = get(projection); if (proj) { const projKey = getUid(proj); if (!(projKey in this.tileGridForProjection_)) { this.tileGridForProjection_[projKey] = tilegrid; } } } }; var DataTile_default3 = DataTileSource; // node_modules/@petamoriken/float16/src/_util/messages.mjs var THIS_IS_NOT_AN_OBJECT = "This is not an object"; var THIS_IS_NOT_A_FLOAT16ARRAY_OBJECT = "This is not a Float16Array object"; var THIS_CONSTRUCTOR_IS_NOT_A_SUBCLASS_OF_FLOAT16ARRAY = "This constructor is not a subclass of Float16Array"; var THE_CONSTRUCTOR_PROPERTY_VALUE_IS_NOT_AN_OBJECT = "The constructor property value is not an object"; var SPECIES_CONSTRUCTOR_DIDNT_RETURN_TYPEDARRAY_OBJECT = "Species constructor didn't return TypedArray object"; var DERIVED_CONSTRUCTOR_CREATED_TYPEDARRAY_OBJECT_WHICH_WAS_TOO_SMALL_LENGTH = "Derived constructor created TypedArray object which was too small length"; var ATTEMPTING_TO_ACCESS_DETACHED_ARRAYBUFFER = "Attempting to access detached ArrayBuffer"; var CANNOT_CONVERT_UNDEFINED_OR_NULL_TO_OBJECT = "Cannot convert undefined or null to object"; var CANNOT_MIX_BIGINT_AND_OTHER_TYPES = "Cannot mix BigInt and other types, use explicit conversions"; var ITERATOR_PROPERTY_IS_NOT_CALLABLE = "@@iterator property is not callable"; var REDUCE_OF_EMPTY_ARRAY_WITH_NO_INITIAL_VALUE = "Reduce of empty array with no initial value"; var THE_COMPARISON_FUNCTION_MUST_BE_EITHER_A_FUNCTION_OR_UNDEFINED = "The comparison function must be either a function or undefined"; var OFFSET_IS_OUT_OF_BOUNDS = "Offset is out of bounds"; // node_modules/@petamoriken/float16/src/_util/primordials.mjs function uncurryThis(target) { return (thisArg, ...args) => { return ReflectApply(target, thisArg, args); }; } function uncurryThisGetter(target, key) { return uncurryThis( ReflectGetOwnPropertyDescriptor( target, key ).get ); } var { apply: ReflectApply, construct: ReflectConstruct, defineProperty: ReflectDefineProperty, get: ReflectGet, getOwnPropertyDescriptor: ReflectGetOwnPropertyDescriptor, getPrototypeOf: ReflectGetPrototypeOf, has: ReflectHas, ownKeys: ReflectOwnKeys, set: ReflectSet, setPrototypeOf: ReflectSetPrototypeOf } = Reflect; var NativeProxy = Proxy; var { EPSILON, MAX_SAFE_INTEGER, isFinite: NumberIsFinite, isNaN: NumberIsNaN } = Number; var { iterator: SymbolIterator, species: SymbolSpecies, toStringTag: SymbolToStringTag, for: SymbolFor } = Symbol; var NativeObject = Object; var { create: ObjectCreate, defineProperty: ObjectDefineProperty, freeze: ObjectFreeze, is: ObjectIs } = NativeObject; var ObjectPrototype = NativeObject.prototype; var ObjectPrototype__lookupGetter__ = ( /** @type {any} */ ObjectPrototype.__lookupGetter__ ? uncurryThis( /** @type {any} */ ObjectPrototype.__lookupGetter__ ) : (object, key) => { if (object == null) { throw NativeTypeError( CANNOT_CONVERT_UNDEFINED_OR_NULL_TO_OBJECT ); } let target = NativeObject(object); do { const descriptor = ReflectGetOwnPropertyDescriptor(target, key); if (descriptor !== void 0) { if (ObjectHasOwn(descriptor, "get")) { return descriptor.get; } return; } } while ((target = ReflectGetPrototypeOf(target)) !== null); } ); var ObjectHasOwn = ( /** @type {any} */ NativeObject.hasOwn || uncurryThis(ObjectPrototype.hasOwnProperty) ); var NativeArray = Array; var ArrayIsArray = NativeArray.isArray; var ArrayPrototype = NativeArray.prototype; var ArrayPrototypeJoin = uncurryThis(ArrayPrototype.join); var ArrayPrototypePush = uncurryThis(ArrayPrototype.push); var ArrayPrototypeToLocaleString = uncurryThis( ArrayPrototype.toLocaleString ); var NativeArrayPrototypeSymbolIterator = ArrayPrototype[SymbolIterator]; var ArrayPrototypeSymbolIterator = uncurryThis(NativeArrayPrototypeSymbolIterator); var { abs: MathAbs, trunc: MathTrunc } = Math; var NativeArrayBuffer = ArrayBuffer; var ArrayBufferIsView = NativeArrayBuffer.isView; var ArrayBufferPrototype = NativeArrayBuffer.prototype; var ArrayBufferPrototypeSlice = uncurryThis(ArrayBufferPrototype.slice); var ArrayBufferPrototypeGetByteLength = uncurryThisGetter(ArrayBufferPrototype, "byteLength"); var NativeSharedArrayBuffer = typeof SharedArrayBuffer !== "undefined" ? SharedArrayBuffer : null; var SharedArrayBufferPrototypeGetByteLength = NativeSharedArrayBuffer && uncurryThisGetter(NativeSharedArrayBuffer.prototype, "byteLength"); var TypedArray = ReflectGetPrototypeOf(Uint8Array); var TypedArrayFrom = TypedArray.from; var TypedArrayPrototype = TypedArray.prototype; var NativeTypedArrayPrototypeSymbolIterator = TypedArrayPrototype[SymbolIterator]; var TypedArrayPrototypeKeys = uncurryThis(TypedArrayPrototype.keys); var TypedArrayPrototypeValues = uncurryThis( TypedArrayPrototype.values ); var TypedArrayPrototypeEntries = uncurryThis( TypedArrayPrototype.entries ); var TypedArrayPrototypeSet = uncurryThis(TypedArrayPrototype.set); var TypedArrayPrototypeReverse = uncurryThis( TypedArrayPrototype.reverse ); var TypedArrayPrototypeFill = uncurryThis(TypedArrayPrototype.fill); var TypedArrayPrototypeCopyWithin = uncurryThis( TypedArrayPrototype.copyWithin ); var TypedArrayPrototypeSort = uncurryThis(TypedArrayPrototype.sort); var TypedArrayPrototypeSlice = uncurryThis(TypedArrayPrototype.slice); var TypedArrayPrototypeSubarray = uncurryThis( TypedArrayPrototype.subarray ); var TypedArrayPrototypeGetBuffer = uncurryThisGetter( TypedArrayPrototype, "buffer" ); var TypedArrayPrototypeGetByteOffset = uncurryThisGetter( TypedArrayPrototype, "byteOffset" ); var TypedArrayPrototypeGetLength = uncurryThisGetter( TypedArrayPrototype, "length" ); var TypedArrayPrototypeGetSymbolToStringTag = uncurryThisGetter( TypedArrayPrototype, SymbolToStringTag ); var NativeUint8Array = Uint8Array; var NativeUint16Array = Uint16Array; var Uint16ArrayFrom = (...args) => { return ReflectApply(TypedArrayFrom, NativeUint16Array, args); }; var NativeUint32Array = Uint32Array; var NativeFloat32Array = Float32Array; var ArrayIteratorPrototype = ReflectGetPrototypeOf([][SymbolIterator]()); var ArrayIteratorPrototypeNext = uncurryThis(ArrayIteratorPrototype.next); var GeneratorPrototypeNext = uncurryThis((function* () { })().next); var IteratorPrototype = ReflectGetPrototypeOf(ArrayIteratorPrototype); var DataViewPrototype = DataView.prototype; var DataViewPrototypeGetUint16 = uncurryThis( DataViewPrototype.getUint16 ); var DataViewPrototypeSetUint16 = uncurryThis( DataViewPrototype.setUint16 ); var NativeTypeError = TypeError; var NativeRangeError = RangeError; var NativeWeakSet = WeakSet; var WeakSetPrototype = NativeWeakSet.prototype; var WeakSetPrototypeAdd = uncurryThis(WeakSetPrototype.add); var WeakSetPrototypeHas = uncurryThis(WeakSetPrototype.has); var NativeWeakMap = WeakMap; var WeakMapPrototype = NativeWeakMap.prototype; var WeakMapPrototypeGet = uncurryThis(WeakMapPrototype.get); var WeakMapPrototypeHas = uncurryThis(WeakMapPrototype.has); var WeakMapPrototypeSet = uncurryThis(WeakMapPrototype.set); // node_modules/@petamoriken/float16/src/_util/arrayIterator.mjs var arrayIterators = new NativeWeakMap(); var SafeIteratorPrototype = ObjectCreate(null, { next: { value: function next() { const arrayIterator = WeakMapPrototypeGet(arrayIterators, this); return ArrayIteratorPrototypeNext(arrayIterator); } }, [SymbolIterator]: { value: function values() { return this; } } }); function safeIfNeeded(array) { if (array[SymbolIterator] === NativeArrayPrototypeSymbolIterator && ArrayIteratorPrototype.next === ArrayIteratorPrototypeNext) { return array; } const safe = ObjectCreate(SafeIteratorPrototype); WeakMapPrototypeSet(arrayIterators, safe, ArrayPrototypeSymbolIterator(array)); return safe; } var generators = new NativeWeakMap(); var DummyArrayIteratorPrototype = ObjectCreate(IteratorPrototype, { next: { value: function next2() { const generator = WeakMapPrototypeGet(generators, this); return GeneratorPrototypeNext(generator); }, writable: true, configurable: true } }); for (const key of ReflectOwnKeys(ArrayIteratorPrototype)) { if (key === "next") { continue; } ObjectDefineProperty(DummyArrayIteratorPrototype, key, ReflectGetOwnPropertyDescriptor(ArrayIteratorPrototype, key)); } function wrap(generator) { const dummy = ObjectCreate(DummyArrayIteratorPrototype); WeakMapPrototypeSet(generators, dummy, generator); return dummy; } // node_modules/@petamoriken/float16/src/_util/is.mjs function isObject(value) { return value !== null && typeof value === "object" || typeof value === "function"; } function isObjectLike(value) { return value !== null && typeof value === "object"; } function isNativeTypedArray(value) { return TypedArrayPrototypeGetSymbolToStringTag(value) !== void 0; } function isNativeBigIntTypedArray(value) { const typedArrayName = TypedArrayPrototypeGetSymbolToStringTag(value); return typedArrayName === "BigInt64Array" || typedArrayName === "BigUint64Array"; } function isArrayBuffer(value) { try { if (ArrayIsArray(value)) { return false; } ArrayBufferPrototypeGetByteLength( /** @type {any} */ value ); return true; } catch (e) { return false; } } function isSharedArrayBuffer(value) { if (NativeSharedArrayBuffer === null) { return false; } try { SharedArrayBufferPrototypeGetByteLength( /** @type {any} */ value ); return true; } catch (e) { return false; } } function isAnyArrayBuffer(value) { return isArrayBuffer(value) || isSharedArrayBuffer(value); } function isOrdinaryArray(value) { if (!ArrayIsArray(value)) { return false; } return value[SymbolIterator] === NativeArrayPrototypeSymbolIterator && ArrayIteratorPrototype.next === ArrayIteratorPrototypeNext; } function isOrdinaryNativeTypedArray(value) { if (!isNativeTypedArray(value)) { return false; } return value[SymbolIterator] === NativeTypedArrayPrototypeSymbolIterator && ArrayIteratorPrototype.next === ArrayIteratorPrototypeNext; } function isCanonicalIntegerIndexString(value) { if (typeof value !== "string") { return false; } const number = +value; if (value !== number + "") { return false; } if (!NumberIsFinite(number)) { return false; } return number === MathTrunc(number); } // node_modules/@petamoriken/float16/src/_util/brand.mjs var brand = SymbolFor("__Float16Array__"); function hasFloat16ArrayBrand(target) { if (!isObjectLike(target)) { return false; } const prototype = ReflectGetPrototypeOf(target); if (!isObjectLike(prototype)) { return false; } const constructor = prototype.constructor; if (constructor === void 0) { return false; } if (!isObject(constructor)) { throw NativeTypeError(THE_CONSTRUCTOR_PROPERTY_VALUE_IS_NOT_AN_OBJECT); } return ReflectHas(constructor, brand); } // node_modules/@petamoriken/float16/src/_util/converter.mjs var INVERSE_OF_EPSILON = 1 / EPSILON; function roundTiesToEven(num) { return num + INVERSE_OF_EPSILON - INVERSE_OF_EPSILON; } var FLOAT16_MIN_VALUE = 6103515625e-14; var FLOAT16_MAX_VALUE = 65504; var FLOAT16_EPSILON = 9765625e-10; var FLOAT16_EPSILON_MULTIPLIED_BY_FLOAT16_MIN_VALUE = FLOAT16_EPSILON * FLOAT16_MIN_VALUE; var FLOAT16_EPSILON_DEVIDED_BY_EPSILON = FLOAT16_EPSILON * INVERSE_OF_EPSILON; function roundToFloat16(num) { const number = +num; if (!NumberIsFinite(number) || number === 0) { return number; } const sign = number > 0 ? 1 : -1; const absolute = MathAbs(number); if (absolute < FLOAT16_MIN_VALUE) { return sign * roundTiesToEven(absolute / FLOAT16_EPSILON_MULTIPLIED_BY_FLOAT16_MIN_VALUE) * FLOAT16_EPSILON_MULTIPLIED_BY_FLOAT16_MIN_VALUE; } const temp = (1 + FLOAT16_EPSILON_DEVIDED_BY_EPSILON) * absolute; const result = temp - (temp - absolute); if (result > FLOAT16_MAX_VALUE || NumberIsNaN(result)) { return sign * Infinity; } return sign * result; } var buffer2 = new NativeArrayBuffer(4); var floatView = new NativeFloat32Array(buffer2); var uint32View = new NativeUint32Array(buffer2); var baseTable = new NativeUint16Array(512); var shiftTable = new NativeUint8Array(512); for (let i = 0; i < 256; ++i) { const e = i - 127; if (e < -24) { baseTable[i] = 0; baseTable[i | 256] = 32768; shiftTable[i] = 24; shiftTable[i | 256] = 24; } else if (e < -14) { baseTable[i] = 1024 >> -e - 14; baseTable[i | 256] = 1024 >> -e - 14 | 32768; shiftTable[i] = -e - 1; shiftTable[i | 256] = -e - 1; } else if (e <= 15) { baseTable[i] = e + 15 << 10; baseTable[i | 256] = e + 15 << 10 | 32768; shiftTable[i] = 13; shiftTable[i | 256] = 13; } else if (e < 128) { baseTable[i] = 31744; baseTable[i | 256] = 64512; shiftTable[i] = 24; shiftTable[i | 256] = 24; } else { baseTable[i] = 31744; baseTable[i | 256] = 64512; shiftTable[i] = 13; shiftTable[i | 256] = 13; } } function roundToFloat16Bits(num) { floatView[0] = roundToFloat16(num); const f = uint32View[0]; const e = f >> 23 & 511; return baseTable[e] + ((f & 8388607) >> shiftTable[e]); } var mantissaTable = new NativeUint32Array(2048); for (let i = 1; i < 1024; ++i) { let m = i << 13; let e = 0; while ((m & 8388608) === 0) { m <<= 1; e -= 8388608; } m &= ~8388608; e += 947912704; mantissaTable[i] = m | e; } for (let i = 1024; i < 2048; ++i) { mantissaTable[i] = 939524096 + (i - 1024 << 13); } var exponentTable = new NativeUint32Array(64); for (let i = 1; i < 31; ++i) { exponentTable[i] = i << 23; } exponentTable[31] = 1199570944; exponentTable[32] = 2147483648; for (let i = 33; i < 63; ++i) { exponentTable[i] = 2147483648 + (i - 32 << 23); } exponentTable[63] = 3347054592; var offsetTable = new NativeUint16Array(64); for (let i = 1; i < 64; ++i) { if (i !== 32) { offsetTable[i] = 1024; } } function convertToNumber(float16bits) { const i = float16bits >> 10; uint32View[0] = mantissaTable[offsetTable[i] + (float16bits & 1023)] + exponentTable[i]; return floatView[0]; } // node_modules/@petamoriken/float16/src/_util/spec.mjs function ToIntegerOrInfinity(target) { const number = +target; if (NumberIsNaN(number) || number === 0) { return 0; } return MathTrunc(number); } function ToLength(target) { const length = ToIntegerOrInfinity(target); if (length < 0) { return 0; } return length < MAX_SAFE_INTEGER ? length : MAX_SAFE_INTEGER; } function SpeciesConstructor(target, defaultConstructor) { if (!isObject(target)) { throw NativeTypeError(THIS_IS_NOT_AN_OBJECT); } const constructor = target.constructor; if (constructor === void 0) { return defaultConstructor; } if (!isObject(constructor)) { throw NativeTypeError(THE_CONSTRUCTOR_PROPERTY_VALUE_IS_NOT_AN_OBJECT); } const species = constructor[SymbolSpecies]; if (species == null) { return defaultConstructor; } return species; } function IsDetachedBuffer(buffer3) { if (isSharedArrayBuffer(buffer3)) { return false; } try { ArrayBufferPrototypeSlice(buffer3, 0, 0); return false; } catch (e) { } return true; } function defaultCompare(x, y) { const isXNaN = NumberIsNaN(x); const isYNaN = NumberIsNaN(y); if (isXNaN && isYNaN) { return 0; } if (isXNaN) { return 1; } if (isYNaN) { return -1; } if (x < y) { return -1; } if (x > y) { return 1; } if (x === 0 && y === 0) { const isXPlusZero = ObjectIs(x, 0); const isYPlusZero = ObjectIs(y, 0); if (!isXPlusZero && isYPlusZero) { return -1; } if (isXPlusZero && !isYPlusZero) { return 1; } } return 0; } // node_modules/@petamoriken/float16/src/Float16Array.mjs var BYTES_PER_ELEMENT = 2; var float16bitsArrays = new NativeWeakMap(); function isFloat16Array(target) { return WeakMapPrototypeHas(float16bitsArrays, target) || !ArrayBufferIsView(target) && hasFloat16ArrayBrand(target); } function assertFloat16Array(target) { if (!isFloat16Array(target)) { throw NativeTypeError(THIS_IS_NOT_A_FLOAT16ARRAY_OBJECT); } } function assertSpeciesTypedArray(target, count) { const isTargetFloat16Array = isFloat16Array(target); const isTargetTypedArray = isNativeTypedArray(target); if (!isTargetFloat16Array && !isTargetTypedArray) { throw NativeTypeError(SPECIES_CONSTRUCTOR_DIDNT_RETURN_TYPEDARRAY_OBJECT); } if (typeof count === "number") { let length; if (isTargetFloat16Array) { const float16bitsArray = getFloat16BitsArray(target); length = TypedArrayPrototypeGetLength(float16bitsArray); } else { length = TypedArrayPrototypeGetLength(target); } if (length < count) { throw NativeTypeError( DERIVED_CONSTRUCTOR_CREATED_TYPEDARRAY_OBJECT_WHICH_WAS_TOO_SMALL_LENGTH ); } } if (isNativeBigIntTypedArray(target)) { throw NativeTypeError(CANNOT_MIX_BIGINT_AND_OTHER_TYPES); } } function getFloat16BitsArray(float16) { const float16bitsArray = WeakMapPrototypeGet(float16bitsArrays, float16); if (float16bitsArray !== void 0) { const buffer4 = TypedArrayPrototypeGetBuffer(float16bitsArray); if (IsDetachedBuffer(buffer4)) { throw NativeTypeError(ATTEMPTING_TO_ACCESS_DETACHED_ARRAYBUFFER); } return float16bitsArray; } const buffer3 = ( /** @type {any} */ float16.buffer ); if (IsDetachedBuffer(buffer3)) { throw NativeTypeError(ATTEMPTING_TO_ACCESS_DETACHED_ARRAYBUFFER); } const cloned = ReflectConstruct(Float16Array, [ buffer3, /** @type {any} */ float16.byteOffset, /** @type {any} */ float16.length ], float16.constructor); return WeakMapPrototypeGet(float16bitsArrays, cloned); } function copyToArray(float16bitsArray) { const length = TypedArrayPrototypeGetLength(float16bitsArray); const array = []; for (let i = 0; i < length; ++i) { array[i] = convertToNumber(float16bitsArray[i]); } return array; } var TypedArrayPrototypeGetters = new NativeWeakSet(); for (const key of ReflectOwnKeys(TypedArrayPrototype)) { if (key === SymbolToStringTag) { continue; } const descriptor = ReflectGetOwnPropertyDescriptor(TypedArrayPrototype, key); if (ObjectHasOwn(descriptor, "get") && typeof descriptor.get === "function") { WeakSetPrototypeAdd(TypedArrayPrototypeGetters, descriptor.get); } } var handler = ObjectFreeze( /** @type {ProxyHandler} */ { get(target, key, receiver) { if (isCanonicalIntegerIndexString(key) && ObjectHasOwn(target, key)) { return convertToNumber(ReflectGet(target, key)); } if (WeakSetPrototypeHas(TypedArrayPrototypeGetters, ObjectPrototype__lookupGetter__(target, key))) { return ReflectGet(target, key); } return ReflectGet(target, key, receiver); }, set(target, key, value, receiver) { if (isCanonicalIntegerIndexString(key) && ObjectHasOwn(target, key)) { return ReflectSet(target, key, roundToFloat16Bits(value)); } return ReflectSet(target, key, value, receiver); }, getOwnPropertyDescriptor(target, key) { if (isCanonicalIntegerIndexString(key) && ObjectHasOwn(target, key)) { const descriptor = ReflectGetOwnPropertyDescriptor(target, key); descriptor.value = convertToNumber(descriptor.value); return descriptor; } return ReflectGetOwnPropertyDescriptor(target, key); }, defineProperty(target, key, descriptor) { if (isCanonicalIntegerIndexString(key) && ObjectHasOwn(target, key) && ObjectHasOwn(descriptor, "value")) { descriptor.value = roundToFloat16Bits(descriptor.value); return ReflectDefineProperty(target, key, descriptor); } return ReflectDefineProperty(target, key, descriptor); } } ); var Float16Array = class _Float16Array { /** @see https://tc39.es/ecma262/#sec-typedarray */ constructor(input, _byteOffset, _length) { let float16bitsArray; if (isFloat16Array(input)) { float16bitsArray = ReflectConstruct(NativeUint16Array, [getFloat16BitsArray(input)], new.target); } else if (isObject(input) && !isAnyArrayBuffer(input)) { let list; let length; if (isNativeTypedArray(input)) { list = input; length = TypedArrayPrototypeGetLength(input); const buffer3 = TypedArrayPrototypeGetBuffer(input); if (IsDetachedBuffer(buffer3)) { throw NativeTypeError(ATTEMPTING_TO_ACCESS_DETACHED_ARRAYBUFFER); } if (isNativeBigIntTypedArray(input)) { throw NativeTypeError(CANNOT_MIX_BIGINT_AND_OTHER_TYPES); } const data = new NativeArrayBuffer( length * BYTES_PER_ELEMENT ); float16bitsArray = ReflectConstruct(NativeUint16Array, [data], new.target); } else { const iterator = input[SymbolIterator]; if (iterator != null && typeof iterator !== "function") { throw NativeTypeError(ITERATOR_PROPERTY_IS_NOT_CALLABLE); } if (iterator != null) { if (isOrdinaryArray(input)) { list = input; length = input.length; } else { list = [.../** @type {Iterable} */ input]; length = list.length; } } else { list = /** @type {ArrayLike} */ input; length = ToLength(list.length); } float16bitsArray = ReflectConstruct(NativeUint16Array, [length], new.target); } for (let i = 0; i < length; ++i) { float16bitsArray[i] = roundToFloat16Bits(list[i]); } } else { float16bitsArray = ReflectConstruct(NativeUint16Array, arguments, new.target); } const proxy = ( /** @type {any} */ new NativeProxy(float16bitsArray, handler) ); WeakMapPrototypeSet(float16bitsArrays, proxy, float16bitsArray); return proxy; } /** * limitation: `Object.getOwnPropertyNames(Float16Array)` or `Reflect.ownKeys(Float16Array)` include this key * @see https://tc39.es/ecma262/#sec-%typedarray%.from */ static from(src, ...opts) { const Constructor = this; if (!ReflectHas(Constructor, brand)) { throw NativeTypeError( THIS_CONSTRUCTOR_IS_NOT_A_SUBCLASS_OF_FLOAT16ARRAY ); } if (Constructor === _Float16Array) { if (isFloat16Array(src) && opts.length === 0) { const float16bitsArray = getFloat16BitsArray(src); const uint16 = new NativeUint16Array( TypedArrayPrototypeGetBuffer(float16bitsArray), TypedArrayPrototypeGetByteOffset(float16bitsArray), TypedArrayPrototypeGetLength(float16bitsArray) ); return new _Float16Array( TypedArrayPrototypeGetBuffer(TypedArrayPrototypeSlice(uint16)) ); } if (opts.length === 0) { return new _Float16Array( TypedArrayPrototypeGetBuffer( Uint16ArrayFrom(src, roundToFloat16Bits) ) ); } const mapFunc = opts[0]; const thisArg = opts[1]; return new _Float16Array( TypedArrayPrototypeGetBuffer( Uint16ArrayFrom(src, function(val, ...args) { return roundToFloat16Bits( ReflectApply(mapFunc, this, [val, ...safeIfNeeded(args)]) ); }, thisArg) ) ); } let list; let length; const iterator = src[SymbolIterator]; if (iterator != null && typeof iterator !== "function") { throw NativeTypeError(ITERATOR_PROPERTY_IS_NOT_CALLABLE); } if (iterator != null) { if (isOrdinaryArray(src)) { list = src; length = src.length; } else if (isOrdinaryNativeTypedArray(src)) { list = src; length = TypedArrayPrototypeGetLength(src); } else { list = [...src]; length = list.length; } } else { if (src == null) { throw NativeTypeError( CANNOT_CONVERT_UNDEFINED_OR_NULL_TO_OBJECT ); } list = NativeObject(src); length = ToLength(list.length); } const array = new Constructor(length); if (opts.length === 0) { for (let i = 0; i < length; ++i) { array[i] = /** @type {number} */ list[i]; } } else { const mapFunc = opts[0]; const thisArg = opts[1]; for (let i = 0; i < length; ++i) { array[i] = ReflectApply(mapFunc, thisArg, [list[i], i]); } } return array; } /** * limitation: `Object.getOwnPropertyNames(Float16Array)` or `Reflect.ownKeys(Float16Array)` include this key * @see https://tc39.es/ecma262/#sec-%typedarray%.of */ static of(...items) { const Constructor = this; if (!ReflectHas(Constructor, brand)) { throw NativeTypeError( THIS_CONSTRUCTOR_IS_NOT_A_SUBCLASS_OF_FLOAT16ARRAY ); } const length = items.length; if (Constructor === _Float16Array) { const proxy = new _Float16Array(length); const float16bitsArray = getFloat16BitsArray(proxy); for (let i = 0; i < length; ++i) { float16bitsArray[i] = roundToFloat16Bits(items[i]); } return proxy; } const array = new Constructor(length); for (let i = 0; i < length; ++i) { array[i] = items[i]; } return array; } /** @see https://tc39.es/ecma262/#sec-%typedarray%.prototype.keys */ keys() { assertFloat16Array(this); const float16bitsArray = getFloat16BitsArray(this); return TypedArrayPrototypeKeys(float16bitsArray); } /** * limitation: returns a object whose prototype is not `%ArrayIteratorPrototype%` * @see https://tc39.es/ecma262/#sec-%typedarray%.prototype.values */ values() { assertFloat16Array(this); const float16bitsArray = getFloat16BitsArray(this); return wrap((function* () { for (const val of TypedArrayPrototypeValues(float16bitsArray)) { yield convertToNumber(val); } })()); } /** * limitation: returns a object whose prototype is not `%ArrayIteratorPrototype%` * @see https://tc39.es/ecma262/#sec-%typedarray%.prototype.entries */ entries() { assertFloat16Array(this); const float16bitsArray = getFloat16BitsArray(this); return wrap((function* () { for (const [i, val] of TypedArrayPrototypeEntries(float16bitsArray)) { yield ( /** @type {[number, number]} */ [i, convertToNumber(val)] ); } })()); } /** @see https://tc39.es/ecma262/#sec-%typedarray%.prototype.at */ at(index) { assertFloat16Array(this); const float16bitsArray = getFloat16BitsArray(this); const length = TypedArrayPrototypeGetLength(float16bitsArray); const relativeIndex = ToIntegerOrInfinity(index); const k = relativeIndex >= 0 ? relativeIndex : length + relativeIndex; if (k < 0 || k >= length) { return; } return convertToNumber(float16bitsArray[k]); } /** @see https://tc39.es/proposal-change-array-by-copy/#sec-%typedarray%.prototype.with */ with(index, value) { assertFloat16Array(this); const float16bitsArray = getFloat16BitsArray(this); const length = TypedArrayPrototypeGetLength(float16bitsArray); const relativeIndex = ToIntegerOrInfinity(index); const k = relativeIndex >= 0 ? relativeIndex : length + relativeIndex; const number = +value; if (k < 0 || k >= length) { throw NativeRangeError(OFFSET_IS_OUT_OF_BOUNDS); } const uint16 = new NativeUint16Array( TypedArrayPrototypeGetBuffer(float16bitsArray), TypedArrayPrototypeGetByteOffset(float16bitsArray), TypedArrayPrototypeGetLength(float16bitsArray) ); const cloned = new _Float16Array( TypedArrayPrototypeGetBuffer( TypedArrayPrototypeSlice(uint16) ) ); const array = getFloat16BitsArray(cloned); array[k] = roundToFloat16Bits(number); return cloned; } /** @see https://tc39.es/ecma262/#sec-%typedarray%.prototype.map */ map(callback, ...opts) { assertFloat16Array(this); const float16bitsArray = getFloat16BitsArray(this); const length = TypedArrayPrototypeGetLength(float16bitsArray); const thisArg = opts[0]; const Constructor = SpeciesConstructor(float16bitsArray, _Float16Array); if (Constructor === _Float16Array) { const proxy = new _Float16Array(length); const array2 = getFloat16BitsArray(proxy); for (let i = 0; i < length; ++i) { const val = convertToNumber(float16bitsArray[i]); array2[i] = roundToFloat16Bits( ReflectApply(callback, thisArg, [val, i, this]) ); } return proxy; } const array = new Constructor(length); assertSpeciesTypedArray(array, length); for (let i = 0; i < length; ++i) { const val = convertToNumber(float16bitsArray[i]); array[i] = ReflectApply(callback, thisArg, [val, i, this]); } return ( /** @type {any} */ array ); } /** @see https://tc39.es/ecma262/#sec-%typedarray%.prototype.filter */ filter(callback, ...opts) { assertFloat16Array(this); const float16bitsArray = getFloat16BitsArray(this); const length = TypedArrayPrototypeGetLength(float16bitsArray); const thisArg = opts[0]; const kept = []; for (let i = 0; i < length; ++i) { const val = convertToNumber(float16bitsArray[i]); if (ReflectApply(callback, thisArg, [val, i, this])) { ArrayPrototypePush(kept, val); } } const Constructor = SpeciesConstructor(float16bitsArray, _Float16Array); const array = new Constructor(kept); assertSpeciesTypedArray(array); return ( /** @type {any} */ array ); } /** @see https://tc39.es/ecma262/#sec-%typedarray%.prototype.reduce */ reduce(callback, ...opts) { assertFloat16Array(this); const float16bitsArray = getFloat16BitsArray(this); const length = TypedArrayPrototypeGetLength(float16bitsArray); if (length === 0 && opts.length === 0) { throw NativeTypeError(REDUCE_OF_EMPTY_ARRAY_WITH_NO_INITIAL_VALUE); } let accumulator, start; if (opts.length === 0) { accumulator = convertToNumber(float16bitsArray[0]); start = 1; } else { accumulator = opts[0]; start = 0; } for (let i = start; i < length; ++i) { accumulator = callback( accumulator, convertToNumber(float16bitsArray[i]), i, this ); } return accumulator; } /** @see https://tc39.es/ecma262/#sec-%typedarray%.prototype.reduceright */ reduceRight(callback, ...opts) { assertFloat16Array(this); const float16bitsArray = getFloat16BitsArray(this); const length = TypedArrayPrototypeGetLength(float16bitsArray); if (length === 0 && opts.length === 0) { throw NativeTypeError(REDUCE_OF_EMPTY_ARRAY_WITH_NO_INITIAL_VALUE); } let accumulator, start; if (opts.length === 0) { accumulator = convertToNumber(float16bitsArray[length - 1]); start = length - 2; } else { accumulator = opts[0]; start = length - 1; } for (let i = start; i >= 0; --i) { accumulator = callback( accumulator, convertToNumber(float16bitsArray[i]), i, this ); } return accumulator; } /** @see https://tc39.es/ecma262/#sec-%typedarray%.prototype.foreach */ forEach(callback, ...opts) { assertFloat16Array(this); const float16bitsArray = getFloat16BitsArray(this); const length = TypedArrayPrototypeGetLength(float16bitsArray); const thisArg = opts[0]; for (let i = 0; i < length; ++i) { ReflectApply(callback, thisArg, [ convertToNumber(float16bitsArray[i]), i, this ]); } } /** @see https://tc39.es/ecma262/#sec-%typedarray%.prototype.find */ find(callback, ...opts) { assertFloat16Array(this); const float16bitsArray = getFloat16BitsArray(this); const length = TypedArrayPrototypeGetLength(float16bitsArray); const thisArg = opts[0]; for (let i = 0; i < length; ++i) { const value = convertToNumber(float16bitsArray[i]); if (ReflectApply(callback, thisArg, [value, i, this])) { return value; } } } /** @see https://tc39.es/ecma262/#sec-%typedarray%.prototype.findindex */ findIndex(callback, ...opts) { assertFloat16Array(this); const float16bitsArray = getFloat16BitsArray(this); const length = TypedArrayPrototypeGetLength(float16bitsArray); const thisArg = opts[0]; for (let i = 0; i < length; ++i) { const value = convertToNumber(float16bitsArray[i]); if (ReflectApply(callback, thisArg, [value, i, this])) { return i; } } return -1; } /** @see https://tc39.es/proposal-array-find-from-last/index.html#sec-%typedarray%.prototype.findlast */ findLast(callback, ...opts) { assertFloat16Array(this); const float16bitsArray = getFloat16BitsArray(this); const length = TypedArrayPrototypeGetLength(float16bitsArray); const thisArg = opts[0]; for (let i = length - 1; i >= 0; --i) { const value = convertToNumber(float16bitsArray[i]); if (ReflectApply(callback, thisArg, [value, i, this])) { return value; } } } /** @see https://tc39.es/proposal-array-find-from-last/index.html#sec-%typedarray%.prototype.findlastindex */ findLastIndex(callback, ...opts) { assertFloat16Array(this); const float16bitsArray = getFloat16BitsArray(this); const length = TypedArrayPrototypeGetLength(float16bitsArray); const thisArg = opts[0]; for (let i = length - 1; i >= 0; --i) { const value = convertToNumber(float16bitsArray[i]); if (ReflectApply(callback, thisArg, [value, i, this])) { return i; } } return -1; } /** @see https://tc39.es/ecma262/#sec-%typedarray%.prototype.every */ every(callback, ...opts) { assertFloat16Array(this); const float16bitsArray = getFloat16BitsArray(this); const length = TypedArrayPrototypeGetLength(float16bitsArray); const thisArg = opts[0]; for (let i = 0; i < length; ++i) { if (!ReflectApply(callback, thisArg, [ convertToNumber(float16bitsArray[i]), i, this ])) { return false; } } return true; } /** @see https://tc39.es/ecma262/#sec-%typedarray%.prototype.some */ some(callback, ...opts) { assertFloat16Array(this); const float16bitsArray = getFloat16BitsArray(this); const length = TypedArrayPrototypeGetLength(float16bitsArray); const thisArg = opts[0]; for (let i = 0; i < length; ++i) { if (ReflectApply(callback, thisArg, [ convertToNumber(float16bitsArray[i]), i, this ])) { return true; } } return false; } /** @see https://tc39.es/ecma262/#sec-%typedarray%.prototype.set */ set(input, ...opts) { assertFloat16Array(this); const float16bitsArray = getFloat16BitsArray(this); const targetOffset = ToIntegerOrInfinity(opts[0]); if (targetOffset < 0) { throw NativeRangeError(OFFSET_IS_OUT_OF_BOUNDS); } if (input == null) { throw NativeTypeError( CANNOT_CONVERT_UNDEFINED_OR_NULL_TO_OBJECT ); } if (isNativeBigIntTypedArray(input)) { throw NativeTypeError( CANNOT_MIX_BIGINT_AND_OTHER_TYPES ); } if (isFloat16Array(input)) { return TypedArrayPrototypeSet( getFloat16BitsArray(this), getFloat16BitsArray(input), targetOffset ); } if (isNativeTypedArray(input)) { const buffer3 = TypedArrayPrototypeGetBuffer(input); if (IsDetachedBuffer(buffer3)) { throw NativeTypeError(ATTEMPTING_TO_ACCESS_DETACHED_ARRAYBUFFER); } } const targetLength = TypedArrayPrototypeGetLength(float16bitsArray); const src = NativeObject(input); const srcLength = ToLength(src.length); if (targetOffset === Infinity || srcLength + targetOffset > targetLength) { throw NativeRangeError(OFFSET_IS_OUT_OF_BOUNDS); } for (let i = 0; i < srcLength; ++i) { float16bitsArray[i + targetOffset] = roundToFloat16Bits(src[i]); } } /** @see https://tc39.es/ecma262/#sec-%typedarray%.prototype.reverse */ reverse() { assertFloat16Array(this); const float16bitsArray = getFloat16BitsArray(this); TypedArrayPrototypeReverse(float16bitsArray); return this; } /** @see https://tc39.es/proposal-change-array-by-copy/#sec-%typedarray%.prototype.toReversed */ toReversed() { assertFloat16Array(this); const float16bitsArray = getFloat16BitsArray(this); const uint16 = new NativeUint16Array( TypedArrayPrototypeGetBuffer(float16bitsArray), TypedArrayPrototypeGetByteOffset(float16bitsArray), TypedArrayPrototypeGetLength(float16bitsArray) ); const cloned = new _Float16Array( TypedArrayPrototypeGetBuffer( TypedArrayPrototypeSlice(uint16) ) ); const clonedFloat16bitsArray = getFloat16BitsArray(cloned); TypedArrayPrototypeReverse(clonedFloat16bitsArray); return cloned; } /** @see https://tc39.es/ecma262/#sec-%typedarray%.prototype.fill */ fill(value, ...opts) { assertFloat16Array(this); const float16bitsArray = getFloat16BitsArray(this); TypedArrayPrototypeFill( float16bitsArray, roundToFloat16Bits(value), ...safeIfNeeded(opts) ); return this; } /** @see https://tc39.es/ecma262/#sec-%typedarray%.prototype.copywithin */ copyWithin(target, start, ...opts) { assertFloat16Array(this); const float16bitsArray = getFloat16BitsArray(this); TypedArrayPrototypeCopyWithin(float16bitsArray, target, start, ...safeIfNeeded(opts)); return this; } /** @see https://tc39.es/ecma262/#sec-%typedarray%.prototype.sort */ sort(compareFn) { assertFloat16Array(this); const float16bitsArray = getFloat16BitsArray(this); const sortCompare = compareFn !== void 0 ? compareFn : defaultCompare; TypedArrayPrototypeSort(float16bitsArray, (x, y) => { return sortCompare(convertToNumber(x), convertToNumber(y)); }); return this; } /** @see https://tc39.es/proposal-change-array-by-copy/#sec-%typedarray%.prototype.toSorted */ toSorted(compareFn) { assertFloat16Array(this); const float16bitsArray = getFloat16BitsArray(this); if (compareFn !== void 0 && typeof compareFn !== "function") { throw new NativeTypeError(THE_COMPARISON_FUNCTION_MUST_BE_EITHER_A_FUNCTION_OR_UNDEFINED); } const sortCompare = compareFn !== void 0 ? compareFn : defaultCompare; const uint16 = new NativeUint16Array( TypedArrayPrototypeGetBuffer(float16bitsArray), TypedArrayPrototypeGetByteOffset(float16bitsArray), TypedArrayPrototypeGetLength(float16bitsArray) ); const cloned = new _Float16Array( TypedArrayPrototypeGetBuffer( TypedArrayPrototypeSlice(uint16) ) ); const clonedFloat16bitsArray = getFloat16BitsArray(cloned); TypedArrayPrototypeSort(clonedFloat16bitsArray, (x, y) => { return sortCompare(convertToNumber(x), convertToNumber(y)); }); return cloned; } /** @see https://tc39.es/ecma262/#sec-%typedarray%.prototype.slice */ slice(start, end) { assertFloat16Array(this); const float16bitsArray = getFloat16BitsArray(this); const Constructor = SpeciesConstructor(float16bitsArray, _Float16Array); if (Constructor === _Float16Array) { const uint16 = new NativeUint16Array( TypedArrayPrototypeGetBuffer(float16bitsArray), TypedArrayPrototypeGetByteOffset(float16bitsArray), TypedArrayPrototypeGetLength(float16bitsArray) ); return new _Float16Array( TypedArrayPrototypeGetBuffer( TypedArrayPrototypeSlice(uint16, start, end) ) ); } const length = TypedArrayPrototypeGetLength(float16bitsArray); const relativeStart = ToIntegerOrInfinity(start); const relativeEnd = end === void 0 ? length : ToIntegerOrInfinity(end); let k; if (relativeStart === -Infinity) { k = 0; } else if (relativeStart < 0) { k = length + relativeStart > 0 ? length + relativeStart : 0; } else { k = length < relativeStart ? length : relativeStart; } let final; if (relativeEnd === -Infinity) { final = 0; } else if (relativeEnd < 0) { final = length + relativeEnd > 0 ? length + relativeEnd : 0; } else { final = length < relativeEnd ? length : relativeEnd; } const count = final - k > 0 ? final - k : 0; const array = new Constructor(count); assertSpeciesTypedArray(array, count); if (count === 0) { return array; } const buffer3 = TypedArrayPrototypeGetBuffer(float16bitsArray); if (IsDetachedBuffer(buffer3)) { throw NativeTypeError(ATTEMPTING_TO_ACCESS_DETACHED_ARRAYBUFFER); } let n = 0; while (k < final) { array[n] = convertToNumber(float16bitsArray[k]); ++k; ++n; } return ( /** @type {any} */ array ); } /** @see https://tc39.es/ecma262/#sec-%typedarray%.prototype.subarray */ subarray(begin, end) { assertFloat16Array(this); const float16bitsArray = getFloat16BitsArray(this); const Constructor = SpeciesConstructor(float16bitsArray, _Float16Array); const uint16 = new NativeUint16Array( TypedArrayPrototypeGetBuffer(float16bitsArray), TypedArrayPrototypeGetByteOffset(float16bitsArray), TypedArrayPrototypeGetLength(float16bitsArray) ); const uint16Subarray = TypedArrayPrototypeSubarray(uint16, begin, end); const array = new Constructor( TypedArrayPrototypeGetBuffer(uint16Subarray), TypedArrayPrototypeGetByteOffset(uint16Subarray), TypedArrayPrototypeGetLength(uint16Subarray) ); assertSpeciesTypedArray(array); return ( /** @type {any} */ array ); } /** @see https://tc39.es/ecma262/#sec-%typedarray%.prototype.indexof */ indexOf(element, ...opts) { assertFloat16Array(this); const float16bitsArray = getFloat16BitsArray(this); const length = TypedArrayPrototypeGetLength(float16bitsArray); let from = ToIntegerOrInfinity(opts[0]); if (from === Infinity) { return -1; } if (from < 0) { from += length; if (from < 0) { from = 0; } } for (let i = from; i < length; ++i) { if (ObjectHasOwn(float16bitsArray, i) && convertToNumber(float16bitsArray[i]) === element) { return i; } } return -1; } /** @see https://tc39.es/ecma262/#sec-%typedarray%.prototype.lastindexof */ lastIndexOf(element, ...opts) { assertFloat16Array(this); const float16bitsArray = getFloat16BitsArray(this); const length = TypedArrayPrototypeGetLength(float16bitsArray); let from = opts.length >= 1 ? ToIntegerOrInfinity(opts[0]) : length - 1; if (from === -Infinity) { return -1; } if (from >= 0) { from = from < length - 1 ? from : length - 1; } else { from += length; } for (let i = from; i >= 0; --i) { if (ObjectHasOwn(float16bitsArray, i) && convertToNumber(float16bitsArray[i]) === element) { return i; } } return -1; } /** @see https://tc39.es/ecma262/#sec-%typedarray%.prototype.includes */ includes(element, ...opts) { assertFloat16Array(this); const float16bitsArray = getFloat16BitsArray(this); const length = TypedArrayPrototypeGetLength(float16bitsArray); let from = ToIntegerOrInfinity(opts[0]); if (from === Infinity) { return false; } if (from < 0) { from += length; if (from < 0) { from = 0; } } const isNaN2 = NumberIsNaN(element); for (let i = from; i < length; ++i) { const value = convertToNumber(float16bitsArray[i]); if (isNaN2 && NumberIsNaN(value)) { return true; } if (value === element) { return true; } } return false; } /** @see https://tc39.es/ecma262/#sec-%typedarray%.prototype.join */ join(separator) { assertFloat16Array(this); const float16bitsArray = getFloat16BitsArray(this); const array = copyToArray(float16bitsArray); return ArrayPrototypeJoin(array, separator); } /** @see https://tc39.es/ecma262/#sec-%typedarray%.prototype.tolocalestring */ toLocaleString(...opts) { assertFloat16Array(this); const float16bitsArray = getFloat16BitsArray(this); const array = copyToArray(float16bitsArray); return ArrayPrototypeToLocaleString(array, ...safeIfNeeded(opts)); } /** @see https://tc39.es/ecma262/#sec-get-%typedarray%.prototype-@@tostringtag */ get [SymbolToStringTag]() { if (isFloat16Array(this)) { return ( /** @type {any} */ "Float16Array" ); } } }; ObjectDefineProperty(Float16Array, "BYTES_PER_ELEMENT", { value: BYTES_PER_ELEMENT }); ObjectDefineProperty(Float16Array, brand, {}); ReflectSetPrototypeOf(Float16Array, TypedArray); var Float16ArrayPrototype = Float16Array.prototype; ObjectDefineProperty(Float16ArrayPrototype, "BYTES_PER_ELEMENT", { value: BYTES_PER_ELEMENT }); ObjectDefineProperty(Float16ArrayPrototype, SymbolIterator, { value: Float16ArrayPrototype.values, writable: true, configurable: true }); ReflectSetPrototypeOf(Float16ArrayPrototype, TypedArrayPrototype); // node_modules/@petamoriken/float16/src/DataView.mjs function getFloat16(dataView, byteOffset, ...opts) { return convertToNumber( DataViewPrototypeGetUint16(dataView, byteOffset, ...safeIfNeeded(opts)) ); } // node_modules/geotiff/dist-module/geotiffimage.js var import_get_attribute = __toESM(require_get_attribute(), 1); var import_find_tags_by_name = __toESM(require_find_tags_by_name(), 1); // node_modules/geotiff/dist-module/rgb.js function fromWhiteIsZero(raster, max) { const { width, height } = raster; const rgbRaster = new Uint8Array(width * height * 3); let value; for (let i = 0, j = 0; i < raster.length; ++i, j += 3) { value = 256 - raster[i] / max * 256; rgbRaster[j] = value; rgbRaster[j + 1] = value; rgbRaster[j + 2] = value; } return rgbRaster; } function fromBlackIsZero(raster, max) { const { width, height } = raster; const rgbRaster = new Uint8Array(width * height * 3); let value; for (let i = 0, j = 0; i < raster.length; ++i, j += 3) { value = raster[i] / max * 256; rgbRaster[j] = value; rgbRaster[j + 1] = value; rgbRaster[j + 2] = value; } return rgbRaster; } function fromPalette(raster, colorMap) { const { width, height } = raster; const rgbRaster = new Uint8Array(width * height * 3); const greenOffset = colorMap.length / 3; const blueOffset = colorMap.length / 3 * 2; for (let i = 0, j = 0; i < raster.length; ++i, j += 3) { const mapIndex = raster[i]; rgbRaster[j] = colorMap[mapIndex] / 65536 * 256; rgbRaster[j + 1] = colorMap[mapIndex + greenOffset] / 65536 * 256; rgbRaster[j + 2] = colorMap[mapIndex + blueOffset] / 65536 * 256; } return rgbRaster; } function fromCMYK(cmykRaster) { const { width, height } = cmykRaster; const rgbRaster = new Uint8Array(width * height * 3); for (let i = 0, j = 0; i < cmykRaster.length; i += 4, j += 3) { const c = cmykRaster[i]; const m = cmykRaster[i + 1]; const y = cmykRaster[i + 2]; const k = cmykRaster[i + 3]; rgbRaster[j] = 255 * ((255 - c) / 256) * ((255 - k) / 256); rgbRaster[j + 1] = 255 * ((255 - m) / 256) * ((255 - k) / 256); rgbRaster[j + 2] = 255 * ((255 - y) / 256) * ((255 - k) / 256); } return rgbRaster; } function fromYCbCr(yCbCrRaster) { const { width, height } = yCbCrRaster; const rgbRaster = new Uint8ClampedArray(width * height * 3); for (let i = 0, j = 0; i < yCbCrRaster.length; i += 3, j += 3) { const y = yCbCrRaster[i]; const cb = yCbCrRaster[i + 1]; const cr = yCbCrRaster[i + 2]; rgbRaster[j] = y + 1.402 * (cr - 128); rgbRaster[j + 1] = y - 0.34414 * (cb - 128) - 0.71414 * (cr - 128); rgbRaster[j + 2] = y + 1.772 * (cb - 128); } return rgbRaster; } var Xn = 0.95047; var Yn = 1; var Zn = 1.08883; function fromCIELab(cieLabRaster) { const { width, height } = cieLabRaster; const rgbRaster = new Uint8Array(width * height * 3); for (let i = 0, j = 0; i < cieLabRaster.length; i += 3, j += 3) { const L = cieLabRaster[i + 0]; const a_ = cieLabRaster[i + 1] << 24 >> 24; const b_ = cieLabRaster[i + 2] << 24 >> 24; let y = (L + 16) / 116; let x = a_ / 500 + y; let z = y - b_ / 200; let r; let g; let b; x = Xn * (x * x * x > 8856e-6 ? x * x * x : (x - 16 / 116) / 7.787); y = Yn * (y * y * y > 8856e-6 ? y * y * y : (y - 16 / 116) / 7.787); z = Zn * (z * z * z > 8856e-6 ? z * z * z : (z - 16 / 116) / 7.787); r = x * 3.2406 + y * -1.5372 + z * -0.4986; g = x * -0.9689 + y * 1.8758 + z * 0.0415; b = x * 0.0557 + y * -0.204 + z * 1.057; r = r > 31308e-7 ? 1.055 * r ** (1 / 2.4) - 0.055 : 12.92 * r; g = g > 31308e-7 ? 1.055 * g ** (1 / 2.4) - 0.055 : 12.92 * g; b = b > 31308e-7 ? 1.055 * b ** (1 / 2.4) - 0.055 : 12.92 * b; rgbRaster[j] = Math.max(0, Math.min(1, r)) * 255; rgbRaster[j + 1] = Math.max(0, Math.min(1, g)) * 255; rgbRaster[j + 2] = Math.max(0, Math.min(1, b)) * 255; } return rgbRaster; } // node_modules/geotiff/dist-module/compression/index.js var registry = /* @__PURE__ */ new Map(); function addDecoder(cases, importFn) { if (!Array.isArray(cases)) { cases = [cases]; } cases.forEach((c) => registry.set(c, importFn)); } async function getDecoder(fileDirectory) { const importFn = registry.get(fileDirectory.Compression); if (!importFn) { throw new Error(`Unknown compression method identifier: ${fileDirectory.Compression}`); } const Decoder = await importFn(); return new Decoder(fileDirectory); } addDecoder([void 0, 1], () => import("./raw-UKC26CDE.js").then((m) => m.default)); addDecoder(5, () => import("./lzw-7DRJSDK5.js").then((m) => m.default)); addDecoder(6, () => { throw new Error("old style JPEG compression is not supported."); }); addDecoder(7, () => import("./jpeg-HGEGG7HT.js").then((m) => m.default)); addDecoder([8, 32946], () => import("./deflate-IME5YE3D.js").then((m) => m.default)); addDecoder(32773, () => import("./packbits-F6QMWCFA.js").then((m) => m.default)); addDecoder( 34887, () => import("./lerc-YJMC4I3X.js").then(async (m) => { await m.zstd.init(); return m; }).then((m) => m.default) ); addDecoder(50001, () => import("./webimage-T4PTOJUP.js").then((m) => m.default)); // node_modules/geotiff/dist-module/resample.js function copyNewSize(array, width, height, samplesPerPixel = 1) { return new (Object.getPrototypeOf(array)).constructor(width * height * samplesPerPixel); } function resampleNearest(valueArrays, inWidth, inHeight, outWidth, outHeight) { const relX = inWidth / outWidth; const relY = inHeight / outHeight; return valueArrays.map((array) => { const newArray = copyNewSize(array, outWidth, outHeight); for (let y = 0; y < outHeight; ++y) { const cy = Math.min(Math.round(relY * y), inHeight - 1); for (let x = 0; x < outWidth; ++x) { const cx = Math.min(Math.round(relX * x), inWidth - 1); const value = array[cy * inWidth + cx]; newArray[y * outWidth + x] = value; } } return newArray; }); } function lerp(v0, v1, t) { return (1 - t) * v0 + t * v1; } function resampleBilinear(valueArrays, inWidth, inHeight, outWidth, outHeight) { const relX = inWidth / outWidth; const relY = inHeight / outHeight; return valueArrays.map((array) => { const newArray = copyNewSize(array, outWidth, outHeight); for (let y = 0; y < outHeight; ++y) { const rawY = relY * y; const yl = Math.floor(rawY); const yh = Math.min(Math.ceil(rawY), inHeight - 1); for (let x = 0; x < outWidth; ++x) { const rawX = relX * x; const tx = rawX % 1; const xl = Math.floor(rawX); const xh = Math.min(Math.ceil(rawX), inWidth - 1); const ll = array[yl * inWidth + xl]; const hl = array[yl * inWidth + xh]; const lh = array[yh * inWidth + xl]; const hh = array[yh * inWidth + xh]; const value = lerp( lerp(ll, hl, tx), lerp(lh, hh, tx), rawY % 1 ); newArray[y * outWidth + x] = value; } } return newArray; }); } function resample(valueArrays, inWidth, inHeight, outWidth, outHeight, method = "nearest") { switch (method.toLowerCase()) { case "nearest": return resampleNearest(valueArrays, inWidth, inHeight, outWidth, outHeight); case "bilinear": case "linear": return resampleBilinear(valueArrays, inWidth, inHeight, outWidth, outHeight); default: throw new Error(`Unsupported resampling method: '${method}'`); } } function resampleNearestInterleaved(valueArray, inWidth, inHeight, outWidth, outHeight, samples) { const relX = inWidth / outWidth; const relY = inHeight / outHeight; const newArray = copyNewSize(valueArray, outWidth, outHeight, samples); for (let y = 0; y < outHeight; ++y) { const cy = Math.min(Math.round(relY * y), inHeight - 1); for (let x = 0; x < outWidth; ++x) { const cx = Math.min(Math.round(relX * x), inWidth - 1); for (let i = 0; i < samples; ++i) { const value = valueArray[cy * inWidth * samples + cx * samples + i]; newArray[y * outWidth * samples + x * samples + i] = value; } } } return newArray; } function resampleBilinearInterleaved(valueArray, inWidth, inHeight, outWidth, outHeight, samples) { const relX = inWidth / outWidth; const relY = inHeight / outHeight; const newArray = copyNewSize(valueArray, outWidth, outHeight, samples); for (let y = 0; y < outHeight; ++y) { const rawY = relY * y; const yl = Math.floor(rawY); const yh = Math.min(Math.ceil(rawY), inHeight - 1); for (let x = 0; x < outWidth; ++x) { const rawX = relX * x; const tx = rawX % 1; const xl = Math.floor(rawX); const xh = Math.min(Math.ceil(rawX), inWidth - 1); for (let i = 0; i < samples; ++i) { const ll = valueArray[yl * inWidth * samples + xl * samples + i]; const hl = valueArray[yl * inWidth * samples + xh * samples + i]; const lh = valueArray[yh * inWidth * samples + xl * samples + i]; const hh = valueArray[yh * inWidth * samples + xh * samples + i]; const value = lerp( lerp(ll, hl, tx), lerp(lh, hh, tx), rawY % 1 ); newArray[y * outWidth * samples + x * samples + i] = value; } } } return newArray; } function resampleInterleaved(valueArray, inWidth, inHeight, outWidth, outHeight, samples, method = "nearest") { switch (method.toLowerCase()) { case "nearest": return resampleNearestInterleaved( valueArray, inWidth, inHeight, outWidth, outHeight, samples ); case "bilinear": case "linear": return resampleBilinearInterleaved( valueArray, inWidth, inHeight, outWidth, outHeight, samples ); default: throw new Error(`Unsupported resampling method: '${method}'`); } } // node_modules/geotiff/dist-module/geotiffimage.js function sum(array, start, end) { let s = 0; for (let i = start; i < end; ++i) { s += array[i]; } return s; } function arrayForType(format, bitsPerSample, size) { switch (format) { case 1: if (bitsPerSample <= 8) { return new Uint8Array(size); } else if (bitsPerSample <= 16) { return new Uint16Array(size); } else if (bitsPerSample <= 32) { return new Uint32Array(size); } break; case 2: if (bitsPerSample === 8) { return new Int8Array(size); } else if (bitsPerSample === 16) { return new Int16Array(size); } else if (bitsPerSample === 32) { return new Int32Array(size); } break; case 3: switch (bitsPerSample) { case 16: case 32: return new Float32Array(size); case 64: return new Float64Array(size); default: break; } break; default: break; } throw Error("Unsupported data format/bitsPerSample"); } function needsNormalization(format, bitsPerSample) { if ((format === 1 || format === 2) && bitsPerSample <= 32 && bitsPerSample % 8 === 0) { return false; } else if (format === 3 && (bitsPerSample === 16 || bitsPerSample === 32 || bitsPerSample === 64)) { return false; } return true; } function normalizeArray(inBuffer, format, planarConfiguration, samplesPerPixel, bitsPerSample, tileWidth, tileHeight) { const view = new DataView(inBuffer); const outSize = planarConfiguration === 2 ? tileHeight * tileWidth : tileHeight * tileWidth * samplesPerPixel; const samplesToTransfer = planarConfiguration === 2 ? 1 : samplesPerPixel; const outArray = arrayForType(format, bitsPerSample, outSize); const bitMask = parseInt("1".repeat(bitsPerSample), 2); if (format === 1) { let pixelBitSkip; if (planarConfiguration === 1) { pixelBitSkip = samplesPerPixel * bitsPerSample; } else { pixelBitSkip = bitsPerSample; } let bitsPerLine = tileWidth * pixelBitSkip; if ((bitsPerLine & 7) !== 0) { bitsPerLine = bitsPerLine + 7 & ~7; } for (let y = 0; y < tileHeight; ++y) { const lineBitOffset = y * bitsPerLine; for (let x = 0; x < tileWidth; ++x) { const pixelBitOffset = lineBitOffset + x * samplesToTransfer * bitsPerSample; for (let i = 0; i < samplesToTransfer; ++i) { const bitOffset = pixelBitOffset + i * bitsPerSample; const outIndex = (y * tileWidth + x) * samplesToTransfer + i; const byteOffset = Math.floor(bitOffset / 8); const innerBitOffset = bitOffset % 8; if (innerBitOffset + bitsPerSample <= 8) { outArray[outIndex] = view.getUint8(byteOffset) >> 8 - bitsPerSample - innerBitOffset & bitMask; } else if (innerBitOffset + bitsPerSample <= 16) { outArray[outIndex] = view.getUint16(byteOffset) >> 16 - bitsPerSample - innerBitOffset & bitMask; } else if (innerBitOffset + bitsPerSample <= 24) { const raw = view.getUint16(byteOffset) << 8 | view.getUint8(byteOffset + 2); outArray[outIndex] = raw >> 24 - bitsPerSample - innerBitOffset & bitMask; } else { outArray[outIndex] = view.getUint32(byteOffset) >> 32 - bitsPerSample - innerBitOffset & bitMask; } } } } } else if (format === 3) { } return outArray.buffer; } var GeoTIFFImage = class { /** * @constructor * @param {Object} fileDirectory The parsed file directory * @param {Object} geoKeys The parsed geo-keys * @param {DataView} dataView The DataView for the underlying file. * @param {Boolean} littleEndian Whether the file is encoded in little or big endian * @param {Boolean} cache Whether or not decoded tiles shall be cached * @param {import('./source/basesource').BaseSource} source The datasource to read from */ constructor(fileDirectory, geoKeys, dataView, littleEndian, cache, source) { this.fileDirectory = fileDirectory; this.geoKeys = geoKeys; this.dataView = dataView; this.littleEndian = littleEndian; this.tiles = cache ? {} : null; this.isTiled = !fileDirectory.StripOffsets; const planarConfiguration = fileDirectory.PlanarConfiguration; this.planarConfiguration = typeof planarConfiguration === "undefined" ? 1 : planarConfiguration; if (this.planarConfiguration !== 1 && this.planarConfiguration !== 2) { throw new Error("Invalid planar configuration."); } this.source = source; } /** * Returns the associated parsed file directory. * @returns {Object} the parsed file directory */ getFileDirectory() { return this.fileDirectory; } /** * Returns the associated parsed geo keys. * @returns {Object} the parsed geo keys */ getGeoKeys() { return this.geoKeys; } /** * Returns the width of the image. * @returns {Number} the width of the image */ getWidth() { return this.fileDirectory.ImageWidth; } /** * Returns the height of the image. * @returns {Number} the height of the image */ getHeight() { return this.fileDirectory.ImageLength; } /** * Returns the number of samples per pixel. * @returns {Number} the number of samples per pixel */ getSamplesPerPixel() { return typeof this.fileDirectory.SamplesPerPixel !== "undefined" ? this.fileDirectory.SamplesPerPixel : 1; } /** * Returns the width of each tile. * @returns {Number} the width of each tile */ getTileWidth() { return this.isTiled ? this.fileDirectory.TileWidth : this.getWidth(); } /** * Returns the height of each tile. * @returns {Number} the height of each tile */ getTileHeight() { if (this.isTiled) { return this.fileDirectory.TileLength; } if (typeof this.fileDirectory.RowsPerStrip !== "undefined") { return Math.min(this.fileDirectory.RowsPerStrip, this.getHeight()); } return this.getHeight(); } getBlockWidth() { return this.getTileWidth(); } getBlockHeight(y) { if (this.isTiled || (y + 1) * this.getTileHeight() <= this.getHeight()) { return this.getTileHeight(); } else { return this.getHeight() - y * this.getTileHeight(); } } /** * Calculates the number of bytes for each pixel across all samples. Only full * bytes are supported, an exception is thrown when this is not the case. * @returns {Number} the bytes per pixel */ getBytesPerPixel() { let bytes = 0; for (let i = 0; i < this.fileDirectory.BitsPerSample.length; ++i) { bytes += this.getSampleByteSize(i); } return bytes; } getSampleByteSize(i) { if (i >= this.fileDirectory.BitsPerSample.length) { throw new RangeError(`Sample index ${i} is out of range.`); } return Math.ceil(this.fileDirectory.BitsPerSample[i] / 8); } getReaderForSample(sampleIndex) { const format = this.fileDirectory.SampleFormat ? this.fileDirectory.SampleFormat[sampleIndex] : 1; const bitsPerSample = this.fileDirectory.BitsPerSample[sampleIndex]; switch (format) { case 1: if (bitsPerSample <= 8) { return DataView.prototype.getUint8; } else if (bitsPerSample <= 16) { return DataView.prototype.getUint16; } else if (bitsPerSample <= 32) { return DataView.prototype.getUint32; } break; case 2: if (bitsPerSample <= 8) { return DataView.prototype.getInt8; } else if (bitsPerSample <= 16) { return DataView.prototype.getInt16; } else if (bitsPerSample <= 32) { return DataView.prototype.getInt32; } break; case 3: switch (bitsPerSample) { case 16: return function(offset, littleEndian) { return getFloat16(this, offset, littleEndian); }; case 32: return DataView.prototype.getFloat32; case 64: return DataView.prototype.getFloat64; default: break; } break; default: break; } throw Error("Unsupported data format/bitsPerSample"); } getSampleFormat(sampleIndex = 0) { return this.fileDirectory.SampleFormat ? this.fileDirectory.SampleFormat[sampleIndex] : 1; } getBitsPerSample(sampleIndex = 0) { return this.fileDirectory.BitsPerSample[sampleIndex]; } getArrayForSample(sampleIndex, size) { const format = this.getSampleFormat(sampleIndex); const bitsPerSample = this.getBitsPerSample(sampleIndex); return arrayForType(format, bitsPerSample, size); } /** * Returns the decoded strip or tile. * @param {Number} x the strip or tile x-offset * @param {Number} y the tile y-offset (0 for stripped images) * @param {Number} sample the sample to get for separated samples * @param {import("./geotiff").Pool|import("./geotiff").BaseDecoder} poolOrDecoder the decoder or decoder pool * @param {AbortSignal} [signal] An AbortSignal that may be signalled if the request is * to be aborted * @returns {Promise.} */ async getTileOrStrip(x, y, sample, poolOrDecoder, signal) { const numTilesPerRow = Math.ceil(this.getWidth() / this.getTileWidth()); const numTilesPerCol = Math.ceil(this.getHeight() / this.getTileHeight()); let index; const { tiles } = this; if (this.planarConfiguration === 1) { index = y * numTilesPerRow + x; } else if (this.planarConfiguration === 2) { index = sample * numTilesPerRow * numTilesPerCol + y * numTilesPerRow + x; } let offset; let byteCount; if (this.isTiled) { offset = this.fileDirectory.TileOffsets[index]; byteCount = this.fileDirectory.TileByteCounts[index]; } else { offset = this.fileDirectory.StripOffsets[index]; byteCount = this.fileDirectory.StripByteCounts[index]; } const slice = (await this.source.fetch([{ offset, length: byteCount }], signal))[0]; let request; if (tiles === null || !tiles[index]) { request = (async () => { let data = await poolOrDecoder.decode(this.fileDirectory, slice); const sampleFormat = this.getSampleFormat(); const bitsPerSample = this.getBitsPerSample(); if (needsNormalization(sampleFormat, bitsPerSample)) { data = normalizeArray( data, sampleFormat, this.planarConfiguration, this.getSamplesPerPixel(), bitsPerSample, this.getTileWidth(), this.getBlockHeight(y) ); } return data; })(); if (tiles !== null) { tiles[index] = request; } } else { request = tiles[index]; } return { x, y, sample, data: await request }; } /** * Internal read function. * @private * @param {Array} imageWindow The image window in pixel coordinates * @param {Array} samples The selected samples (0-based indices) * @param {TypedArray|TypedArray[]} valueArrays The array(s) to write into * @param {Boolean} interleave Whether or not to write in an interleaved manner * @param {import("./geotiff").Pool|AbstractDecoder} poolOrDecoder the decoder or decoder pool * @param {number} width the width of window to be read into * @param {number} height the height of window to be read into * @param {number} resampleMethod the resampling method to be used when interpolating * @param {AbortSignal} [signal] An AbortSignal that may be signalled if the request is * to be aborted * @returns {Promise} */ async _readRaster(imageWindow, samples, valueArrays, interleave, poolOrDecoder, width, height, resampleMethod, signal) { const tileWidth = this.getTileWidth(); const tileHeight = this.getTileHeight(); const imageWidth = this.getWidth(); const imageHeight = this.getHeight(); const minXTile = Math.max(Math.floor(imageWindow[0] / tileWidth), 0); const maxXTile = Math.min( Math.ceil(imageWindow[2] / tileWidth), Math.ceil(imageWidth / tileWidth) ); const minYTile = Math.max(Math.floor(imageWindow[1] / tileHeight), 0); const maxYTile = Math.min( Math.ceil(imageWindow[3] / tileHeight), Math.ceil(imageHeight / tileHeight) ); const windowWidth = imageWindow[2] - imageWindow[0]; let bytesPerPixel = this.getBytesPerPixel(); const srcSampleOffsets = []; const sampleReaders = []; for (let i = 0; i < samples.length; ++i) { if (this.planarConfiguration === 1) { srcSampleOffsets.push(sum(this.fileDirectory.BitsPerSample, 0, samples[i]) / 8); } else { srcSampleOffsets.push(0); } sampleReaders.push(this.getReaderForSample(samples[i])); } const promises = []; const { littleEndian } = this; for (let yTile = minYTile; yTile < maxYTile; ++yTile) { for (let xTile = minXTile; xTile < maxXTile; ++xTile) { let getPromise; if (this.planarConfiguration === 1) { getPromise = this.getTileOrStrip(xTile, yTile, 0, poolOrDecoder, signal); } for (let sampleIndex = 0; sampleIndex < samples.length; ++sampleIndex) { const si = sampleIndex; const sample = samples[sampleIndex]; if (this.planarConfiguration === 2) { bytesPerPixel = this.getSampleByteSize(sample); getPromise = this.getTileOrStrip(xTile, yTile, sample, poolOrDecoder, signal); } const promise = getPromise.then((tile) => { const buffer3 = tile.data; const dataView = new DataView(buffer3); const blockHeight = this.getBlockHeight(tile.y); const firstLine = tile.y * tileHeight; const firstCol = tile.x * tileWidth; const lastLine = firstLine + blockHeight; const lastCol = (tile.x + 1) * tileWidth; const reader = sampleReaders[si]; const ymax = Math.min(blockHeight, blockHeight - (lastLine - imageWindow[3]), imageHeight - firstLine); const xmax = Math.min(tileWidth, tileWidth - (lastCol - imageWindow[2]), imageWidth - firstCol); for (let y = Math.max(0, imageWindow[1] - firstLine); y < ymax; ++y) { for (let x = Math.max(0, imageWindow[0] - firstCol); x < xmax; ++x) { const pixelOffset = (y * tileWidth + x) * bytesPerPixel; const value = reader.call( dataView, pixelOffset + srcSampleOffsets[si], littleEndian ); let windowCoordinate; if (interleave) { windowCoordinate = (y + firstLine - imageWindow[1]) * windowWidth * samples.length + (x + firstCol - imageWindow[0]) * samples.length + si; valueArrays[windowCoordinate] = value; } else { windowCoordinate = (y + firstLine - imageWindow[1]) * windowWidth + x + firstCol - imageWindow[0]; valueArrays[si][windowCoordinate] = value; } } } }); promises.push(promise); } } } await Promise.all(promises); if (width && imageWindow[2] - imageWindow[0] !== width || height && imageWindow[3] - imageWindow[1] !== height) { let resampled; if (interleave) { resampled = resampleInterleaved( valueArrays, imageWindow[2] - imageWindow[0], imageWindow[3] - imageWindow[1], width, height, samples.length, resampleMethod ); } else { resampled = resample( valueArrays, imageWindow[2] - imageWindow[0], imageWindow[3] - imageWindow[1], width, height, resampleMethod ); } resampled.width = width; resampled.height = height; return resampled; } valueArrays.width = width || imageWindow[2] - imageWindow[0]; valueArrays.height = height || imageWindow[3] - imageWindow[1]; return valueArrays; } /** * Reads raster data from the image. This function reads all selected samples * into separate arrays of the correct type for that sample or into a single * combined array when `interleave` is set. When provided, only a subset * of the raster is read for each sample. * * @param {ReadRasterOptions} [options={}] optional parameters * @returns {Promise} the decoded arrays as a promise */ async readRasters({ window: wnd, samples = [], interleave, pool = null, width, height, resampleMethod, fillValue, signal } = {}) { const imageWindow = wnd || [0, 0, this.getWidth(), this.getHeight()]; if (imageWindow[0] > imageWindow[2] || imageWindow[1] > imageWindow[3]) { throw new Error("Invalid subsets"); } const imageWindowWidth = imageWindow[2] - imageWindow[0]; const imageWindowHeight = imageWindow[3] - imageWindow[1]; const numPixels = imageWindowWidth * imageWindowHeight; const samplesPerPixel = this.getSamplesPerPixel(); if (!samples || !samples.length) { for (let i = 0; i < samplesPerPixel; ++i) { samples.push(i); } } else { for (let i = 0; i < samples.length; ++i) { if (samples[i] >= samplesPerPixel) { return Promise.reject(new RangeError(`Invalid sample index '${samples[i]}'.`)); } } } let valueArrays; if (interleave) { const format = this.fileDirectory.SampleFormat ? Math.max.apply(null, this.fileDirectory.SampleFormat) : 1; const bitsPerSample = Math.max.apply(null, this.fileDirectory.BitsPerSample); valueArrays = arrayForType(format, bitsPerSample, numPixels * samples.length); if (fillValue) { valueArrays.fill(fillValue); } } else { valueArrays = []; for (let i = 0; i < samples.length; ++i) { const valueArray = this.getArrayForSample(samples[i], numPixels); if (Array.isArray(fillValue) && i < fillValue.length) { valueArray.fill(fillValue[i]); } else if (fillValue && !Array.isArray(fillValue)) { valueArray.fill(fillValue); } valueArrays.push(valueArray); } } const poolOrDecoder = pool || await getDecoder(this.fileDirectory); const result = await this._readRaster( imageWindow, samples, valueArrays, interleave, poolOrDecoder, width, height, resampleMethod, signal ); return result; } /** * Reads raster data from the image as RGB. The result is always an * interleaved typed array. * Colorspaces other than RGB will be transformed to RGB, color maps expanded. * When no other method is applicable, the first sample is used to produce a * grayscale image. * When provided, only a subset of the raster is read for each sample. * * @param {Object} [options] optional parameters * @param {Array} [options.window] the subset to read data from in pixels. * @param {boolean} [options.interleave=true] whether the data shall be read * in one single array or separate * arrays. * @param {import("./geotiff").Pool} [options.pool=null] The optional decoder pool to use. * @param {number} [options.width] The desired width of the output. When the width is no the * same as the images, resampling will be performed. * @param {number} [options.height] The desired height of the output. When the width is no the * same as the images, resampling will be performed. * @param {string} [options.resampleMethod='nearest'] The desired resampling method. * @param {boolean} [options.enableAlpha=false] Enable reading alpha channel if present. * @param {AbortSignal} [options.signal] An AbortSignal that may be signalled if the request is * to be aborted * @returns {Promise} the RGB array as a Promise */ async readRGB({ window: window2, interleave = true, pool = null, width, height, resampleMethod, enableAlpha = false, signal } = {}) { const imageWindow = window2 || [0, 0, this.getWidth(), this.getHeight()]; if (imageWindow[0] > imageWindow[2] || imageWindow[1] > imageWindow[3]) { throw new Error("Invalid subsets"); } const pi = this.fileDirectory.PhotometricInterpretation; if (pi === photometricInterpretations.RGB) { let s = [0, 1, 2]; if (!(this.fileDirectory.ExtraSamples === ExtraSamplesValues.Unspecified) && enableAlpha) { s = []; for (let i = 0; i < this.fileDirectory.BitsPerSample.length; i += 1) { s.push(i); } } return this.readRasters({ window: window2, interleave, samples: s, pool, width, height, resampleMethod, signal }); } let samples; switch (pi) { case photometricInterpretations.WhiteIsZero: case photometricInterpretations.BlackIsZero: case photometricInterpretations.Palette: samples = [0]; break; case photometricInterpretations.CMYK: samples = [0, 1, 2, 3]; break; case photometricInterpretations.YCbCr: case photometricInterpretations.CIELab: samples = [0, 1, 2]; break; default: throw new Error("Invalid or unsupported photometric interpretation."); } const subOptions = { window: imageWindow, interleave: true, samples, pool, width, height, resampleMethod, signal }; const { fileDirectory } = this; const raster = await this.readRasters(subOptions); const max = 2 ** this.fileDirectory.BitsPerSample[0]; let data; switch (pi) { case photometricInterpretations.WhiteIsZero: data = fromWhiteIsZero(raster, max); break; case photometricInterpretations.BlackIsZero: data = fromBlackIsZero(raster, max); break; case photometricInterpretations.Palette: data = fromPalette(raster, fileDirectory.ColorMap); break; case photometricInterpretations.CMYK: data = fromCMYK(raster); break; case photometricInterpretations.YCbCr: data = fromYCbCr(raster); break; case photometricInterpretations.CIELab: data = fromCIELab(raster); break; default: throw new Error("Unsupported photometric interpretation."); } if (!interleave) { const red = new Uint8Array(data.length / 3); const green = new Uint8Array(data.length / 3); const blue = new Uint8Array(data.length / 3); for (let i = 0, j = 0; i < data.length; i += 3, ++j) { red[j] = data[i]; green[j] = data[i + 1]; blue[j] = data[i + 2]; } data = [red, green, blue]; } data.width = raster.width; data.height = raster.height; return data; } /** * Returns an array of tiepoints. * @returns {Object[]} */ getTiePoints() { if (!this.fileDirectory.ModelTiepoint) { return []; } const tiePoints = []; for (let i = 0; i < this.fileDirectory.ModelTiepoint.length; i += 6) { tiePoints.push({ i: this.fileDirectory.ModelTiepoint[i], j: this.fileDirectory.ModelTiepoint[i + 1], k: this.fileDirectory.ModelTiepoint[i + 2], x: this.fileDirectory.ModelTiepoint[i + 3], y: this.fileDirectory.ModelTiepoint[i + 4], z: this.fileDirectory.ModelTiepoint[i + 5] }); } return tiePoints; } /** * Returns the parsed GDAL metadata items. * * If sample is passed to null, dataset-level metadata will be returned. * Otherwise only metadata specific to the provided sample will be returned. * * @param {number} [sample=null] The sample index. * @returns {Object} */ getGDALMetadata(sample = null) { const metadata = {}; if (!this.fileDirectory.GDAL_METADATA) { return null; } const string = this.fileDirectory.GDAL_METADATA; let items = (0, import_find_tags_by_name.default)(string, "Item"); if (sample === null) { items = items.filter((item) => (0, import_get_attribute.default)(item, "sample") === void 0); } else { items = items.filter((item) => Number((0, import_get_attribute.default)(item, "sample")) === sample); } for (let i = 0; i < items.length; ++i) { const item = items[i]; metadata[(0, import_get_attribute.default)(item, "name")] = item.inner; } return metadata; } /** * Returns the GDAL nodata value * @returns {number|null} */ getGDALNoData() { if (!this.fileDirectory.GDAL_NODATA) { return null; } const string = this.fileDirectory.GDAL_NODATA; return Number(string.substring(0, string.length - 1)); } /** * Returns the image origin as a XYZ-vector. When the image has no affine * transformation, then an exception is thrown. * @returns {Array} The origin as a vector */ getOrigin() { const tiePoints = this.fileDirectory.ModelTiepoint; const modelTransformation = this.fileDirectory.ModelTransformation; if (tiePoints && tiePoints.length === 6) { return [ tiePoints[3], tiePoints[4], tiePoints[5] ]; } if (modelTransformation) { return [ modelTransformation[3], modelTransformation[7], modelTransformation[11] ]; } throw new Error("The image does not have an affine transformation."); } /** * Returns the image resolution as a XYZ-vector. When the image has no affine * transformation, then an exception is thrown. * @param {GeoTIFFImage} [referenceImage=null] A reference image to calculate the resolution from * in cases when the current image does not have the * required tags on its own. * @returns {Array} The resolution as a vector */ getResolution(referenceImage = null) { const modelPixelScale = this.fileDirectory.ModelPixelScale; const modelTransformation = this.fileDirectory.ModelTransformation; if (modelPixelScale) { return [ modelPixelScale[0], -modelPixelScale[1], modelPixelScale[2] ]; } if (modelTransformation) { if (modelTransformation[1] === 0 && modelTransformation[4] === 0) { return [ modelTransformation[0], -modelTransformation[5], modelTransformation[10] ]; } return [ Math.sqrt(modelTransformation[0] * modelTransformation[0] + modelTransformation[4] * modelTransformation[4]), -Math.sqrt(modelTransformation[1] * modelTransformation[1] + modelTransformation[5] * modelTransformation[5]), modelTransformation[10] ]; } if (referenceImage) { const [refResX, refResY, refResZ] = referenceImage.getResolution(); return [ refResX * referenceImage.getWidth() / this.getWidth(), refResY * referenceImage.getHeight() / this.getHeight(), refResZ * referenceImage.getWidth() / this.getWidth() ]; } throw new Error("The image does not have an affine transformation."); } /** * Returns whether or not the pixels of the image depict an area (or point). * @returns {Boolean} Whether the pixels are a point */ pixelIsArea() { return this.geoKeys.GTRasterTypeGeoKey === 1; } /** * Returns the image bounding box as an array of 4 values: min-x, min-y, * max-x and max-y. When the image has no affine transformation, then an * exception is thrown. * @param {boolean} [tilegrid=false] If true return extent for a tilegrid * without adjustment for ModelTransformation. * @returns {Array} The bounding box */ getBoundingBox(tilegrid = false) { const height = this.getHeight(); const width = this.getWidth(); if (this.fileDirectory.ModelTransformation && !tilegrid) { const [a, b, c, d, e, f, g, h] = this.fileDirectory.ModelTransformation; const corners = [ [0, 0], [0, height], [width, 0], [width, height] ]; const projected = corners.map(([I, J]) => [ d + a * I + b * J, h + e * I + f * J ]); const xs = projected.map((pt) => pt[0]); const ys = projected.map((pt) => pt[1]); return [ Math.min(...xs), Math.min(...ys), Math.max(...xs), Math.max(...ys) ]; } else { const origin = this.getOrigin(); const resolution = this.getResolution(); const x1 = origin[0]; const y1 = origin[1]; const x2 = x1 + resolution[0] * width; const y2 = y1 + resolution[1] * height; return [ Math.min(x1, x2), Math.min(y1, y2), Math.max(x1, x2), Math.max(y1, y2) ]; } } }; var geotiffimage_default = GeoTIFFImage; // node_modules/geotiff/dist-module/dataview64.js var DataView64 = class { constructor(arrayBuffer) { this._dataView = new DataView(arrayBuffer); } get buffer() { return this._dataView.buffer; } getUint64(offset, littleEndian) { const left = this.getUint32(offset, littleEndian); const right = this.getUint32(offset + 4, littleEndian); let combined; if (littleEndian) { combined = left + 2 ** 32 * right; if (!Number.isSafeInteger(combined)) { throw new Error( `${combined} exceeds MAX_SAFE_INTEGER. Precision may be lost. Please report if you get this message to https://github.com/geotiffjs/geotiff.js/issues` ); } return combined; } combined = 2 ** 32 * left + right; if (!Number.isSafeInteger(combined)) { throw new Error( `${combined} exceeds MAX_SAFE_INTEGER. Precision may be lost. Please report if you get this message to https://github.com/geotiffjs/geotiff.js/issues` ); } return combined; } // adapted from https://stackoverflow.com/a/55338384/8060591 getInt64(offset, littleEndian) { let value = 0; const isNegative = (this._dataView.getUint8(offset + (littleEndian ? 7 : 0)) & 128) > 0; let carrying = true; for (let i = 0; i < 8; i++) { let byte = this._dataView.getUint8(offset + (littleEndian ? i : 7 - i)); if (isNegative) { if (carrying) { if (byte !== 0) { byte = ~(byte - 1) & 255; carrying = false; } } else { byte = ~byte & 255; } } value += byte * 256 ** i; } if (isNegative) { value = -value; } return value; } getUint8(offset, littleEndian) { return this._dataView.getUint8(offset, littleEndian); } getInt8(offset, littleEndian) { return this._dataView.getInt8(offset, littleEndian); } getUint16(offset, littleEndian) { return this._dataView.getUint16(offset, littleEndian); } getInt16(offset, littleEndian) { return this._dataView.getInt16(offset, littleEndian); } getUint32(offset, littleEndian) { return this._dataView.getUint32(offset, littleEndian); } getInt32(offset, littleEndian) { return this._dataView.getInt32(offset, littleEndian); } getFloat16(offset, littleEndian) { return getFloat16(this._dataView, offset, littleEndian); } getFloat32(offset, littleEndian) { return this._dataView.getFloat32(offset, littleEndian); } getFloat64(offset, littleEndian) { return this._dataView.getFloat64(offset, littleEndian); } }; // node_modules/geotiff/dist-module/dataslice.js var DataSlice = class { constructor(arrayBuffer, sliceOffset, littleEndian, bigTiff) { this._dataView = new DataView(arrayBuffer); this._sliceOffset = sliceOffset; this._littleEndian = littleEndian; this._bigTiff = bigTiff; } get sliceOffset() { return this._sliceOffset; } get sliceTop() { return this._sliceOffset + this.buffer.byteLength; } get littleEndian() { return this._littleEndian; } get bigTiff() { return this._bigTiff; } get buffer() { return this._dataView.buffer; } covers(offset, length) { return this.sliceOffset <= offset && this.sliceTop >= offset + length; } readUint8(offset) { return this._dataView.getUint8( offset - this._sliceOffset, this._littleEndian ); } readInt8(offset) { return this._dataView.getInt8( offset - this._sliceOffset, this._littleEndian ); } readUint16(offset) { return this._dataView.getUint16( offset - this._sliceOffset, this._littleEndian ); } readInt16(offset) { return this._dataView.getInt16( offset - this._sliceOffset, this._littleEndian ); } readUint32(offset) { return this._dataView.getUint32( offset - this._sliceOffset, this._littleEndian ); } readInt32(offset) { return this._dataView.getInt32( offset - this._sliceOffset, this._littleEndian ); } readFloat32(offset) { return this._dataView.getFloat32( offset - this._sliceOffset, this._littleEndian ); } readFloat64(offset) { return this._dataView.getFloat64( offset - this._sliceOffset, this._littleEndian ); } readUint64(offset) { const left = this.readUint32(offset); const right = this.readUint32(offset + 4); let combined; if (this._littleEndian) { combined = left + 2 ** 32 * right; if (!Number.isSafeInteger(combined)) { throw new Error( `${combined} exceeds MAX_SAFE_INTEGER. Precision may be lost. Please report if you get this message to https://github.com/geotiffjs/geotiff.js/issues` ); } return combined; } combined = 2 ** 32 * left + right; if (!Number.isSafeInteger(combined)) { throw new Error( `${combined} exceeds MAX_SAFE_INTEGER. Precision may be lost. Please report if you get this message to https://github.com/geotiffjs/geotiff.js/issues` ); } return combined; } // adapted from https://stackoverflow.com/a/55338384/8060591 readInt64(offset) { let value = 0; const isNegative = (this._dataView.getUint8(offset + (this._littleEndian ? 7 : 0)) & 128) > 0; let carrying = true; for (let i = 0; i < 8; i++) { let byte = this._dataView.getUint8( offset + (this._littleEndian ? i : 7 - i) ); if (isNegative) { if (carrying) { if (byte !== 0) { byte = ~(byte - 1) & 255; carrying = false; } } else { byte = ~byte & 255; } } value += byte * 256 ** i; } if (isNegative) { value = -value; } return value; } readOffset(offset) { if (this._bigTiff) { return this.readUint64(offset); } return this.readUint32(offset); } }; // node_modules/geotiff/dist-module/pool.js var defaultPoolSize = typeof navigator !== "undefined" ? navigator.hardwareConcurrency || 2 : 2; var Pool = class { /** * @constructor * @param {Number} [size] The size of the pool. Defaults to the number of CPUs * available. When this parameter is `null` or 0, then the * decoding will be done in the main thread. * @param {function(): Worker} [createWorker] A function that creates the decoder worker. * Defaults to a worker with all decoders that ship with geotiff.js. The `createWorker()` * function is expected to return a `Worker` compatible with Web Workers. For code that * runs in Node, [web-worker](https://www.npmjs.com/package/web-worker) is a good choice. * * A worker that uses a custom lzw decoder would look like this `my-custom-worker.js` file: * ```js * import { addDecoder, getDecoder } from 'geotiff'; * addDecoder(5, () => import ('./my-custom-lzw').then((m) => m.default)); * self.addEventListener('message', async (e) => { * const { id, fileDirectory, buffer } = e.data; * const decoder = await getDecoder(fileDirectory); * const decoded = await decoder.decode(fileDirectory, buffer); * self.postMessage({ decoded, id }, [decoded]); * }); * ``` * The way the above code is built into a worker by the `createWorker()` function * depends on the used bundler. For most bundlers, something like this will work: * ```js * function createWorker() { * return new Worker(new URL('./my-custom-worker.js', import.meta.url)); * } * ``` */ constructor(size = defaultPoolSize, createWorker2) { this.workers = null; this._awaitingDecoder = null; this.size = size; this.messageId = 0; if (size) { this._awaitingDecoder = createWorker2 ? Promise.resolve(createWorker2) : new Promise((resolve) => { import("./decoder-FUDNTCPN.js").then((module) => { resolve(module.create); }); }); this._awaitingDecoder.then((create2) => { this._awaitingDecoder = null; this.workers = []; for (let i = 0; i < size; i++) { this.workers.push({ worker: create2(), idle: true }); } }); } } /** * Decode the given block of bytes with the set compression method. * @param {ArrayBuffer} buffer the array buffer of bytes to decode. * @returns {Promise} the decoded result as a `Promise` */ async decode(fileDirectory, buffer3) { if (this._awaitingDecoder) { await this._awaitingDecoder; } return this.size === 0 ? getDecoder(fileDirectory).then((decoder) => decoder.decode(fileDirectory, buffer3)) : new Promise((resolve) => { const worker = this.workers.find((candidate) => candidate.idle) || this.workers[Math.floor(Math.random() * this.size)]; worker.idle = false; const id = this.messageId++; const onMessage = (e) => { if (e.data.id === id) { worker.idle = true; resolve(e.data.decoded); worker.worker.removeEventListener("message", onMessage); } }; worker.worker.addEventListener("message", onMessage); worker.worker.postMessage({ fileDirectory, buffer: buffer3, id }, [buffer3]); }); } destroy() { if (this.workers) { this.workers.forEach((worker) => { worker.worker.terminate(); }); this.workers = null; } } }; var pool_default = Pool; // node_modules/geotiff/dist-module/source/httputils.js var CRLFCRLF = "\r\n\r\n"; function itemsToObject(items) { if (typeof Object.fromEntries !== "undefined") { return Object.fromEntries(items); } const obj = {}; for (const [key, value] of items) { obj[key.toLowerCase()] = value; } return obj; } function parseHeaders(text) { const items = text.split("\r\n").map((line) => { const kv = line.split(":").map((str) => str.trim()); kv[0] = kv[0].toLowerCase(); return kv; }); return itemsToObject(items); } function parseContentType(rawContentType) { const [type, ...rawParams] = rawContentType.split(";").map((s) => s.trim()); const paramsItems = rawParams.map((param) => param.split("=")); return { type, params: itemsToObject(paramsItems) }; } function parseContentRange(rawContentRange) { let start; let end; let total; if (rawContentRange) { [, start, end, total] = rawContentRange.match(/bytes (\d+)-(\d+)\/(\d+)/); start = parseInt(start, 10); end = parseInt(end, 10); total = parseInt(total, 10); } return { start, end, total }; } function parseByteRanges(responseArrayBuffer, boundary) { let offset = null; const decoder = new TextDecoder("ascii"); const out = []; const startBoundary = `--${boundary}`; const endBoundary = `${startBoundary}--`; for (let i = 0; i < 10; ++i) { const text = decoder.decode( new Uint8Array(responseArrayBuffer, i, startBoundary.length) ); if (text === startBoundary) { offset = i; } } if (offset === null) { throw new Error("Could not find initial boundary"); } while (offset < responseArrayBuffer.byteLength) { const text = decoder.decode( new Uint8Array( responseArrayBuffer, offset, Math.min(startBoundary.length + 1024, responseArrayBuffer.byteLength - offset) ) ); if (text.length === 0 || text.startsWith(endBoundary)) { break; } if (!text.startsWith(startBoundary)) { throw new Error("Part does not start with boundary"); } const innerText = text.substr(startBoundary.length + 2); if (innerText.length === 0) { break; } const endOfHeaders = innerText.indexOf(CRLFCRLF); const headers = parseHeaders(innerText.substr(0, endOfHeaders)); const { start, end, total } = parseContentRange(headers["content-range"]); const startOfData = offset + startBoundary.length + endOfHeaders + CRLFCRLF.length; const length = parseInt(end, 10) + 1 - parseInt(start, 10); out.push({ headers, data: responseArrayBuffer.slice(startOfData, startOfData + length), offset: start, length, fileSize: total }); offset = startOfData + length + 4; } return out; } // node_modules/geotiff/dist-module/source/basesource.js var BaseSource = class { /** * * @param {Slice[]} slices * @returns {ArrayBuffer[]} */ async fetch(slices, signal = void 0) { return Promise.all( slices.map((slice) => this.fetchSlice(slice, signal)) ); } /** * * @param {Slice} slice * @returns {ArrayBuffer} */ async fetchSlice(slice) { throw new Error(`fetching of slice ${slice} not possible, not implemented`); } /** * Returns the filesize if already determined and null otherwise */ get fileSize() { return null; } async close() { } }; // node_modules/quick-lru/index.js var QuickLRU = class extends Map { constructor(options = {}) { super(); if (!(options.maxSize && options.maxSize > 0)) { throw new TypeError("`maxSize` must be a number greater than 0"); } if (typeof options.maxAge === "number" && options.maxAge === 0) { throw new TypeError("`maxAge` must be a number greater than 0"); } this.maxSize = options.maxSize; this.maxAge = options.maxAge || Number.POSITIVE_INFINITY; this.onEviction = options.onEviction; this.cache = /* @__PURE__ */ new Map(); this.oldCache = /* @__PURE__ */ new Map(); this._size = 0; } // TODO: Use private class methods when targeting Node.js 16. _emitEvictions(cache) { if (typeof this.onEviction !== "function") { return; } for (const [key, item] of cache) { this.onEviction(key, item.value); } } _deleteIfExpired(key, item) { if (typeof item.expiry === "number" && item.expiry <= Date.now()) { if (typeof this.onEviction === "function") { this.onEviction(key, item.value); } return this.delete(key); } return false; } _getOrDeleteIfExpired(key, item) { const deleted = this._deleteIfExpired(key, item); if (deleted === false) { return item.value; } } _getItemValue(key, item) { return item.expiry ? this._getOrDeleteIfExpired(key, item) : item.value; } _peek(key, cache) { const item = cache.get(key); return this._getItemValue(key, item); } _set(key, value) { this.cache.set(key, value); this._size++; if (this._size >= this.maxSize) { this._size = 0; this._emitEvictions(this.oldCache); this.oldCache = this.cache; this.cache = /* @__PURE__ */ new Map(); } } _moveToRecent(key, item) { this.oldCache.delete(key); this._set(key, item); } *_entriesAscending() { for (const item of this.oldCache) { const [key, value] = item; if (!this.cache.has(key)) { const deleted = this._deleteIfExpired(key, value); if (deleted === false) { yield item; } } } for (const item of this.cache) { const [key, value] = item; const deleted = this._deleteIfExpired(key, value); if (deleted === false) { yield item; } } } get(key) { if (this.cache.has(key)) { const item = this.cache.get(key); return this._getItemValue(key, item); } if (this.oldCache.has(key)) { const item = this.oldCache.get(key); if (this._deleteIfExpired(key, item) === false) { this._moveToRecent(key, item); return item.value; } } } set(key, value, { maxAge = this.maxAge } = {}) { const expiry = typeof maxAge === "number" && maxAge !== Number.POSITIVE_INFINITY ? Date.now() + maxAge : void 0; if (this.cache.has(key)) { this.cache.set(key, { value, expiry }); } else { this._set(key, { value, expiry }); } return this; } has(key) { if (this.cache.has(key)) { return !this._deleteIfExpired(key, this.cache.get(key)); } if (this.oldCache.has(key)) { return !this._deleteIfExpired(key, this.oldCache.get(key)); } return false; } peek(key) { if (this.cache.has(key)) { return this._peek(key, this.cache); } if (this.oldCache.has(key)) { return this._peek(key, this.oldCache); } } delete(key) { const deleted = this.cache.delete(key); if (deleted) { this._size--; } return this.oldCache.delete(key) || deleted; } clear() { this.cache.clear(); this.oldCache.clear(); this._size = 0; } resize(newSize) { if (!(newSize && newSize > 0)) { throw new TypeError("`maxSize` must be a number greater than 0"); } const items = [...this._entriesAscending()]; const removeCount = items.length - newSize; if (removeCount < 0) { this.cache = new Map(items); this.oldCache = /* @__PURE__ */ new Map(); this._size = items.length; } else { if (removeCount > 0) { this._emitEvictions(items.slice(0, removeCount)); } this.oldCache = new Map(items.slice(removeCount)); this.cache = /* @__PURE__ */ new Map(); this._size = 0; } this.maxSize = newSize; } *keys() { for (const [key] of this) { yield key; } } *values() { for (const [, value] of this) { yield value; } } *[Symbol.iterator]() { for (const item of this.cache) { const [key, value] = item; const deleted = this._deleteIfExpired(key, value); if (deleted === false) { yield [key, value.value]; } } for (const item of this.oldCache) { const [key, value] = item; if (!this.cache.has(key)) { const deleted = this._deleteIfExpired(key, value); if (deleted === false) { yield [key, value.value]; } } } } *entriesDescending() { let items = [...this.cache]; for (let i = items.length - 1; i >= 0; --i) { const item = items[i]; const [key, value] = item; const deleted = this._deleteIfExpired(key, value); if (deleted === false) { yield [key, value.value]; } } items = [...this.oldCache]; for (let i = items.length - 1; i >= 0; --i) { const item = items[i]; const [key, value] = item; if (!this.cache.has(key)) { const deleted = this._deleteIfExpired(key, value); if (deleted === false) { yield [key, value.value]; } } } } *entriesAscending() { for (const [key, value] of this._entriesAscending()) { yield [key, value.value]; } } get size() { if (!this._size) { return this.oldCache.size; } let oldCacheSize = 0; for (const key of this.oldCache.keys()) { if (!this.cache.has(key)) { oldCacheSize++; } } return Math.min(this._size + oldCacheSize, this.maxSize); } entries() { return this.entriesAscending(); } forEach(callbackFunction, thisArgument = this) { for (const [key, value] of this.entriesAscending()) { callbackFunction.call(thisArgument, value, key, this); } } get [Symbol.toStringTag]() { return JSON.stringify([...this.entriesAscending()]); } }; // node_modules/geotiff/dist-module/utils.js function assign(target, source) { for (const key in source) { if (source.hasOwnProperty(key)) { target[key] = source[key]; } } } function invert(oldObj) { const newObj = {}; for (const key in oldObj) { if (oldObj.hasOwnProperty(key)) { const value = oldObj[key]; newObj[value] = key; } } return newObj; } function times(numTimes, func) { const results = []; for (let i = 0; i < numTimes; i++) { results.push(func(i)); } return results; } async function wait(milliseconds) { return new Promise((resolve) => setTimeout(resolve, milliseconds)); } function zip(a, b) { const A = Array.isArray(a) ? a : Array.from(a); const B = Array.isArray(b) ? b : Array.from(b); return A.map((k, i) => [k, B[i]]); } var AbortError = class _AbortError extends Error { constructor(params) { super(params); if (Error.captureStackTrace) { Error.captureStackTrace(this, _AbortError); } this.name = "AbortError"; } }; var CustomAggregateError = class extends Error { constructor(errors, message) { super(message); this.errors = errors; this.message = message; this.name = "AggregateError"; } }; var AggregateError = CustomAggregateError; // node_modules/geotiff/dist-module/source/blockedsource.js var Block = class { /** * * @param {number} offset * @param {number} length * @param {ArrayBuffer} [data] */ constructor(offset, length, data = null) { this.offset = offset; this.length = length; this.data = data; } /** * @returns {number} the top byte border */ get top() { return this.offset + this.length; } }; var BlockGroup = class { /** * * @param {number} offset * @param {number} length * @param {number[]} blockIds */ constructor(offset, length, blockIds) { this.offset = offset; this.length = length; this.blockIds = blockIds; } }; var BlockedSource = class extends BaseSource { /** * * @param {BaseSource} source The underlying source that shall be blocked and cached * @param {object} options * @param {number} [options.blockSize] * @param {number} [options.cacheSize] */ constructor(source, { blockSize = 65536, cacheSize = 100 } = {}) { super(); this.source = source; this.blockSize = blockSize; this.blockCache = new QuickLRU({ maxSize: cacheSize, onEviction: (blockId, block) => { this.evictedBlocks.set(blockId, block); } }); this.evictedBlocks = /* @__PURE__ */ new Map(); this.blockRequests = /* @__PURE__ */ new Map(); this.blockIdsToFetch = /* @__PURE__ */ new Set(); this.abortedBlockIds = /* @__PURE__ */ new Set(); } get fileSize() { return this.source.fileSize; } /** * * @param {import("./basesource").Slice[]} slices */ async fetch(slices, signal) { const blockRequests = []; const missingBlockIds = []; const allBlockIds = []; this.evictedBlocks.clear(); for (const { offset, length } of slices) { let top = offset + length; const { fileSize } = this; if (fileSize !== null) { top = Math.min(top, fileSize); } const firstBlockOffset = Math.floor(offset / this.blockSize) * this.blockSize; for (let current = firstBlockOffset; current < top; current += this.blockSize) { const blockId = Math.floor(current / this.blockSize); if (!this.blockCache.has(blockId) && !this.blockRequests.has(blockId)) { this.blockIdsToFetch.add(blockId); missingBlockIds.push(blockId); } if (this.blockRequests.has(blockId)) { blockRequests.push(this.blockRequests.get(blockId)); } allBlockIds.push(blockId); } } await wait(); this.fetchBlocks(signal); const missingRequests = []; for (const blockId of missingBlockIds) { if (this.blockRequests.has(blockId)) { missingRequests.push(this.blockRequests.get(blockId)); } } await Promise.allSettled(blockRequests); await Promise.allSettled(missingRequests); const abortedBlockRequests = []; const abortedBlockIds = allBlockIds.filter((id) => this.abortedBlockIds.has(id) || !this.blockCache.has(id)); abortedBlockIds.forEach((id) => this.blockIdsToFetch.add(id)); if (abortedBlockIds.length > 0 && signal && !signal.aborted) { this.fetchBlocks(null); for (const blockId of abortedBlockIds) { const block = this.blockRequests.get(blockId); if (!block) { throw new Error(`Block ${blockId} is not in the block requests`); } abortedBlockRequests.push(block); } await Promise.allSettled(abortedBlockRequests); } if (signal && signal.aborted) { throw new AbortError("Request was aborted"); } const blocks = allBlockIds.map((id) => this.blockCache.get(id) || this.evictedBlocks.get(id)); const failedBlocks = blocks.filter((i) => !i); if (failedBlocks.length) { throw new AggregateError(failedBlocks, "Request failed"); } const requiredBlocks = new Map(zip(allBlockIds, blocks)); return this.readSliceData(slices, requiredBlocks); } /** * * @param {AbortSignal} signal */ fetchBlocks(signal) { if (this.blockIdsToFetch.size > 0) { const groups = this.groupBlocks(this.blockIdsToFetch); const groupRequests = this.source.fetch(groups, signal); for (let groupIndex = 0; groupIndex < groups.length; ++groupIndex) { const group = groups[groupIndex]; for (const blockId of group.blockIds) { this.blockRequests.set(blockId, (async () => { try { const response = (await groupRequests)[groupIndex]; const blockOffset = blockId * this.blockSize; const o = blockOffset - response.offset; const t = Math.min(o + this.blockSize, response.data.byteLength); const data = response.data.slice(o, t); const block = new Block( blockOffset, data.byteLength, data, blockId ); this.blockCache.set(blockId, block); this.abortedBlockIds.delete(blockId); } catch (err) { if (err.name === "AbortError") { err.signal = signal; this.blockCache.delete(blockId); this.abortedBlockIds.add(blockId); } else { throw err; } } finally { this.blockRequests.delete(blockId); } })()); } } this.blockIdsToFetch.clear(); } } /** * * @param {Set} blockIds * @returns {BlockGroup[]} */ groupBlocks(blockIds) { const sortedBlockIds = Array.from(blockIds).sort((a, b) => a - b); if (sortedBlockIds.length === 0) { return []; } let current = []; let lastBlockId = null; const groups = []; for (const blockId of sortedBlockIds) { if (lastBlockId === null || lastBlockId + 1 === blockId) { current.push(blockId); lastBlockId = blockId; } else { groups.push(new BlockGroup( current[0] * this.blockSize, current.length * this.blockSize, current )); current = [blockId]; lastBlockId = blockId; } } groups.push(new BlockGroup( current[0] * this.blockSize, current.length * this.blockSize, current )); return groups; } /** * * @param {import("./basesource").Slice[]} slices * @param {Map} blocks */ readSliceData(slices, blocks) { return slices.map((slice) => { let top = slice.offset + slice.length; if (this.fileSize !== null) { top = Math.min(this.fileSize, top); } const blockIdLow = Math.floor(slice.offset / this.blockSize); const blockIdHigh = Math.floor(top / this.blockSize); const sliceData = new ArrayBuffer(slice.length); const sliceView = new Uint8Array(sliceData); for (let blockId = blockIdLow; blockId <= blockIdHigh; ++blockId) { const block = blocks.get(blockId); const delta = block.offset - slice.offset; const topDelta = block.top - top; let blockInnerOffset = 0; let rangeInnerOffset = 0; let usedBlockLength; if (delta < 0) { blockInnerOffset = -delta; } else if (delta > 0) { rangeInnerOffset = delta; } if (topDelta < 0) { usedBlockLength = block.length - blockInnerOffset; } else { usedBlockLength = top - block.offset - blockInnerOffset; } const blockView = new Uint8Array(block.data, blockInnerOffset, usedBlockLength); sliceView.set(blockView, rangeInnerOffset); } return sliceData; }); } }; // node_modules/geotiff/dist-module/source/client/base.js var BaseResponse = class { /** * Returns whether the response has an ok'ish status code */ get ok() { return this.status >= 200 && this.status <= 299; } /** * Returns the status code of the response */ get status() { throw new Error("not implemented"); } /** * Returns the value of the specified header * @param {string} headerName the header name * @returns {string} the header value */ getHeader(headerName) { throw new Error("not implemented"); } /** * @returns {ArrayBuffer} the response data of the request */ async getData() { throw new Error("not implemented"); } }; var BaseClient = class { constructor(url) { this.url = url; } /** * Send a request with the options * @param {{headers: HeadersInit, signal: AbortSignal}} [options={}] * @returns {Promise} */ async request({ headers, signal } = {}) { throw new Error("request is not implemented"); } }; // node_modules/geotiff/dist-module/source/client/fetch.js var FetchResponse = class extends BaseResponse { /** * BaseResponse facade for fetch API Response * @param {Response} response */ constructor(response) { super(); this.response = response; } get status() { return this.response.status; } getHeader(name) { return this.response.headers.get(name); } async getData() { const data = this.response.arrayBuffer ? await this.response.arrayBuffer() : (await this.response.buffer()).buffer; return data; } }; var FetchClient = class extends BaseClient { constructor(url, credentials) { super(url); this.credentials = credentials; } /** * @param {{headers: HeadersInit, signal: AbortSignal}} [options={}] * @returns {Promise} */ async request({ headers, signal } = {}) { const response = await fetch(this.url, { headers, credentials: this.credentials, signal }); return new FetchResponse(response); } }; // node_modules/geotiff/dist-module/source/client/xhr.js var XHRResponse = class extends BaseResponse { /** * BaseResponse facade for XMLHttpRequest * @param {XMLHttpRequest} xhr * @param {ArrayBuffer} data */ constructor(xhr, data) { super(); this.xhr = xhr; this.data = data; } get status() { return this.xhr.status; } getHeader(name) { return this.xhr.getResponseHeader(name); } async getData() { return this.data; } }; var XHRClient = class extends BaseClient { constructRequest(headers, signal) { return new Promise((resolve, reject) => { const xhr = new XMLHttpRequest(); xhr.open("GET", this.url); xhr.responseType = "arraybuffer"; for (const [key, value] of Object.entries(headers)) { xhr.setRequestHeader(key, value); } xhr.onload = () => { const data = xhr.response; resolve(new XHRResponse(xhr, data)); }; xhr.onerror = reject; xhr.onabort = () => reject(new AbortError("Request aborted")); xhr.send(); if (signal) { if (signal.aborted) { xhr.abort(); } signal.addEventListener("abort", () => xhr.abort()); } }); } async request({ headers, signal } = {}) { const response = await this.constructRequest(headers, signal); return response; } }; // node_modules/geotiff/dist-module/source/client/http.js var import_http = __toESM(require_http(), 1); var import_https = __toESM(require_https(), 1); var import_url = __toESM(require_url(), 1); var HttpResponse = class extends BaseResponse { /** * BaseResponse facade for node HTTP/HTTPS API Response * @param {http.ServerResponse} response */ constructor(response, dataPromise) { super(); this.response = response; this.dataPromise = dataPromise; } get status() { return this.response.statusCode; } getHeader(name) { return this.response.headers[name]; } async getData() { const data = await this.dataPromise; return data; } }; var HttpClient = class extends BaseClient { constructor(url) { super(url); this.parsedUrl = import_url.default.parse(this.url); this.httpApi = this.parsedUrl.protocol === "http:" ? import_http.default : import_https.default; } constructRequest(headers, signal) { return new Promise((resolve, reject) => { const request = this.httpApi.get( { ...this.parsedUrl, headers }, (response) => { const dataPromise = new Promise((resolveData) => { const chunks = []; response.on("data", (chunk) => { chunks.push(chunk); }); response.on("end", () => { const data = Buffer.concat(chunks).buffer; resolveData(data); }); response.on("error", reject); }); resolve(new HttpResponse(response, dataPromise)); } ); request.on("error", reject); if (signal) { if (signal.aborted) { request.destroy(new AbortError("Request aborted")); } signal.addEventListener("abort", () => request.destroy(new AbortError("Request aborted"))); } }); } async request({ headers, signal } = {}) { const response = await this.constructRequest(headers, signal); return response; } }; // node_modules/geotiff/dist-module/source/remote.js var RemoteSource = class extends BaseSource { /** * * @param {BaseClient} client * @param {object} headers * @param {numbers} maxRanges * @param {boolean} allowFullFile */ constructor(client, headers, maxRanges, allowFullFile) { super(); this.client = client; this.headers = headers; this.maxRanges = maxRanges; this.allowFullFile = allowFullFile; this._fileSize = null; } /** * * @param {Slice[]} slices */ async fetch(slices, signal) { if (this.maxRanges >= slices.length) { return this.fetchSlices(slices, signal); } else if (this.maxRanges > 0 && slices.length > 1) { } return Promise.all( slices.map((slice) => this.fetchSlice(slice, signal)) ); } async fetchSlices(slices, signal) { const response = await this.client.request({ headers: { ...this.headers, Range: `bytes=${slices.map(({ offset, length }) => `${offset}-${offset + length}`).join(",")}` }, signal }); if (!response.ok) { throw new Error("Error fetching data."); } else if (response.status === 206) { const { type, params } = parseContentType(response.getHeader("content-type")); if (type === "multipart/byteranges") { const byteRanges = parseByteRanges(await response.getData(), params.boundary); this._fileSize = byteRanges[0].fileSize || null; return byteRanges; } const data = await response.getData(); const { start, end, total } = parseContentRange(response.getHeader("content-range")); this._fileSize = total || null; const first = [{ data, offset: start, length: end - start }]; if (slices.length > 1) { const others = await Promise.all(slices.slice(1).map((slice) => this.fetchSlice(slice, signal))); return first.concat(others); } return first; } else { if (!this.allowFullFile) { throw new Error("Server responded with full file"); } const data = await response.getData(); this._fileSize = data.byteLength; return [{ data, offset: 0, length: data.byteLength }]; } } async fetchSlice(slice, signal) { const { offset, length } = slice; const response = await this.client.request({ headers: { ...this.headers, Range: `bytes=${offset}-${offset + length}` }, signal }); if (!response.ok) { throw new Error("Error fetching data."); } else if (response.status === 206) { const data = await response.getData(); const { total } = parseContentRange(response.getHeader("content-range")); this._fileSize = total || null; return { data, offset, length }; } else { if (!this.allowFullFile) { throw new Error("Server responded with full file"); } const data = await response.getData(); this._fileSize = data.byteLength; return { data, offset: 0, length: data.byteLength }; } } get fileSize() { return this._fileSize; } }; function maybeWrapInBlockedSource(source, { blockSize, cacheSize }) { if (blockSize === null) { return source; } return new BlockedSource(source, { blockSize, cacheSize }); } function makeFetchSource(url, { headers = {}, credentials, maxRanges = 0, allowFullFile = false, ...blockOptions } = {}) { const client = new FetchClient(url, credentials); const source = new RemoteSource(client, headers, maxRanges, allowFullFile); return maybeWrapInBlockedSource(source, blockOptions); } function makeXHRSource(url, { headers = {}, maxRanges = 0, allowFullFile = false, ...blockOptions } = {}) { const client = new XHRClient(url); const source = new RemoteSource(client, headers, maxRanges, allowFullFile); return maybeWrapInBlockedSource(source, blockOptions); } function makeHttpSource(url, { headers = {}, maxRanges = 0, allowFullFile = false, ...blockOptions } = {}) { const client = new HttpClient(url); const source = new RemoteSource(client, headers, maxRanges, allowFullFile); return maybeWrapInBlockedSource(source, blockOptions); } function makeRemoteSource(url, { forceXHR = false, ...clientOptions } = {}) { if (typeof fetch === "function" && !forceXHR) { return makeFetchSource(url, clientOptions); } if (typeof XMLHttpRequest !== "undefined") { return makeXHRSource(url, clientOptions); } return makeHttpSource(url, clientOptions); } // node_modules/geotiff/dist-module/source/filereader.js var FileReaderSource = class extends BaseSource { constructor(file) { super(); this.file = file; } async fetchSlice(slice, signal) { return new Promise((resolve, reject) => { const blob = this.file.slice(slice.offset, slice.offset + slice.length); const reader = new FileReader(); reader.onload = (event) => resolve(event.target.result); reader.onerror = reject; reader.onabort = reject; reader.readAsArrayBuffer(blob); if (signal) { signal.addEventListener("abort", () => reader.abort()); } }); } }; function makeFileReaderSource(file) { return new FileReaderSource(file); } // node_modules/geotiff/dist-module/source/file.js var import_fs = __toESM(require_fs(), 1); // node_modules/geotiff/dist-module/geotiffwriter.js var tagName2Code = invert(fieldTagNames); var geoKeyName2Code = invert(geoKeyNames); var name2code = {}; assign(name2code, tagName2Code); assign(name2code, geoKeyName2Code); var typeName2byte = invert(fieldTypeNames); var _binBE = { nextZero: (data, o) => { let oincr = o; while (data[oincr] !== 0) { oincr++; } return oincr; }, readUshort: (buff, p) => { return buff[p] << 8 | buff[p + 1]; }, readShort: (buff, p) => { const a = _binBE.ui8; a[0] = buff[p + 1]; a[1] = buff[p + 0]; return _binBE.i16[0]; }, readInt: (buff, p) => { const a = _binBE.ui8; a[0] = buff[p + 3]; a[1] = buff[p + 2]; a[2] = buff[p + 1]; a[3] = buff[p + 0]; return _binBE.i32[0]; }, readUint: (buff, p) => { const a = _binBE.ui8; a[0] = buff[p + 3]; a[1] = buff[p + 2]; a[2] = buff[p + 1]; a[3] = buff[p + 0]; return _binBE.ui32[0]; }, readASCII: (buff, p, l) => { return l.map((i) => String.fromCharCode(buff[p + i])).join(""); }, readFloat: (buff, p) => { const a = _binBE.ui8; times(4, (i) => { a[i] = buff[p + 3 - i]; }); return _binBE.fl32[0]; }, readDouble: (buff, p) => { const a = _binBE.ui8; times(8, (i) => { a[i] = buff[p + 7 - i]; }); return _binBE.fl64[0]; }, writeUshort: (buff, p, n) => { buff[p] = n >> 8 & 255; buff[p + 1] = n & 255; }, writeUint: (buff, p, n) => { buff[p] = n >> 24 & 255; buff[p + 1] = n >> 16 & 255; buff[p + 2] = n >> 8 & 255; buff[p + 3] = n >> 0 & 255; }, writeASCII: (buff, p, s) => { times(s.length, (i) => { buff[p + i] = s.charCodeAt(i); }); }, ui8: new Uint8Array(8) }; _binBE.fl64 = new Float64Array(_binBE.ui8.buffer); _binBE.writeDouble = (buff, p, n) => { _binBE.fl64[0] = n; times(8, (i) => { buff[p + i] = _binBE.ui8[7 - i]; }); }; // node_modules/geotiff/dist-module/logging.js var DummyLogger = class { log() { } debug() { } info() { } warn() { } error() { } time() { } timeEnd() { } }; var LOGGER = new DummyLogger(); // node_modules/geotiff/dist-module/geotiff.js function getFieldTypeLength(fieldType) { switch (fieldType) { case fieldTypes.BYTE: case fieldTypes.ASCII: case fieldTypes.SBYTE: case fieldTypes.UNDEFINED: return 1; case fieldTypes.SHORT: case fieldTypes.SSHORT: return 2; case fieldTypes.LONG: case fieldTypes.SLONG: case fieldTypes.FLOAT: case fieldTypes.IFD: return 4; case fieldTypes.RATIONAL: case fieldTypes.SRATIONAL: case fieldTypes.DOUBLE: case fieldTypes.LONG8: case fieldTypes.SLONG8: case fieldTypes.IFD8: return 8; default: throw new RangeError(`Invalid field type: ${fieldType}`); } } function parseGeoKeyDirectory(fileDirectory) { const rawGeoKeyDirectory = fileDirectory.GeoKeyDirectory; if (!rawGeoKeyDirectory) { return null; } const geoKeyDirectory = {}; for (let i = 4; i <= rawGeoKeyDirectory[3] * 4; i += 4) { const key = geoKeyNames[rawGeoKeyDirectory[i]]; const location = rawGeoKeyDirectory[i + 1] ? fieldTagNames[rawGeoKeyDirectory[i + 1]] : null; const count = rawGeoKeyDirectory[i + 2]; const offset = rawGeoKeyDirectory[i + 3]; let value = null; if (!location) { value = offset; } else { value = fileDirectory[location]; if (typeof value === "undefined" || value === null) { throw new Error(`Could not get value of geoKey '${key}'.`); } else if (typeof value === "string") { value = value.substring(offset, offset + count - 1); } else if (value.subarray) { value = value.subarray(offset, offset + count); if (count === 1) { value = value[0]; } } } geoKeyDirectory[key] = value; } return geoKeyDirectory; } function getValues(dataSlice, fieldType, count, offset) { let values2 = null; let readMethod = null; const fieldTypeLength = getFieldTypeLength(fieldType); switch (fieldType) { case fieldTypes.BYTE: case fieldTypes.ASCII: case fieldTypes.UNDEFINED: values2 = new Uint8Array(count); readMethod = dataSlice.readUint8; break; case fieldTypes.SBYTE: values2 = new Int8Array(count); readMethod = dataSlice.readInt8; break; case fieldTypes.SHORT: values2 = new Uint16Array(count); readMethod = dataSlice.readUint16; break; case fieldTypes.SSHORT: values2 = new Int16Array(count); readMethod = dataSlice.readInt16; break; case fieldTypes.LONG: case fieldTypes.IFD: values2 = new Uint32Array(count); readMethod = dataSlice.readUint32; break; case fieldTypes.SLONG: values2 = new Int32Array(count); readMethod = dataSlice.readInt32; break; case fieldTypes.LONG8: case fieldTypes.IFD8: values2 = new Array(count); readMethod = dataSlice.readUint64; break; case fieldTypes.SLONG8: values2 = new Array(count); readMethod = dataSlice.readInt64; break; case fieldTypes.RATIONAL: values2 = new Uint32Array(count * 2); readMethod = dataSlice.readUint32; break; case fieldTypes.SRATIONAL: values2 = new Int32Array(count * 2); readMethod = dataSlice.readInt32; break; case fieldTypes.FLOAT: values2 = new Float32Array(count); readMethod = dataSlice.readFloat32; break; case fieldTypes.DOUBLE: values2 = new Float64Array(count); readMethod = dataSlice.readFloat64; break; default: throw new RangeError(`Invalid field type: ${fieldType}`); } if (!(fieldType === fieldTypes.RATIONAL || fieldType === fieldTypes.SRATIONAL)) { for (let i = 0; i < count; ++i) { values2[i] = readMethod.call( dataSlice, offset + i * fieldTypeLength ); } } else { for (let i = 0; i < count; i += 2) { values2[i] = readMethod.call( dataSlice, offset + i * fieldTypeLength ); values2[i + 1] = readMethod.call( dataSlice, offset + (i * fieldTypeLength + 4) ); } } if (fieldType === fieldTypes.ASCII) { return new TextDecoder("utf-8").decode(values2); } return values2; } var ImageFileDirectory = class { constructor(fileDirectory, geoKeyDirectory, nextIFDByteOffset) { this.fileDirectory = fileDirectory; this.geoKeyDirectory = geoKeyDirectory; this.nextIFDByteOffset = nextIFDByteOffset; } }; var GeoTIFFImageIndexError = class extends Error { constructor(index) { super(`No image at index ${index}`); this.index = index; } }; var GeoTIFFBase = class { /** * (experimental) Reads raster data from the best fitting image. This function uses * the image with the lowest resolution that is still a higher resolution than the * requested resolution. * When specified, the `bbox` option is translated to the `window` option and the * `resX` and `resY` to `width` and `height` respectively. * Then, the [readRasters]{@link GeoTIFFImage#readRasters} method of the selected * image is called and the result returned. * @see GeoTIFFImage.readRasters * @param {import('./geotiffimage').ReadRasterOptions} [options={}] optional parameters * @returns {Promise} the decoded array(s), with `height` and `width`, as a promise */ async readRasters(options = {}) { const { window: imageWindow, width, height } = options; let { resX, resY, bbox } = options; const firstImage = await this.getImage(); let usedImage = firstImage; const imageCount = await this.getImageCount(); const imgBBox = firstImage.getBoundingBox(); if (imageWindow && bbox) { throw new Error('Both "bbox" and "window" passed.'); } if (width || height) { if (imageWindow) { const [oX, oY] = firstImage.getOrigin(); const [rX, rY] = firstImage.getResolution(); bbox = [ oX + imageWindow[0] * rX, oY + imageWindow[1] * rY, oX + imageWindow[2] * rX, oY + imageWindow[3] * rY ]; } const usedBBox = bbox || imgBBox; if (width) { if (resX) { throw new Error("Both width and resX passed"); } resX = (usedBBox[2] - usedBBox[0]) / width; } if (height) { if (resY) { throw new Error("Both width and resY passed"); } resY = (usedBBox[3] - usedBBox[1]) / height; } } if (resX || resY) { const allImages = []; for (let i = 0; i < imageCount; ++i) { const image = await this.getImage(i); const { SubfileType: subfileType, NewSubfileType: newSubfileType } = image.fileDirectory; if (i === 0 || subfileType === 2 || newSubfileType & 1) { allImages.push(image); } } allImages.sort((a, b) => a.getWidth() - b.getWidth()); for (let i = 0; i < allImages.length; ++i) { const image = allImages[i]; const imgResX = (imgBBox[2] - imgBBox[0]) / image.getWidth(); const imgResY = (imgBBox[3] - imgBBox[1]) / image.getHeight(); usedImage = image; if (resX && resX > imgResX || resY && resY > imgResY) { break; } } } let wnd = imageWindow; if (bbox) { const [oX, oY] = firstImage.getOrigin(); const [imageResX, imageResY] = usedImage.getResolution(firstImage); wnd = [ Math.round((bbox[0] - oX) / imageResX), Math.round((bbox[1] - oY) / imageResY), Math.round((bbox[2] - oX) / imageResX), Math.round((bbox[3] - oY) / imageResY) ]; wnd = [ Math.min(wnd[0], wnd[2]), Math.min(wnd[1], wnd[3]), Math.max(wnd[0], wnd[2]), Math.max(wnd[1], wnd[3]) ]; } return usedImage.readRasters({ ...options, window: wnd }); } }; var GeoTIFF = class _GeoTIFF extends GeoTIFFBase { /** * @constructor * @param {*} source The datasource to read from. * @param {boolean} littleEndian Whether the image uses little endian. * @param {boolean} bigTiff Whether the image uses bigTIFF conventions. * @param {number} firstIFDOffset The numeric byte-offset from the start of the image * to the first IFD. * @param {GeoTIFFOptions} [options] further options. */ constructor(source, littleEndian, bigTiff, firstIFDOffset, options = {}) { super(); this.source = source; this.littleEndian = littleEndian; this.bigTiff = bigTiff; this.firstIFDOffset = firstIFDOffset; this.cache = options.cache || false; this.ifdRequests = []; this.ghostValues = null; } async getSlice(offset, size) { const fallbackSize = this.bigTiff ? 4048 : 1024; return new DataSlice( (await this.source.fetch([{ offset, length: typeof size !== "undefined" ? size : fallbackSize }]))[0], offset, this.littleEndian, this.bigTiff ); } /** * Instructs to parse an image file directory at the given file offset. * As there is no way to ensure that a location is indeed the start of an IFD, * this function must be called with caution (e.g only using the IFD offsets from * the headers or other IFDs). * @param {number} offset the offset to parse the IFD at * @returns {Promise} the parsed IFD */ async parseFileDirectoryAt(offset) { const entrySize = this.bigTiff ? 20 : 12; const offsetSize = this.bigTiff ? 8 : 2; let dataSlice = await this.getSlice(offset); const numDirEntries = this.bigTiff ? dataSlice.readUint64(offset) : dataSlice.readUint16(offset); const byteSize = numDirEntries * entrySize + (this.bigTiff ? 16 : 6); if (!dataSlice.covers(offset, byteSize)) { dataSlice = await this.getSlice(offset, byteSize); } const fileDirectory = {}; let i = offset + (this.bigTiff ? 8 : 2); for (let entryCount = 0; entryCount < numDirEntries; i += entrySize, ++entryCount) { const fieldTag = dataSlice.readUint16(i); const fieldType = dataSlice.readUint16(i + 2); const typeCount = this.bigTiff ? dataSlice.readUint64(i + 4) : dataSlice.readUint32(i + 4); let fieldValues; let value; const fieldTypeLength = getFieldTypeLength(fieldType); const valueOffset = i + (this.bigTiff ? 12 : 8); if (fieldTypeLength * typeCount <= (this.bigTiff ? 8 : 4)) { fieldValues = getValues(dataSlice, fieldType, typeCount, valueOffset); } else { const actualOffset = dataSlice.readOffset(valueOffset); const length = getFieldTypeLength(fieldType) * typeCount; if (dataSlice.covers(actualOffset, length)) { fieldValues = getValues(dataSlice, fieldType, typeCount, actualOffset); } else { const fieldDataSlice = await this.getSlice(actualOffset, length); fieldValues = getValues(fieldDataSlice, fieldType, typeCount, actualOffset); } } if (typeCount === 1 && arrayFields.indexOf(fieldTag) === -1 && !(fieldType === fieldTypes.RATIONAL || fieldType === fieldTypes.SRATIONAL)) { value = fieldValues[0]; } else { value = fieldValues; } fileDirectory[fieldTagNames[fieldTag]] = value; } const geoKeyDirectory = parseGeoKeyDirectory(fileDirectory); const nextIFDByteOffset = dataSlice.readOffset( offset + offsetSize + entrySize * numDirEntries ); return new ImageFileDirectory( fileDirectory, geoKeyDirectory, nextIFDByteOffset ); } async requestIFD(index) { if (this.ifdRequests[index]) { return this.ifdRequests[index]; } else if (index === 0) { this.ifdRequests[index] = this.parseFileDirectoryAt(this.firstIFDOffset); return this.ifdRequests[index]; } else if (!this.ifdRequests[index - 1]) { try { this.ifdRequests[index - 1] = this.requestIFD(index - 1); } catch (e) { if (e instanceof GeoTIFFImageIndexError) { throw new GeoTIFFImageIndexError(index); } throw e; } } this.ifdRequests[index] = (async () => { const previousIfd = await this.ifdRequests[index - 1]; if (previousIfd.nextIFDByteOffset === 0) { throw new GeoTIFFImageIndexError(index); } return this.parseFileDirectoryAt(previousIfd.nextIFDByteOffset); })(); return this.ifdRequests[index]; } /** * Get the n-th internal subfile of an image. By default, the first is returned. * * @param {number} [index=0] the index of the image to return. * @returns {Promise} the image at the given index */ async getImage(index = 0) { const ifd = await this.requestIFD(index); return new geotiffimage_default( ifd.fileDirectory, ifd.geoKeyDirectory, this.dataView, this.littleEndian, this.cache, this.source ); } /** * Returns the count of the internal subfiles. * * @returns {Promise} the number of internal subfile images */ async getImageCount() { let index = 0; let hasNext = true; while (hasNext) { try { await this.requestIFD(index); ++index; } catch (e) { if (e instanceof GeoTIFFImageIndexError) { hasNext = false; } else { throw e; } } } return index; } /** * Get the values of the COG ghost area as a parsed map. * See https://gdal.org/drivers/raster/cog.html#header-ghost-area for reference * @returns {Promise} the parsed ghost area or null, if no such area was found */ async getGhostValues() { const offset = this.bigTiff ? 16 : 8; if (this.ghostValues) { return this.ghostValues; } const detectionString = "GDAL_STRUCTURAL_METADATA_SIZE="; const heuristicAreaSize = detectionString.length + 100; let slice = await this.getSlice(offset, heuristicAreaSize); if (detectionString === getValues(slice, fieldTypes.ASCII, detectionString.length, offset)) { const valuesString = getValues(slice, fieldTypes.ASCII, heuristicAreaSize, offset); const firstLine = valuesString.split("\n")[0]; const metadataSize = Number(firstLine.split("=")[1].split(" ")[0]) + firstLine.length; if (metadataSize > heuristicAreaSize) { slice = await this.getSlice(offset, metadataSize); } const fullString = getValues(slice, fieldTypes.ASCII, metadataSize, offset); this.ghostValues = {}; fullString.split("\n").filter((line) => line.length > 0).map((line) => line.split("=")).forEach(([key, value]) => { this.ghostValues[key] = value; }); } return this.ghostValues; } /** * Parse a (Geo)TIFF file from the given source. * * @param {*} source The source of data to parse from. * @param {GeoTIFFOptions} [options] Additional options. * @param {AbortSignal} [signal] An AbortSignal that may be signalled if the request is * to be aborted */ static async fromSource(source, options, signal) { const headerData = (await source.fetch([{ offset: 0, length: 1024 }], signal))[0]; const dataView = new DataView64(headerData); const BOM = dataView.getUint16(0, 0); let littleEndian; if (BOM === 18761) { littleEndian = true; } else if (BOM === 19789) { littleEndian = false; } else { throw new TypeError("Invalid byte order value."); } const magicNumber = dataView.getUint16(2, littleEndian); let bigTiff; if (magicNumber === 42) { bigTiff = false; } else if (magicNumber === 43) { bigTiff = true; const offsetByteSize = dataView.getUint16(4, littleEndian); if (offsetByteSize !== 8) { throw new Error("Unsupported offset byte-size."); } } else { throw new TypeError("Invalid magic number."); } const firstIFDOffset = bigTiff ? dataView.getUint64(8, littleEndian) : dataView.getUint32(4, littleEndian); return new _GeoTIFF(source, littleEndian, bigTiff, firstIFDOffset, options); } /** * Closes the underlying file buffer * N.B. After the GeoTIFF has been completely processed it needs * to be closed but only if it has been constructed from a file. */ close() { if (typeof this.source.close === "function") { return this.source.close(); } return false; } }; var MultiGeoTIFF = class extends GeoTIFFBase { /** * Construct a new MultiGeoTIFF from a main and several overview files. * @param {GeoTIFF} mainFile The main GeoTIFF file. * @param {GeoTIFF[]} overviewFiles An array of overview files. */ constructor(mainFile, overviewFiles) { super(); this.mainFile = mainFile; this.overviewFiles = overviewFiles; this.imageFiles = [mainFile].concat(overviewFiles); this.fileDirectoriesPerFile = null; this.fileDirectoriesPerFileParsing = null; this.imageCount = null; } async parseFileDirectoriesPerFile() { const requests = [this.mainFile.parseFileDirectoryAt(this.mainFile.firstIFDOffset)].concat(this.overviewFiles.map((file) => file.parseFileDirectoryAt(file.firstIFDOffset))); this.fileDirectoriesPerFile = await Promise.all(requests); return this.fileDirectoriesPerFile; } /** * Get the n-th internal subfile of an image. By default, the first is returned. * * @param {number} [index=0] the index of the image to return. * @returns {Promise} the image at the given index */ async getImage(index = 0) { await this.getImageCount(); await this.parseFileDirectoriesPerFile(); let visited = 0; let relativeIndex = 0; for (let i = 0; i < this.imageFiles.length; i++) { const imageFile = this.imageFiles[i]; for (let ii = 0; ii < this.imageCounts[i]; ii++) { if (index === visited) { const ifd = await imageFile.requestIFD(relativeIndex); return new geotiffimage_default( ifd.fileDirectory, ifd.geoKeyDirectory, imageFile.dataView, imageFile.littleEndian, imageFile.cache, imageFile.source ); } visited++; relativeIndex++; } relativeIndex = 0; } throw new RangeError("Invalid image index"); } /** * Returns the count of the internal subfiles. * * @returns {Promise} the number of internal subfile images */ async getImageCount() { if (this.imageCount !== null) { return this.imageCount; } const requests = [this.mainFile.getImageCount()].concat(this.overviewFiles.map((file) => file.getImageCount())); this.imageCounts = await Promise.all(requests); this.imageCount = this.imageCounts.reduce((count, ifds) => count + ifds, 0); return this.imageCount; } }; async function fromUrl(url, options = {}, signal) { return GeoTIFF.fromSource(makeRemoteSource(url, options), signal); } async function fromBlob(blob, signal) { return GeoTIFF.fromSource(makeFileReaderSource(blob), signal); } async function fromUrls(mainUrl, overviewUrls = [], options = {}, signal) { const mainFile = await GeoTIFF.fromSource(makeRemoteSource(mainUrl, options), signal); const overviewFiles = await Promise.all( overviewUrls.map((url) => GeoTIFF.fromSource(makeRemoteSource(url, options))) ); return new MultiGeoTIFF(mainFile, overviewFiles); } // node_modules/ol/source/GeoTIFF.js function isMask(image) { const fileDirectory = image.fileDirectory; const type = fileDirectory.NewSubfileType || 0; return (type & 4) === 4; } function readRGB(preference, image) { if (!preference) { return false; } if (preference === true) { return true; } if (image.getSamplesPerPixel() !== 3) { return false; } const interpretation = image.fileDirectory.PhotometricInterpretation; const interpretations = globals_exports.photometricInterpretations; return interpretation === interpretations.CMYK || interpretation === interpretations.YCbCr || interpretation === interpretations.CIELab || interpretation === interpretations.ICCLab; } var STATISTICS_MAXIMUM = "STATISTICS_MAXIMUM"; var STATISTICS_MINIMUM = "STATISTICS_MINIMUM"; var defaultTileSize = 256; var workerPool; function getWorkerPool() { if (!workerPool) { workerPool = new pool_default(); } return workerPool; } function getBoundingBox(image) { try { return image.getBoundingBox(true); } catch { return [0, 0, image.getWidth(), image.getHeight()]; } } function getOrigin(image) { try { return image.getOrigin().slice(0, 2); } catch { return [0, image.getHeight()]; } } function getResolutions(image, referenceImage) { try { return image.getResolution(referenceImage); } catch { return [ referenceImage.getWidth() / image.getWidth(), referenceImage.getHeight() / image.getHeight() ]; } } function getProjection(image) { const geoKeys = image.geoKeys; if (!geoKeys) { return null; } if (geoKeys.ProjectedCSTypeGeoKey && geoKeys.ProjectedCSTypeGeoKey !== 32767) { const code = "EPSG:" + geoKeys.ProjectedCSTypeGeoKey; let projection = get(code); if (!projection) { const units = fromCode(geoKeys.ProjLinearUnitsGeoKey); if (units) { projection = new Projection_default({ code, units }); } } return projection; } if (geoKeys.GeographicTypeGeoKey && geoKeys.GeographicTypeGeoKey !== 32767) { const code = "EPSG:" + geoKeys.GeographicTypeGeoKey; let projection = get(code); if (!projection) { const units = fromCode(geoKeys.GeogAngularUnitsGeoKey); if (units) { projection = new Projection_default({ code, units }); } } return projection; } return null; } function getImagesForTIFF(tiff) { return tiff.getImageCount().then(function(count) { const requests = new Array(count); for (let i = 0; i < count; ++i) { requests[i] = tiff.getImage(i); } return Promise.all(requests); }); } function getImagesForSource(source, options) { let request; if (source.blob) { request = fromBlob(source.blob); } else if (source.overviews) { request = fromUrls(source.url, source.overviews, options); } else { request = fromUrl(source.url, options); } return request.then(getImagesForTIFF); } function assertEqual(expected, got, tolerance, message, rejector) { if (Array.isArray(expected)) { const length = expected.length; if (!Array.isArray(got) || length != got.length) { const error2 = new Error(message); rejector(error2); throw error2; } for (let i = 0; i < length; ++i) { assertEqual(expected[i], got[i], tolerance, message, rejector); } return; } got = /** @type {number} */ got; if (Math.abs(expected - got) > tolerance * expected) { throw new Error(message); } } function getMinForDataType(array) { if (array instanceof Int8Array) { return -128; } if (array instanceof Int16Array) { return -32768; } if (array instanceof Int32Array) { return -2147483648; } if (array instanceof Float32Array) { return 12e-39; } return 0; } function getMaxForDataType(array) { if (array instanceof Int8Array) { return 127; } if (array instanceof Uint8Array) { return 255; } if (array instanceof Uint8ClampedArray) { return 255; } if (array instanceof Int16Array) { return 32767; } if (array instanceof Uint16Array) { return 65535; } if (array instanceof Int32Array) { return 2147483647; } if (array instanceof Uint32Array) { return 4294967295; } if (array instanceof Float32Array) { return 34e37; } return 255; } var GeoTIFFSource = class extends DataTile_default3 { /** * @param {Options} options Data tile options. */ constructor(options) { super({ state: "loading", tileGrid: null, projection: options.projection || null, transition: options.transition, interpolate: options.interpolate !== false, wrapX: options.wrapX }); this.sourceInfo_ = options.sources; const numSources = this.sourceInfo_.length; this.sourceOptions_ = options.sourceOptions; this.sourceImagery_ = new Array(numSources); this.sourceMasks_ = new Array(numSources); this.resolutionFactors_ = new Array(numSources); this.samplesPerPixel_; this.nodataValues_; this.metadata_; this.normalize_ = options.normalize !== false; this.addAlpha_ = false; this.error_ = null; this.convertToRGB_ = options.convertToRGB || false; this.setKey(this.sourceInfo_.map((source) => source.url).join(",")); const self = this; const requests = new Array(numSources); for (let i = 0; i < numSources; ++i) { requests[i] = getImagesForSource( this.sourceInfo_[i], this.sourceOptions_ ); } Promise.all(requests).then(function(sources) { self.configure_(sources); }).catch(function(error2) { error(error2); self.error_ = error2; self.setState("error"); }); } /** * @return {Error} A source loading error. When the source state is `error`, use this function * to get more information about the error. To debug a faulty configuration, you may want to use * a listener like * ```js * geotiffSource.on('change', () => { * if (geotiffSource.getState() === 'error') { * console.error(geotiffSource.getError()); * } * }); * ``` */ getError() { return this.error_; } /** * Determine the projection of the images in this GeoTIFF. * The default implementation looks at the ProjectedCSTypeGeoKey and the GeographicTypeGeoKey * of each image in turn. * You can override this method in a subclass to support more projections. * * @param {Array>} sources Each source is a list of images * from a single GeoTIFF. */ determineProjection(sources) { const firstSource = sources[0]; for (let i = firstSource.length - 1; i >= 0; --i) { const image = firstSource[i]; const projection = getProjection(image); if (projection) { this.projection = projection; break; } } } /** * Determine any transform matrix for the images in this GeoTIFF. * * @param {Array>} sources Each source is a list of images * from a single GeoTIFF. */ determineTransformMatrix(sources) { const firstSource = sources[0]; for (let i = firstSource.length - 1; i >= 0; --i) { const image = firstSource[i]; const modelTransformation = image.fileDirectory.ModelTransformation; if (modelTransformation) { const [a, b, c, d, e, f, g, h] = modelTransformation; const matrix = multiply( multiply( [ 1 / Math.sqrt(a * a + e * e), 0, 0, -1 / Math.sqrt(b * b + f * f), d, h ], [a, e, b, f, 0, 0] ), [1, 0, 0, 1, -d, -h] ); this.transformMatrix = matrix; this.addAlpha_ = true; break; } } } /** * Configure the tile grid based on images within the source GeoTIFFs. Each GeoTIFF * must have the same internal tiled structure. * @param {Array>} sources Each source is a list of images * from a single GeoTIFF. * @private */ configure_(sources) { let extent; let origin; let commonRenderTileSizes; let commonSourceTileSizes; let resolutions; const samplesPerPixel = new Array(sources.length); const nodataValues = new Array(sources.length); const metadata = new Array(sources.length); let minZoom = 0; const sourceCount = sources.length; for (let sourceIndex = 0; sourceIndex < sourceCount; ++sourceIndex) { const images = []; const masks = []; sources[sourceIndex].forEach((item) => { if (isMask(item)) { masks.push(item); } else { images.push(item); } }); const imageCount = images.length; if (masks.length > 0 && masks.length !== imageCount) { throw new Error( `Expected one mask per image found ${masks.length} masks and ${imageCount} images` ); } let sourceExtent; let sourceOrigin; const sourceTileSizes = new Array(imageCount); const renderTileSizes = new Array(imageCount); const sourceResolutions = new Array(imageCount); nodataValues[sourceIndex] = new Array(imageCount); metadata[sourceIndex] = new Array(imageCount); for (let imageIndex = 0; imageIndex < imageCount; ++imageIndex) { const image = images[imageIndex]; const nodataValue = image.getGDALNoData(); metadata[sourceIndex][imageIndex] = image.getGDALMetadata(0); nodataValues[sourceIndex][imageIndex] = nodataValue; const wantedSamples = this.sourceInfo_[sourceIndex].bands; samplesPerPixel[sourceIndex] = wantedSamples ? wantedSamples.length : image.getSamplesPerPixel(); const level = imageCount - (imageIndex + 1); if (!sourceExtent) { sourceExtent = getBoundingBox(image); } if (!sourceOrigin) { sourceOrigin = getOrigin(image); } const imageResolutions = getResolutions(image, images[0]); sourceResolutions[level] = imageResolutions[0]; const sourceTileSize = [image.getTileWidth(), image.getTileHeight()]; if (sourceTileSize[0] !== sourceTileSize[1] && sourceTileSize[1] < defaultTileSize) { sourceTileSize[0] = defaultTileSize; sourceTileSize[1] = defaultTileSize; } sourceTileSizes[level] = sourceTileSize; const aspectRatio = imageResolutions[0] / Math.abs(imageResolutions[1]); renderTileSizes[level] = [ sourceTileSize[0], sourceTileSize[1] / aspectRatio ]; } if (!extent) { extent = sourceExtent; } else { getIntersection(extent, sourceExtent, extent); } if (!origin) { origin = sourceOrigin; } else { const message = `Origin mismatch for source ${sourceIndex}, got [${sourceOrigin}] but expected [${origin}]`; assertEqual(origin, sourceOrigin, 0, message, this.viewRejector); } if (!resolutions) { resolutions = sourceResolutions; this.resolutionFactors_[sourceIndex] = 1; } else { if (resolutions.length - minZoom > sourceResolutions.length) { minZoom = resolutions.length - sourceResolutions.length; } const resolutionFactor = resolutions[resolutions.length - 1] / sourceResolutions[sourceResolutions.length - 1]; this.resolutionFactors_[sourceIndex] = resolutionFactor; const scaledSourceResolutions = sourceResolutions.map( (resolution) => resolution *= resolutionFactor ); const message = `Resolution mismatch for source ${sourceIndex}, got [${scaledSourceResolutions}] but expected [${resolutions}]`; assertEqual( resolutions.slice(minZoom, resolutions.length), scaledSourceResolutions, 0.02, message, this.viewRejector ); } if (!commonRenderTileSizes) { commonRenderTileSizes = renderTileSizes; } else { assertEqual( commonRenderTileSizes.slice(minZoom, commonRenderTileSizes.length), renderTileSizes, 0.01, `Tile size mismatch for source ${sourceIndex}`, this.viewRejector ); } if (!commonSourceTileSizes) { commonSourceTileSizes = sourceTileSizes; } else { assertEqual( commonSourceTileSizes.slice(minZoom, commonSourceTileSizes.length), sourceTileSizes, 0, `Tile size mismatch for source ${sourceIndex}`, this.viewRejector ); } this.sourceImagery_[sourceIndex] = images.reverse(); this.sourceMasks_[sourceIndex] = masks.reverse(); } for (let i = 0, ii = this.sourceImagery_.length; i < ii; ++i) { const sourceImagery = this.sourceImagery_[i]; while (sourceImagery.length < resolutions.length) { sourceImagery.unshift(void 0); } } if (!this.getProjection()) { this.determineProjection(sources); } this.determineTransformMatrix(sources); this.samplesPerPixel_ = samplesPerPixel; this.nodataValues_ = nodataValues; this.metadata_ = metadata; outer: for (let sourceIndex = 0; sourceIndex < sourceCount; ++sourceIndex) { if (this.sourceInfo_[sourceIndex].nodata !== void 0) { this.addAlpha_ = true; break; } if (this.sourceMasks_[sourceIndex].length) { this.addAlpha_ = true; break; } const values2 = nodataValues[sourceIndex]; const bands = this.sourceInfo_[sourceIndex].bands; if (bands) { for (let i = 0; i < bands.length; ++i) { if (values2[bands[i] - 1] !== null) { this.addAlpha_ = true; break outer; } } continue; } for (let imageIndex = 0; imageIndex < values2.length; ++imageIndex) { if (values2[imageIndex] !== null) { this.addAlpha_ = true; break outer; } } } let bandCount = this.addAlpha_ ? 1 : 0; for (let sourceIndex = 0; sourceIndex < sourceCount; ++sourceIndex) { bandCount += samplesPerPixel[sourceIndex]; } this.bandCount = bandCount; const tileGrid = new TileGrid_default({ extent, minZoom, origin, resolutions, tileSizes: commonRenderTileSizes }); this.tileGrid = tileGrid; this.setTileSizes(commonSourceTileSizes); this.setLoader(this.loadTile_.bind(this)); this.setState("ready"); const zoom = 1; if (resolutions.length === 2) { resolutions = [resolutions[0], resolutions[1], resolutions[1] / 2]; } else if (resolutions.length === 1) { resolutions = [resolutions[0] * 2, resolutions[0], resolutions[0] / 2]; } let viewExtent = extent; if (this.transformMatrix) { const matrix = makeInverse(create(), this.transformMatrix.slice()); const transformFn = createTransformFromCoordinateTransform( (input) => apply(matrix, input) ); viewExtent = applyTransform(extent, transformFn); } this.viewResolver({ showFullExtent: true, projection: this.projection, resolutions, center: toUserCoordinate(getCenter(viewExtent), this.projection), extent: toUserExtent(viewExtent, this.projection), zoom }); } /** * @param {number} z The z tile index. * @param {number} x The x tile index. * @param {number} y The y tile index. * @param {import('./DataTile.js').LoaderOptions} options The loader options. * @return {Promise} The composed tile data. * @private */ loadTile_(z, x, y, options) { const sourceTileSize = this.getTileSize(z); const sourceCount = this.sourceImagery_.length; const requests = new Array(sourceCount * 2); const nodataValues = this.nodataValues_; const sourceInfo = this.sourceInfo_; const pool = getWorkerPool(); for (let sourceIndex = 0; sourceIndex < sourceCount; ++sourceIndex) { const source = sourceInfo[sourceIndex]; const resolutionFactor = this.resolutionFactors_[sourceIndex]; const pixelBounds = [ Math.round(x * (sourceTileSize[0] * resolutionFactor)), Math.round(y * (sourceTileSize[1] * resolutionFactor)), Math.round((x + 1) * (sourceTileSize[0] * resolutionFactor)), Math.round((y + 1) * (sourceTileSize[1] * resolutionFactor)) ]; const image = this.sourceImagery_[sourceIndex][z]; let samples; if (source.bands) { samples = source.bands.map(function(bandNumber) { return bandNumber - 1; }); } let fillValue; if ("nodata" in source && source.nodata !== null) { fillValue = source.nodata; } else { if (!samples) { fillValue = nodataValues[sourceIndex]; } else { fillValue = samples.map(function(sampleIndex) { return nodataValues[sourceIndex][sampleIndex]; }); } } const readOptions = { window: pixelBounds, width: sourceTileSize[0], height: sourceTileSize[1], samples, fillValue, pool, interleave: false, signal: options.signal }; if (readRGB(this.convertToRGB_, image)) { requests[sourceIndex] = image.readRGB(readOptions); } else { requests[sourceIndex] = image.readRasters(readOptions); } const maskIndex = sourceCount + sourceIndex; const mask = this.sourceMasks_[sourceIndex][z]; if (!mask) { requests[maskIndex] = Promise.resolve(null); continue; } requests[maskIndex] = mask.readRasters({ window: pixelBounds, width: sourceTileSize[0], height: sourceTileSize[1], samples: [0], pool, interleave: false }); } return Promise.all(requests).then(this.composeTile_.bind(this, sourceTileSize)).catch(function(error2) { error(error2); throw error2; }); } /** * @param {import("../size.js").Size} sourceTileSize The source tile size. * @param {Array} sourceSamples The source samples. * @return {import("../DataTile.js").Data} The composed tile data. * @private */ composeTile_(sourceTileSize, sourceSamples) { const metadata = this.metadata_; const sourceInfo = this.sourceInfo_; const sourceCount = this.sourceImagery_.length; const bandCount = this.bandCount; const samplesPerPixel = this.samplesPerPixel_; const nodataValues = this.nodataValues_; const normalize = this.normalize_; const addAlpha = this.addAlpha_; const pixelCount = sourceTileSize[0] * sourceTileSize[1]; const dataLength = pixelCount * bandCount; let data; if (normalize) { data = new Uint8Array(dataLength); } else { data = new Float32Array(dataLength); } let dataIndex = 0; for (let pixelIndex = 0; pixelIndex < pixelCount; ++pixelIndex) { let transparent = addAlpha; for (let sourceIndex = 0; sourceIndex < sourceCount; ++sourceIndex) { const source = sourceInfo[sourceIndex]; let min = source.min; let max = source.max; let gain, bias; if (normalize) { const stats = metadata[sourceIndex][0]; if (min === void 0) { if (stats && STATISTICS_MINIMUM in stats) { min = parseFloat(stats[STATISTICS_MINIMUM]); } else { min = getMinForDataType(sourceSamples[sourceIndex][0]); } } if (max === void 0) { if (stats && STATISTICS_MAXIMUM in stats) { max = parseFloat(stats[STATISTICS_MAXIMUM]); } else { max = getMaxForDataType(sourceSamples[sourceIndex][0]); } } gain = 255 / (max - min); bias = -min * gain; } for (let sampleIndex = 0; sampleIndex < samplesPerPixel[sourceIndex]; ++sampleIndex) { const sourceValue = sourceSamples[sourceIndex][sampleIndex][pixelIndex]; let value; if (normalize) { value = clamp(gain * sourceValue + bias, 0, 255); } else { value = sourceValue; } if (!addAlpha) { data[dataIndex] = value; } else { let nodata = source.nodata; if (nodata === void 0) { let bandIndex; if (source.bands) { bandIndex = source.bands[sampleIndex] - 1; } else { bandIndex = sampleIndex; } nodata = nodataValues[sourceIndex][bandIndex]; } const nodataIsNaN = isNaN(nodata); if (!nodataIsNaN && sourceValue !== nodata || nodataIsNaN && !isNaN(sourceValue)) { transparent = false; data[dataIndex] = value; } } dataIndex++; } if (!transparent) { const maskIndex = sourceCount + sourceIndex; const mask = sourceSamples[maskIndex]; if (mask && !mask[0][pixelIndex]) { transparent = true; } } } if (addAlpha) { if (!transparent) { data[dataIndex] = 255; } dataIndex++; } } return data; } }; GeoTIFFSource.prototype.getView; var GeoTIFF_default = GeoTIFFSource; // node_modules/ol/source/Google.js var maxZoom = 22; var Google = class extends TileImage_default { /** * @param {Options} options Google Maps options. */ constructor(options) { const highDpi = !!options.highDpi; super({ attributionsCollapsible: options.attributionsCollapsible, cacheSize: options.cacheSize, crossOrigin: "anonymous", interpolate: options.interpolate, projection: "EPSG:3857", reprojectionErrorThreshold: options.reprojectionErrorThreshold, state: "loading", tileLoadFunction: options.tileLoadFunction, tilePixelRatio: highDpi ? 2 : 1, wrapX: options.wrapX !== void 0 ? options.wrapX : true, transition: options.transition, zDirection: options.zDirection }); this.apiKey_ = options.key; this.error_ = null; const sessionTokenRequest = { mapType: options.mapType || "roadmap", language: options.language || "en-US", region: options.region || "US" }; if (options.imageFormat) { sessionTokenRequest.imageFormat = options.imageFormat; } if (options.scale) { sessionTokenRequest.scale = options.scale; } if (highDpi) { sessionTokenRequest.highDpi = true; } if (options.layerTypes) { sessionTokenRequest.layerTypes = options.layerTypes; } if (options.styles) { sessionTokenRequest.styles = options.styles; } if (options.overlay === true) { sessionTokenRequest.overlay = true; } if (options.apiOptions) { sessionTokenRequest.apiOptions = options.apiOptions; } this.sessionTokenRequest_ = sessionTokenRequest; this.sessionTokenValue_; this.sessionRefreshId_; this.previousViewportAttribution_; this.previousViewportExtent_; const baseUrl = options.url || "https://tile.googleapis.com/"; this.createSessionUrl_ = baseUrl + "v1/createSession"; this.tileUrl_ = baseUrl + "v1/2dtiles"; this.attributionUrl_ = baseUrl + "tile/v1/viewport"; this.createSession_(); } /** * @return {Error|null} A source loading error. When the source state is `error`, use this function * to get more information about the error. To debug a faulty configuration, you may want to use * a listener like * ```js * source.on('change', () => { * if (source.getState() === 'error') { * console.error(source.getError()); * } * }); * ``` */ getError() { return this.error_; } /** * Exposed here so it can be overridden in the tests. * @param {string} url The URL. * @param {RequestInit} config The config. * @return {Promise} A promise that resolves with the response. */ fetchSessionToken(url, config) { return fetch(url, config); } /** * Get or renew a session token for use with tile requests. * @private */ async createSession_() { const url = this.createSessionUrl_ + "?key=" + this.apiKey_; const config = { method: "POST", headers: { "Content-Type": "application/json" }, body: JSON.stringify(this.sessionTokenRequest_) }; const response = await this.fetchSessionToken(url, config); if (!response.ok) { try { const body = await response.json(); this.error_ = new Error(body.error.message); } catch { this.error_ = new Error("Error fetching session token"); } this.setState("error"); return; } const sessionTokenResponse = await response.json(); const tilePixelRatio = this.getTilePixelRatio(1); const tileSize = [ sessionTokenResponse.tileWidth / tilePixelRatio, sessionTokenResponse.tileHeight / tilePixelRatio ]; this.tileGrid = createXYZ({ extent: extentFromProjection(this.getProjection()), maxZoom, tileSize }); const session = sessionTokenResponse.session; this.sessionTokenValue_ = session; const key = this.apiKey_; const tileUrl = this.tileUrl_; this.tileUrlFunction = function(tileCoord, pixelRatio, projection) { const z = tileCoord[0]; const x = tileCoord[1]; const y = tileCoord[2]; const url2 = `${tileUrl}/${z}/${x}/${y}?session=${session}&key=${key}`; return url2; }; const expiry = parseInt(sessionTokenResponse.expiry, 10) * 1e3; const timeout = Math.max(expiry - Date.now() - 60 * 1e3, 1); this.sessionRefreshId_ = setTimeout(() => this.createSession_(), timeout); this.setAttributions(this.fetchAttributions_.bind(this)); this.setState("ready"); } /** * @param {import('../Map.js').FrameState} frameState The frame state. * @return {Promise} The attributions. * @private */ async fetchAttributions_(frameState) { if (frameState.viewHints[ViewHint_default.ANIMATING] || frameState.viewHints[ViewHint_default.INTERACTING] || frameState.animate) { return this.previousViewportAttribution_; } const [west, south] = toLonLat( getBottomLeft(frameState.extent), frameState.viewState.projection ); const [east, north] = toLonLat( getTopRight(frameState.extent), frameState.viewState.projection ); const tileGrid = this.getTileGrid(); const zoom = tileGrid.getZForResolution( frameState.viewState.resolution, this.zDirection ); const viewportExtent = `zoom=${zoom}&north=${north}&south=${south}&east=${east}&west=${west}`; if (this.previousViewportExtent_ == viewportExtent) { return this.previousViewportAttribution_; } this.previousViewportExtent_ = viewportExtent; const session = this.sessionTokenValue_; const key = this.apiKey_; const attributionUrl = this.attributionUrl_; const url = `${attributionUrl}?session=${session}&key=${key}&${viewportExtent}`; this.previousViewportAttribution_ = await fetch(url).then((response) => response.json()).then((json) => json.copyright); return this.previousViewportAttribution_; } /** * @override */ disposeInternal() { clearTimeout(this.sessionRefreshId_); super.disposeInternal(); } }; var Google_default = Google; // node_modules/ol/format/IIIFInfo.js var Versions = { VERSION1: "version1", VERSION2: "version2", VERSION3: "version3" }; var IIIF_PROFILE_VALUES = {}; IIIF_PROFILE_VALUES[Versions.VERSION1] = { "level0": { supports: [], formats: [], qualities: ["native"] }, "level1": { supports: ["regionByPx", "sizeByW", "sizeByH", "sizeByPct"], formats: ["jpg"], qualities: ["native"] }, "level2": { supports: [ "regionByPx", "regionByPct", "sizeByW", "sizeByH", "sizeByPct", "sizeByConfinedWh", "sizeByWh" ], formats: ["jpg", "png"], qualities: ["native", "color", "grey", "bitonal"] } }; IIIF_PROFILE_VALUES[Versions.VERSION2] = { "level0": { supports: [], formats: ["jpg"], qualities: ["default"] }, "level1": { supports: ["regionByPx", "sizeByW", "sizeByH", "sizeByPct"], formats: ["jpg"], qualities: ["default"] }, "level2": { supports: [ "regionByPx", "regionByPct", "sizeByW", "sizeByH", "sizeByPct", "sizeByConfinedWh", "sizeByDistortedWh", "sizeByWh" ], formats: ["jpg", "png"], qualities: ["default", "bitonal"] } }; IIIF_PROFILE_VALUES[Versions.VERSION3] = { "level0": { supports: [], formats: ["jpg"], qualities: ["default"] }, "level1": { supports: ["regionByPx", "regionSquare", "sizeByW", "sizeByH", "sizeByWh"], formats: ["jpg"], qualities: ["default"] }, "level2": { supports: [ "regionByPx", "regionSquare", "regionByPct", "sizeByW", "sizeByH", "sizeByPct", "sizeByConfinedWh", "sizeByWh" ], formats: ["jpg", "png"], qualities: ["default"] } }; IIIF_PROFILE_VALUES["none"] = { "none": { supports: [], formats: [], qualities: [] } }; function generateVersion1Options(iiifInfo) { let levelProfile = iiifInfo.getComplianceLevelSupportedFeatures(); if (levelProfile === void 0) { levelProfile = IIIF_PROFILE_VALUES[Versions.VERSION1]["level0"]; } return { url: iiifInfo.imageInfo["@id"] === void 0 ? void 0 : iiifInfo.imageInfo["@id"].replace(/\/?(?:info\.json)?$/g, ""), supports: levelProfile.supports, formats: [ ...levelProfile.formats, iiifInfo.imageInfo.formats === void 0 ? [] : iiifInfo.imageInfo.formats ], qualities: [ ...levelProfile.qualities, iiifInfo.imageInfo.qualities === void 0 ? [] : iiifInfo.imageInfo.qualities ], resolutions: iiifInfo.imageInfo.scale_factors, tileSize: iiifInfo.imageInfo.tile_width !== void 0 ? iiifInfo.imageInfo.tile_height !== void 0 ? [iiifInfo.imageInfo.tile_width, iiifInfo.imageInfo.tile_height] : [iiifInfo.imageInfo.tile_width, iiifInfo.imageInfo.tile_width] : iiifInfo.imageInfo.tile_height != void 0 ? [iiifInfo.imageInfo.tile_height, iiifInfo.imageInfo.tile_height] : void 0 }; } function generateVersion2Options(iiifInfo) { const levelProfile = iiifInfo.getComplianceLevelSupportedFeatures(), additionalProfile = Array.isArray(iiifInfo.imageInfo.profile) && iiifInfo.imageInfo.profile.length > 1, profileSupports = additionalProfile && iiifInfo.imageInfo.profile[1].supports ? iiifInfo.imageInfo.profile[1].supports : [], profileFormats = additionalProfile && iiifInfo.imageInfo.profile[1].formats ? iiifInfo.imageInfo.profile[1].formats : [], profileQualities = additionalProfile && iiifInfo.imageInfo.profile[1].qualities ? iiifInfo.imageInfo.profile[1].qualities : []; return { url: iiifInfo.imageInfo["@id"].replace(/\/?(?:info\.json)?$/g, ""), sizes: iiifInfo.imageInfo.sizes === void 0 ? void 0 : iiifInfo.imageInfo.sizes.map(function(size) { return [size.width, size.height]; }), tileSize: iiifInfo.imageInfo.tiles === void 0 ? void 0 : [ iiifInfo.imageInfo.tiles.map(function(tile) { return tile.width; })[0], iiifInfo.imageInfo.tiles.map(function(tile) { return tile.height === void 0 ? tile.width : tile.height; })[0] ], resolutions: iiifInfo.imageInfo.tiles === void 0 ? void 0 : iiifInfo.imageInfo.tiles.map(function(tile) { return tile.scaleFactors; })[0], supports: [...levelProfile.supports, ...profileSupports], formats: [...levelProfile.formats, ...profileFormats], qualities: [...levelProfile.qualities, ...profileQualities] }; } function generateVersion3Options(iiifInfo) { const levelProfile = iiifInfo.getComplianceLevelSupportedFeatures(), formats = iiifInfo.imageInfo.extraFormats === void 0 ? levelProfile.formats : [...levelProfile.formats, ...iiifInfo.imageInfo.extraFormats], preferredFormat = iiifInfo.imageInfo.preferredFormats !== void 0 && Array.isArray(iiifInfo.imageInfo.preferredFormats) && iiifInfo.imageInfo.preferredFormats.length > 0 ? iiifInfo.imageInfo.preferredFormats.filter(function(format) { return ["jpg", "png", "gif"].includes(format); }).reduce(function(acc, format) { return acc === void 0 && formats.includes(format) ? format : acc; }, void 0) : void 0; return { url: iiifInfo.imageInfo["id"], sizes: iiifInfo.imageInfo.sizes === void 0 ? void 0 : iiifInfo.imageInfo.sizes.map(function(size) { return [size.width, size.height]; }), tileSize: iiifInfo.imageInfo.tiles === void 0 ? void 0 : [ iiifInfo.imageInfo.tiles.map(function(tile) { return tile.width; })[0], iiifInfo.imageInfo.tiles.map(function(tile) { return tile.height; })[0] ], resolutions: iiifInfo.imageInfo.tiles === void 0 ? void 0 : iiifInfo.imageInfo.tiles.map(function(tile) { return tile.scaleFactors; })[0], supports: iiifInfo.imageInfo.extraFeatures === void 0 ? levelProfile.supports : [...levelProfile.supports, ...iiifInfo.imageInfo.extraFeatures], formats, qualities: iiifInfo.imageInfo.extraQualities === void 0 ? levelProfile.qualities : [...levelProfile.qualities, ...iiifInfo.imageInfo.extraQualities], preferredFormat }; } var versionFunctions = {}; versionFunctions[Versions.VERSION1] = generateVersion1Options; versionFunctions[Versions.VERSION2] = generateVersion2Options; versionFunctions[Versions.VERSION3] = generateVersion3Options; // node_modules/ol/source/Zoomify.js var CustomTile = class extends ImageTile_default { /** * @param {import("../size.js").Size} tileSize Full tile size. * @param {import("../tilecoord.js").TileCoord} tileCoord Tile coordinate. * @param {import("../TileState.js").default} state State. * @param {string} src Image source URI. * @param {?string} crossOrigin Cross origin. * @param {import("../Tile.js").LoadFunction} tileLoadFunction Tile load function. * @param {import("../Tile.js").Options} [options] Tile options. */ constructor(tileSize, tileCoord, state, src, crossOrigin, tileLoadFunction, options) { super(tileCoord, state, src, crossOrigin, tileLoadFunction, options); this.zoomifyImage_ = null; this.tileSize_ = tileSize; } /** * Get the image element for this tile. * @return {HTMLCanvasElement|OffscreenCanvas|HTMLImageElement|HTMLVideoElement} Image. * @override */ getImage() { if (this.zoomifyImage_) { return this.zoomifyImage_; } const image = super.getImage(); if (this.state == TileState_default.LOADED) { const tileSize = this.tileSize_; if (image.width == tileSize[0] && image.height == tileSize[1]) { this.zoomifyImage_ = image; return image; } const context = createCanvasContext2D(tileSize[0], tileSize[1]); context.drawImage(image, 0, 0); this.zoomifyImage_ = context.canvas; return context.canvas; } return image; } }; var Zoomify = class extends TileImage_default { /** * @param {Options} options Options. */ constructor(options) { const size = options.size; const tierSizeCalculation = options.tierSizeCalculation !== void 0 ? options.tierSizeCalculation : "default"; const tilePixelRatio = options.tilePixelRatio || 1; const imageWidth = size[0]; const imageHeight = size[1]; const tierSizeInTiles = []; const tileSize = options.tileSize || DEFAULT_TILE_SIZE; let tileSizeForTierSizeCalculation = tileSize * tilePixelRatio; switch (tierSizeCalculation) { case "default": while (imageWidth > tileSizeForTierSizeCalculation || imageHeight > tileSizeForTierSizeCalculation) { tierSizeInTiles.push([ Math.ceil(imageWidth / tileSizeForTierSizeCalculation), Math.ceil(imageHeight / tileSizeForTierSizeCalculation) ]); tileSizeForTierSizeCalculation += tileSizeForTierSizeCalculation; } break; case "truncated": let width = imageWidth; let height = imageHeight; while (width > tileSizeForTierSizeCalculation || height > tileSizeForTierSizeCalculation) { tierSizeInTiles.push([ Math.ceil(width / tileSizeForTierSizeCalculation), Math.ceil(height / tileSizeForTierSizeCalculation) ]); width >>= 1; height >>= 1; } break; default: throw new Error("Unknown `tierSizeCalculation` configured"); } tierSizeInTiles.push([1, 1]); tierSizeInTiles.reverse(); const resolutions = [tilePixelRatio]; const tileCountUpToTier = [0]; for (let i = 1, ii = tierSizeInTiles.length; i < ii; i++) { resolutions.push(tilePixelRatio << i); tileCountUpToTier.push( tierSizeInTiles[i - 1][0] * tierSizeInTiles[i - 1][1] + tileCountUpToTier[i - 1] ); } resolutions.reverse(); const tileGrid = new TileGrid_default({ tileSize, extent: options.extent || [0, -imageHeight, imageWidth, 0], resolutions }); let url = options.url; if (url && !url.includes("{TileGroup}") && !url.includes("{tileIndex}")) { url += "{TileGroup}/{z}-{x}-{y}.jpg"; } const urls = expandUrl(url); let tileWidth = tileSize * tilePixelRatio; function createFromTemplate(template) { return ( /** * @param {import("../tilecoord.js").TileCoord} tileCoord Tile Coordinate. * @param {number} pixelRatio Pixel ratio. * @param {import("../proj/Projection.js").default} projection Projection. * @return {string|undefined} Tile URL. */ (function(tileCoord, pixelRatio, projection) { if (!tileCoord) { return void 0; } const tileCoordZ = tileCoord[0]; const tileCoordX = tileCoord[1]; const tileCoordY = tileCoord[2]; const tileIndex = tileCoordX + tileCoordY * tierSizeInTiles[tileCoordZ][0]; const tileGroup = (tileIndex + tileCountUpToTier[tileCoordZ]) / tileWidth | 0; const localContext = { "z": tileCoordZ, "x": tileCoordX, "y": tileCoordY, "tileIndex": tileIndex, "TileGroup": "TileGroup" + tileGroup }; return template.replace(/\{(\w+?)\}/g, function(m, p) { return localContext[p]; }); }) ); } const tileUrlFunction = createFromTileUrlFunctions( urls.map(createFromTemplate) ); const ZoomifyTileClass = CustomTile.bind( null, toSize(tileSize * tilePixelRatio) ); super({ attributions: options.attributions, cacheSize: options.cacheSize, crossOrigin: options.crossOrigin, interpolate: options.interpolate, projection: options.projection, tilePixelRatio, reprojectionErrorThreshold: options.reprojectionErrorThreshold, tileClass: ZoomifyTileClass, tileGrid, tileUrlFunction, transition: options.transition }); this.zDirection = options.zDirection; const tileUrl = tileGrid.getTileCoordForCoordAndResolution( getCenter(tileGrid.getExtent()), resolutions[resolutions.length - 1] ); const testTileUrl = tileUrlFunction(tileUrl, 1, null); const image = new Image(); image.addEventListener("error", () => { tileWidth = tileSize; this.changed(); }); image.src = testTileUrl; } }; var Zoomify_default = Zoomify; // node_modules/ol/source/IIIF.js function formatPercentage(percentage) { return percentage.toLocaleString("en", { maximumFractionDigits: 10 }); } var IIIF = class extends TileImage_default { /** * @param {Options} [options] Tile source options. Use {@link import("../format/IIIFInfo.js").IIIFInfo} * to parse Image API service information responses into constructor options. * @api */ constructor(options) { const partialOptions = options || {}; let baseUrl = partialOptions.url || ""; baseUrl = baseUrl + (baseUrl.lastIndexOf("/") === baseUrl.length - 1 || baseUrl === "" ? "" : "/"); const version = partialOptions.version || Versions.VERSION2; const sizes = partialOptions.sizes || []; const size = partialOptions.size; assert( size != void 0 && Array.isArray(size) && size.length == 2 && !isNaN(size[0]) && size[0] > 0 && !isNaN(size[1]) && size[1] > 0, "Missing or invalid `size`" ); const width = size[0]; const height = size[1]; const tileSize = partialOptions.tileSize; const tilePixelRatio = partialOptions.tilePixelRatio || 1; const format = partialOptions.format || "jpg"; const quality = partialOptions.quality || (partialOptions.version == Versions.VERSION1 ? "native" : "default"); let resolutions = partialOptions.resolutions || []; const supports = partialOptions.supports || []; const extent = partialOptions.extent || [0, -height, width, 0]; const supportsListedSizes = sizes != void 0 && Array.isArray(sizes) && sizes.length > 0; const supportsListedTiles = tileSize !== void 0 && (typeof tileSize === "number" && Number.isInteger(tileSize) && tileSize > 0 || Array.isArray(tileSize) && tileSize.length > 0); const supportsArbitraryTiling = supports != void 0 && Array.isArray(supports) && (supports.includes("regionByPx") || supports.includes("regionByPct")) && (supports.includes("sizeByWh") || supports.includes("sizeByH") || supports.includes("sizeByW") || supports.includes("sizeByPct")); let tileWidth, tileHeight, maxZoom2; resolutions.sort(function(a, b) { return b - a; }); if (supportsListedTiles || supportsArbitraryTiling) { if (tileSize != void 0) { if (typeof tileSize === "number" && Number.isInteger(tileSize) && tileSize > 0) { tileWidth = tileSize; tileHeight = tileSize; } else if (Array.isArray(tileSize) && tileSize.length > 0) { if (tileSize.length == 1 || tileSize[1] == void 0 && Number.isInteger(tileSize[0])) { tileWidth = tileSize[0]; tileHeight = tileSize[0]; } if (tileSize.length == 2) { if (Number.isInteger(tileSize[0]) && Number.isInteger(tileSize[1])) { tileWidth = tileSize[0]; tileHeight = tileSize[1]; } else if (tileSize[0] == void 0 && Number.isInteger(tileSize[1])) { tileWidth = tileSize[1]; tileHeight = tileSize[1]; } } } } if (tileWidth === void 0 || tileHeight === void 0) { tileWidth = DEFAULT_TILE_SIZE; tileHeight = DEFAULT_TILE_SIZE; } if (resolutions.length == 0) { maxZoom2 = Math.max( Math.ceil(Math.log(width / tileWidth) / Math.LN2), Math.ceil(Math.log(height / tileHeight) / Math.LN2) ); for (let i = maxZoom2; i >= 0; i--) { resolutions.push(Math.pow(2, i)); } } else { const maxScaleFactor = Math.max(...resolutions); maxZoom2 = Math.round(Math.log(maxScaleFactor) / Math.LN2); } } else { tileWidth = width; tileHeight = height; resolutions = []; if (supportsListedSizes) { sizes.sort(function(a, b) { return a[0] - b[0]; }); maxZoom2 = -1; const ignoredSizesIndex = []; for (let i = 0; i < sizes.length; i++) { const resolution = width / sizes[i][0]; if (resolutions.length > 0 && resolutions[resolutions.length - 1] == resolution) { ignoredSizesIndex.push(i); continue; } resolutions.push(resolution); maxZoom2++; } if (ignoredSizesIndex.length > 0) { for (let i = 0; i < ignoredSizesIndex.length; i++) { sizes.splice(ignoredSizesIndex[i] - i, 1); } } } else { resolutions.push(1); sizes.push([width, height]); maxZoom2 = 0; } } const tileGrid = new TileGrid_default({ tileSize: [tileWidth, tileHeight], extent, origin: getTopLeft(extent), resolutions }); const tileUrlFunction = function(tileCoord, pixelRatio, projection) { let regionParam, sizeParam; const zoom = tileCoord[0]; if (zoom > maxZoom2) { return; } const tileX = tileCoord[1], tileY = tileCoord[2], scale4 = resolutions[zoom]; if (tileX === void 0 || tileY === void 0 || scale4 === void 0 || tileX < 0 || Math.ceil(width / scale4 / tileWidth) <= tileX || tileY < 0 || Math.ceil(height / scale4 / tileHeight) <= tileY) { return; } if (supportsArbitraryTiling || supportsListedTiles) { const regionX = tileX * tileWidth * scale4, regionY = tileY * tileHeight * scale4; let regionW = tileWidth * scale4, regionH = tileHeight * scale4, sizeW = tileWidth, sizeH = tileHeight; if (regionX + regionW > width) { regionW = width - regionX; } if (regionY + regionH > height) { regionH = height - regionY; } if (regionX + tileWidth * scale4 > width) { sizeW = Math.floor((width - regionX + scale4 - 1) / scale4); } if (regionY + tileHeight * scale4 > height) { sizeH = Math.floor((height - regionY + scale4 - 1) / scale4); } if (regionX == 0 && regionW == width && regionY == 0 && regionH == height) { regionParam = "full"; } else if (!supportsArbitraryTiling || supports.includes("regionByPx")) { regionParam = regionX + "," + regionY + "," + regionW + "," + regionH; } else if (supports.includes("regionByPct")) { const pctX = formatPercentage(regionX / width * 100), pctY = formatPercentage(regionY / height * 100), pctW = formatPercentage(regionW / width * 100), pctH = formatPercentage(regionH / height * 100); regionParam = "pct:" + pctX + "," + pctY + "," + pctW + "," + pctH; } if (version == Versions.VERSION3 && (!supportsArbitraryTiling || supports.includes("sizeByWh"))) { sizeParam = sizeW + "," + sizeH; } else if (!supportsArbitraryTiling || supports.includes("sizeByW")) { sizeParam = sizeW + ","; } else if (supports.includes("sizeByH")) { sizeParam = "," + sizeH; } else if (supports.includes("sizeByWh")) { sizeParam = sizeW + "," + sizeH; } else if (supports.includes("sizeByPct")) { sizeParam = "pct:" + formatPercentage(100 / scale4); } } else { regionParam = "full"; if (supportsListedSizes) { const regionWidth = sizes[zoom][0], regionHeight = sizes[zoom][1]; if (version == Versions.VERSION3) { if (regionWidth == width && regionHeight == height) { sizeParam = "max"; } else { sizeParam = regionWidth + "," + regionHeight; } } else { if (regionWidth == width) { sizeParam = "full"; } else { sizeParam = regionWidth + ","; } } } else { sizeParam = version == Versions.VERSION3 ? "max" : "full"; } } return baseUrl + regionParam + "/" + sizeParam + "/0/" + quality + "." + format; }; const IiifTileClass = CustomTile.bind( null, toSize(tileSize || 256).map(function(size2) { return size2 * tilePixelRatio; }) ); super({ attributions: partialOptions.attributions, attributionsCollapsible: partialOptions.attributionsCollapsible, cacheSize: partialOptions.cacheSize, crossOrigin: partialOptions.crossOrigin, interpolate: partialOptions.interpolate, projection: partialOptions.projection, reprojectionErrorThreshold: partialOptions.reprojectionErrorThreshold, state: partialOptions.state, tileClass: IiifTileClass, tileGrid, tilePixelRatio: partialOptions.tilePixelRatio, tileUrlFunction, transition: partialOptions.transition }); this.zDirection = partialOptions.zDirection; } }; var IIIF_default = IIIF; // node_modules/ol/reproj/Image.js var ReprojImage = class extends Image_default { /** * @param {import("../proj/Projection.js").default} sourceProj Source projection (of the data). * @param {import("../proj/Projection.js").default} targetProj Target projection. * @param {import("../extent.js").Extent} targetExtent Target extent. * @param {number} targetResolution Target resolution. * @param {number} pixelRatio Pixel ratio. * @param {FunctionType} getImageFunction * Function returning source images (extent, resolution, pixelRatio). * @param {boolean} interpolate Use linear interpolation when resampling. */ constructor(sourceProj, targetProj, targetExtent, targetResolution, pixelRatio, getImageFunction, interpolate) { let maxSourceExtent = sourceProj.getExtent(); if (maxSourceExtent && sourceProj.canWrapX()) { maxSourceExtent = maxSourceExtent.slice(); maxSourceExtent[0] = -Infinity; maxSourceExtent[2] = Infinity; } let maxTargetExtent = targetProj.getExtent(); if (maxTargetExtent && targetProj.canWrapX()) { maxTargetExtent = maxTargetExtent.slice(); maxTargetExtent[0] = -Infinity; maxTargetExtent[2] = Infinity; } const limitedTargetExtent = maxTargetExtent ? getIntersection(targetExtent, maxTargetExtent) : targetExtent; const targetCenter = getCenter(limitedTargetExtent); const sourceResolution = calculateSourceResolution( sourceProj, targetProj, targetCenter, targetResolution ); const errorThresholdInPixels = ERROR_THRESHOLD; const triangulation = new Triangulation_default( sourceProj, targetProj, limitedTargetExtent, maxSourceExtent, sourceResolution * errorThresholdInPixels, targetResolution ); const sourceExtent = triangulation.calculateSourceExtent(); const sourceImage = isEmpty2(sourceExtent) ? null : getImageFunction(sourceExtent, sourceResolution, pixelRatio); const state = sourceImage ? ImageState_default.IDLE : ImageState_default.EMPTY; const sourcePixelRatio = sourceImage ? sourceImage.getPixelRatio() : 1; super(targetExtent, targetResolution, sourcePixelRatio, state); this.targetProj_ = targetProj; this.maxSourceExtent_ = maxSourceExtent; this.triangulation_ = triangulation; this.targetResolution_ = targetResolution; this.targetExtent_ = targetExtent; this.sourceImage_ = sourceImage; this.sourcePixelRatio_ = sourcePixelRatio; this.interpolate_ = interpolate; this.canvas_ = null; this.sourceListenerKey_ = null; } /** * Clean up. * @override */ disposeInternal() { if (this.state == ImageState_default.LOADING) { this.unlistenSource_(); } super.disposeInternal(); } /** * @return {HTMLCanvasElement|OffscreenCanvas} Image. * @override */ getImage() { return this.canvas_; } /** * @return {import("../proj/Projection.js").default} Projection. */ getProjection() { return this.targetProj_; } /** * @private */ reproject_() { const sourceState = this.sourceImage_.getState(); if (sourceState == ImageState_default.LOADED) { const width = getWidth(this.targetExtent_) / this.targetResolution_; const height = getHeight(this.targetExtent_) / this.targetResolution_; this.canvas_ = render( width, height, this.sourcePixelRatio_, fromResolutionLike(this.sourceImage_.getResolution()), this.maxSourceExtent_, this.targetResolution_, this.targetExtent_, this.triangulation_, [ { extent: this.sourceImage_.getExtent(), image: this.sourceImage_.getImage() } ], 0, void 0, this.interpolate_, true ); } this.state = sourceState; this.changed(); } /** * Load not yet loaded URI. * @override */ load() { if (this.state == ImageState_default.IDLE) { this.state = ImageState_default.LOADING; this.changed(); const sourceState = this.sourceImage_.getState(); if (sourceState == ImageState_default.LOADED || sourceState == ImageState_default.ERROR) { this.reproject_(); } else { this.sourceListenerKey_ = listen( this.sourceImage_, EventType_default.CHANGE, (e) => { const sourceState2 = this.sourceImage_.getState(); if (sourceState2 == ImageState_default.LOADED || sourceState2 == ImageState_default.ERROR) { this.unlistenSource_(); this.reproject_(); } } ); this.sourceImage_.load(); } } } /** * @private */ unlistenSource_() { unlistenByKey( /** @type {!import("../events.js").EventsKey} */ this.sourceListenerKey_ ); this.sourceListenerKey_ = null; } }; var Image_default3 = ReprojImage; // node_modules/ol/source/common.js var DECIMALS = 4; // node_modules/ol/source/Image.js var ImageSourceEventType = { /** * Triggered when an image starts loading. * @event module:ol/source/Image.ImageSourceEvent#imageloadstart * @api */ IMAGELOADSTART: "imageloadstart", /** * Triggered when an image finishes loading. * @event module:ol/source/Image.ImageSourceEvent#imageloadend * @api */ IMAGELOADEND: "imageloadend", /** * Triggered if image loading results in an error. * @event module:ol/source/Image.ImageSourceEvent#imageloaderror * @api */ IMAGELOADERROR: "imageloaderror" }; var ImageSourceEvent = class extends Event_default { /** * @param {string} type Type. * @param {import("../Image.js").default} image The image. */ constructor(type, image) { super(type); this.image = image; } }; var ImageSource = class extends Source_default { /** * @param {Options} options Single image source options. */ constructor(options) { super({ attributions: options.attributions, projection: options.projection, state: options.state, interpolate: options.interpolate !== void 0 ? options.interpolate : true }); this.on; this.once; this.un; this.loader = options.loader || null; this.resolutions_ = options.resolutions !== void 0 ? options.resolutions : null; this.reprojectedImage_ = null; this.reprojectedRevision_ = 0; this.image = null; this.wantedExtent_; this.wantedResolution_; this.static_ = options.loader ? options.loader.length === 0 : false; this.wantedProjection_ = null; } /** * @return {Array|null} Resolutions. * @override */ getResolutions() { return this.resolutions_; } /** * @param {Array|null} resolutions Resolutions. */ setResolutions(resolutions) { this.resolutions_ = resolutions; } /** * @protected * @param {number} resolution Resolution. * @return {number} Resolution. */ findNearestResolution(resolution) { const resolutions = this.getResolutions(); if (resolutions) { const idx = linearFindNearest(resolutions, resolution, 0); resolution = resolutions[idx]; } return resolution; } /** * @param {import("../extent.js").Extent} extent Extent. * @param {number} resolution Resolution. * @param {number} pixelRatio Pixel ratio. * @param {import("../proj/Projection.js").default} projection Projection. * @return {import("../Image.js").default} Single image. */ getImage(extent, resolution, pixelRatio, projection) { const sourceProjection = this.getProjection(); if (!sourceProjection || !projection || equivalent(sourceProjection, projection)) { if (sourceProjection) { projection = sourceProjection; } return this.getImageInternal(extent, resolution, pixelRatio, projection); } if (this.reprojectedImage_) { if (this.reprojectedRevision_ == this.getRevision() && equivalent(this.reprojectedImage_.getProjection(), projection) && this.reprojectedImage_.getResolution() == resolution && equals(this.reprojectedImage_.getExtent(), extent)) { return this.reprojectedImage_; } this.reprojectedImage_.dispose(); this.reprojectedImage_ = null; } this.reprojectedImage_ = new Image_default3( sourceProjection, projection, extent, resolution, pixelRatio, (extent2, resolution2, pixelRatio2) => this.getImageInternal(extent2, resolution2, pixelRatio2, sourceProjection), this.getInterpolate() ); this.reprojectedRevision_ = this.getRevision(); return this.reprojectedImage_; } /** * @abstract * @param {import("../extent.js").Extent} extent Extent. * @param {number} resolution Resolution. * @param {number} pixelRatio Pixel ratio. * @param {import("../proj/Projection.js").default} projection Projection. * @return {import("../Image.js").default} Single image. * @protected */ getImageInternal(extent, resolution, pixelRatio, projection) { if (this.loader) { const requestExtent = getRequestExtent(extent, resolution, pixelRatio, 1); const requestResolution = this.findNearestResolution(resolution); if (this.image && (this.static_ || this.wantedProjection_ === projection && (this.wantedExtent_ && containsExtent(this.wantedExtent_, requestExtent) || containsExtent(this.image.getExtent(), requestExtent)) && (this.wantedResolution_ && fromResolutionLike(this.wantedResolution_) === requestResolution || fromResolutionLike(this.image.getResolution()) === requestResolution))) { return this.image; } this.wantedProjection_ = projection; this.wantedExtent_ = requestExtent; this.wantedResolution_ = requestResolution; this.image = new Image_default( requestExtent, requestResolution, pixelRatio, this.loader ); this.image.addEventListener( EventType_default.CHANGE, this.handleImageChange.bind(this) ); } return this.image; } /** * Handle image change events. * @param {import("../events/Event.js").default} event Event. * @protected */ handleImageChange(event) { const image = ( /** @type {import("../Image.js").default} */ event.target ); let type; switch (image.getState()) { case ImageState_default.LOADING: this.loading = true; type = ImageSourceEventType.IMAGELOADSTART; break; case ImageState_default.LOADED: this.loading = false; type = ImageSourceEventType.IMAGELOADEND; break; case ImageState_default.ERROR: this.loading = false; type = ImageSourceEventType.IMAGELOADERROR; break; default: return; } if (this.hasListener(type)) { this.dispatchEvent(new ImageSourceEvent(type, image)); } } }; function defaultImageLoadFunction(image, src) { image.getImage().src = src; } function getRequestExtent(extent, resolution, pixelRatio, ratio) { const imageResolution = resolution / pixelRatio; const center = getCenter(extent); const viewWidth = ceil(getWidth(extent) / imageResolution, DECIMALS); const viewHeight = ceil(getHeight(extent) / imageResolution, DECIMALS); const marginWidth = ceil((ratio - 1) * viewWidth / 2, DECIMALS); const requestWidth = viewWidth + 2 * marginWidth; const marginHeight = ceil((ratio - 1) * viewHeight / 2, DECIMALS); const requestHeight = viewHeight + 2 * marginHeight; return getForViewAndSize(center, imageResolution, 0, [ requestWidth, requestHeight ]); } var Image_default4 = ImageSource; // node_modules/ol/source/arcgisRest.js function getRequestUrl(baseUrl, extent, resolution, pixelRatio, projection, params) { const srid = projection.getCode().split(/:(?=\d+$)/).pop(); const imageResolution = resolution / pixelRatio; const imageSize = [ round(getWidth(extent) / imageResolution, DECIMALS), round(getHeight(extent) / imageResolution, DECIMALS) ]; params["SIZE"] = imageSize[0] + "," + imageSize[1]; params["BBOX"] = extent.join(","); params["BBOXSR"] = srid; params["IMAGESR"] = srid; params["DPI"] = Math.round( params["DPI"] ? params["DPI"] * pixelRatio : 90 * pixelRatio ); const modifiedUrl = baseUrl.replace(/MapServer\/?$/, "MapServer/export").replace(/ImageServer\/?$/, "ImageServer/exportImage"); return appendParams(modifiedUrl, params); } function createLoader(options) { const load = options.load ? options.load : decode; const projection = get(options.projection || "EPSG:3857"); const ratio = options.ratio ?? 1.5; const crossOrigin = options.crossOrigin ?? null; return function(extent, resolution, pixelRatio) { pixelRatio = options.hidpi ? pixelRatio : 1; const params = { "F": "image", "FORMAT": "PNG32", "TRANSPARENT": true }; Object.assign(params, options.params); extent = getRequestExtent(extent, resolution, pixelRatio, ratio); const src = getRequestUrl( options.url, extent, resolution, pixelRatio, projection, params ); const image = new Image(); image.crossOrigin = crossOrigin; return load(image, src).then((image2) => { const resolution2 = getWidth(extent) / image2.width * pixelRatio; return { image: image2, extent, resolution: resolution2, pixelRatio }; }); }; } // node_modules/ol/source/ImageArcGISRest.js var ImageArcGISRest = class extends Image_default4 { /** * @param {Options} [options] Image ArcGIS Rest Options. */ constructor(options) { options = options ? options : {}; super({ attributions: options.attributions, interpolate: options.interpolate, projection: options.projection, resolutions: options.resolutions }); this.crossOrigin_ = options.crossOrigin !== void 0 ? options.crossOrigin : null; this.hidpi_ = options.hidpi !== void 0 ? options.hidpi : true; this.url_ = options.url; this.imageLoadFunction_ = options.imageLoadFunction !== void 0 ? options.imageLoadFunction : defaultImageLoadFunction; this.params_ = Object.assign({}, options.params); this.imageSize_ = [0, 0]; this.renderedRevision_ = 0; this.ratio_ = options.ratio !== void 0 ? options.ratio : 1.5; this.loaderProjection_ = null; } /** * Get the user-provided params, i.e. those passed to the constructor through * the "params" option, and possibly updated using the updateParams method. * @return {Object} Params. * @api */ getParams() { return this.params_; } /** * @param {import("../extent.js").Extent} extent Extent. * @param {number} resolution Resolution. * @param {number} pixelRatio Pixel ratio. * @param {import("../proj/Projection.js").default} projection Projection. * @return {import("../Image.js").default} Single image. * @override */ getImageInternal(extent, resolution, pixelRatio, projection) { if (this.url_ === void 0) { return null; } if (!this.loader || this.loaderProjection_ !== projection) { this.loaderProjection_ = projection; this.loader = createLoader({ crossOrigin: this.crossOrigin_, params: this.params_, projection, hidpi: this.hidpi_, url: this.url_, ratio: this.ratio_, load: (image, src) => { this.image.setImage(image); this.imageLoadFunction_(this.image, src); return decode(image); } }); } return super.getImageInternal(extent, resolution, pixelRatio, projection); } /** * Return the image load function of the source. * @return {import("../Image.js").LoadFunction} The image load function. * @api */ getImageLoadFunction() { return this.imageLoadFunction_; } /** * Return the URL used for this ArcGIS source. * @return {string|undefined} URL. * @api */ getUrl() { return this.url_; } /** * Set the image load function of the source. * @param {import("../Image.js").LoadFunction} imageLoadFunction Image load function. * @api */ setImageLoadFunction(imageLoadFunction) { this.imageLoadFunction_ = imageLoadFunction; this.changed(); } /** * Set the URL to use for requests. * @param {string|undefined} url URL. * @api */ setUrl(url) { if (url != this.url_) { this.url_ = url; this.loader = null; this.changed(); } } /** * Set the user-provided params. * @param {Object} params Params. * @api */ setParams(params) { this.params_ = Object.assign({}, params); this.changed(); } /** * Update the user-provided params. * @param {Object} params Params. * @api */ updateParams(params) { Object.assign(this.params_, params); this.changed(); } /** * @override */ changed() { this.image = null; super.changed(); } }; var ImageArcGISRest_default = ImageArcGISRest; // node_modules/ol/source/ImageCanvas.js var ImageCanvasSource = class extends Image_default4 { /** * @param {Options} [options] ImageCanvas options. */ constructor(options) { options = options ? options : {}; super({ attributions: options.attributions, interpolate: options.interpolate, projection: options.projection, resolutions: options.resolutions, state: options.state }); this.canvasFunction_ = options.canvasFunction; this.canvas_ = null; this.renderedRevision_ = 0; this.ratio_ = options.ratio !== void 0 ? options.ratio : 1.5; } /** * @param {import("../extent.js").Extent} extent Extent. * @param {number} resolution Resolution. * @param {number} pixelRatio Pixel ratio. * @param {import("../proj/Projection.js").default} projection Projection. * @return {import("../ImageCanvas.js").default} Single image. * @override */ getImageInternal(extent, resolution, pixelRatio, projection) { resolution = this.findNearestResolution(resolution); let canvas = this.canvas_; if (canvas && this.renderedRevision_ == this.getRevision() && canvas.getResolution() == resolution && canvas.getPixelRatio() == pixelRatio && containsExtent(canvas.getExtent(), extent)) { return canvas; } extent = extent.slice(); scaleFromCenter(extent, this.ratio_); const width = getWidth(extent) / resolution; const height = getHeight(extent) / resolution; const size = [width * pixelRatio, height * pixelRatio]; const canvasElement = this.canvasFunction_.call( this, extent, resolution, pixelRatio, size, projection ); if (canvasElement) { canvas = new ImageCanvas_default(extent, resolution, pixelRatio, canvasElement); } this.canvas_ = canvas; this.renderedRevision_ = this.getRevision(); return canvas; } }; var ImageCanvas_default2 = ImageCanvasSource; // node_modules/ol/source/mapguide.js function getScale(extent, size, metersPerUnit, dpi) { const mcsW = getWidth(extent); const mcsH = getHeight(extent); const devW = size[0]; const devH = size[1]; const mpp = 0.0254 / dpi; if (devH * mcsW > devW * mcsH) { return mcsW * metersPerUnit / (devW * mpp); } return mcsH * metersPerUnit / (devH * mpp); } function getUrl(baseUrl, params, extent, size, useOverlay, metersPerUnit, displayDpi) { const scale4 = getScale(extent, size, metersPerUnit, displayDpi); const center = getCenter(extent); const baseParams = { "OPERATION": useOverlay ? "GETDYNAMICMAPOVERLAYIMAGE" : "GETMAPIMAGE", "VERSION": "2.0.0", "LOCALE": "en", "CLIENTAGENT": "ol/source/ImageMapGuide source", "CLIP": "1", "SETDISPLAYDPI": displayDpi, "SETDISPLAYWIDTH": Math.round(size[0]), "SETDISPLAYHEIGHT": Math.round(size[1]), "SETVIEWSCALE": scale4, "SETVIEWCENTERX": center[0], "SETVIEWCENTERY": center[1] }; Object.assign(baseParams, params); return appendParams(baseUrl, baseParams); } function createLoader2(options) { const load = options.load || decode; const useOverlay = options.useOverlay ?? false; const metersPerUnit = options.metersPerUnit || 1; const displayDpi = options.displayDpi || 96; const ratio = options.ratio ?? 1; const crossOrigin = options.crossOrigin ?? null; return function(extent, resolution, pixelRatio) { const image = new Image(); image.crossOrigin = crossOrigin; extent = getRequestExtent(extent, resolution, pixelRatio, ratio); const width = getWidth(extent) / resolution; const height = getHeight(extent) / resolution; const size = [width * pixelRatio, height * pixelRatio]; const src = getUrl( options.url, options.params, extent, size, useOverlay, metersPerUnit, displayDpi ); return load(image, src).then((image2) => ({ image: image2, extent, pixelRatio })); }; } // node_modules/ol/source/ImageMapGuide.js var ImageMapGuide = class extends Image_default4 { /** * @param {Options} options ImageMapGuide options. */ constructor(options) { super({ interpolate: options.interpolate, projection: options.projection, resolutions: options.resolutions }); this.crossOrigin_ = options.crossOrigin !== void 0 ? options.crossOrigin : null; this.displayDpi_ = options.displayDpi !== void 0 ? options.displayDpi : 96; this.params_ = Object.assign({}, options.params); this.url_ = options.url; this.imageLoadFunction_ = options.imageLoadFunction !== void 0 ? options.imageLoadFunction : defaultImageLoadFunction; this.hidpi_ = options.hidpi !== void 0 ? options.hidpi : true; this.metersPerUnit_ = options.metersPerUnit !== void 0 ? options.metersPerUnit : 1; this.ratio_ = options.ratio !== void 0 ? options.ratio : 1; this.useOverlay_ = options.useOverlay !== void 0 ? options.useOverlay : false; this.renderedRevision_ = 0; this.loaderProjection_ = null; } /** * Get the user-provided params, i.e. those passed to the constructor through * the "params" option, and possibly updated using the updateParams method. * @return {Object} Params. * @api */ getParams() { return this.params_; } /** * @param {import("../extent.js").Extent} extent Extent. * @param {number} resolution Resolution. * @param {number} pixelRatio Pixel ratio. * @param {import("../proj/Projection.js").default} projection Projection. * @return {import("../Image.js").default} Single image. * @override */ getImageInternal(extent, resolution, pixelRatio, projection) { if (this.url_ === void 0) { return null; } if (!this.loader || this.loaderProjection_ !== projection) { this.loaderProjection_ = projection; this.loader = createLoader2({ crossOrigin: this.crossOrigin_, params: this.params_, hidpi: this.hidpi_, metersPerUnit: this.metersPerUnit_, url: this.url_, useOverlay: this.useOverlay_, ratio: this.ratio_, load: (image, src) => { this.image.setImage(image); this.imageLoadFunction_(this.image, src); return decode(image); } }); } return super.getImageInternal(extent, resolution, pixelRatio, projection); } /** * Return the image load function of the source. * @return {import("../Image.js").LoadFunction} The image load function. * @api */ getImageLoadFunction() { return this.imageLoadFunction_; } /** * Set the user-provided params. * @param {Object} params Params. * @api */ setParams(params) { this.params_ = Object.assign({}, params); this.changed(); } /** * Update the user-provided params. * @param {Object} params Params. * @api */ updateParams(params) { Object.assign(this.params_, params); this.changed(); } /** * Set the image load function of the MapGuide source. * @param {import("../Image.js").LoadFunction} imageLoadFunction Image load function. * @api */ setImageLoadFunction(imageLoadFunction) { this.imageLoadFunction_ = imageLoadFunction; this.changed(); } /** * @override */ changed() { this.image = null; super.changed(); } }; var ImageMapGuide_default = ImageMapGuide; // node_modules/ol/source/static.js function createLoader3(options) { const load = options.load || decode; const extent = options.imageExtent; const crossOrigin = options.crossOrigin ?? null; return () => { const image = new Image(); image.crossOrigin = crossOrigin; return load(image, options.url).then((image2) => { const resolutionX = getWidth(extent) / image2.width; const resolutionY = getHeight(extent) / image2.height; const resolution = resolutionX !== resolutionY ? [resolutionX, resolutionY] : resolutionY; return { image: image2, extent, resolution, pixelRatio: 1 }; }); }; } // node_modules/ol/source/ImageStatic.js var Static = class extends Image_default4 { /** * @param {Options} options ImageStatic options. */ constructor(options) { const crossOrigin = options.crossOrigin !== void 0 ? options.crossOrigin : null; const imageLoadFunction = options.imageLoadFunction !== void 0 ? options.imageLoadFunction : defaultImageLoadFunction; super({ attributions: options.attributions, interpolate: options.interpolate, projection: get(options.projection) }); this.url_ = options.url; this.imageExtent_ = options.imageExtent; this.image = null; this.image = new Image_default( this.imageExtent_, void 0, 1, createLoader3({ url: options.url, imageExtent: options.imageExtent, crossOrigin, load: (image, src) => { this.image.setImage(image); imageLoadFunction(this.image, src); return decode(image); } }) ); this.image.addEventListener( EventType_default.CHANGE, this.handleImageChange.bind(this) ); } /** * Returns the image extent * @return {import("../extent.js").Extent} image extent. * @api */ getImageExtent() { return this.imageExtent_; } /** * @param {import("../extent.js").Extent} extent Extent. * @param {number} resolution Resolution. * @param {number} pixelRatio Pixel ratio. * @param {import("../proj/Projection.js").default} projection Projection. * @return {import("../Image.js").default} Single image. * @override */ getImageInternal(extent, resolution, pixelRatio, projection) { if (intersects(extent, this.image.getExtent())) { return this.image; } return null; } /** * Return the URL used for this image source. * @return {string} URL. * @api */ getUrl() { return this.url_; } }; var ImageStatic_default = Static; // node_modules/ol/source/ImageTile.js var loadError = new Error("Image failed to load"); function loadImage(template, z, x, y, options) { return new Promise((resolve, reject) => { const image = new Image(); image.crossOrigin = options.crossOrigin ?? null; image.addEventListener("load", () => resolve(image)); image.addEventListener("error", () => reject(loadError)); image.src = renderXYZTemplate(template, z, x, y, options.maxY); }); } function makeLoaderFromTemplates(templates) { return function(z, x, y, options) { const template = pickUrl(templates, z, x, y); return loadImage(template, z, x, y, options); }; } function makeLoaderFromGetter(getter) { return function(z, x, y, options) { const url = getter(z, x, y, options); return loadImage(url, z, x, y, options); }; } function makeLoaderFromUrlLike(url) { let loader; if (Array.isArray(url)) { loader = makeLoaderFromTemplates(url); } else if (typeof url === "string") { const urls = expandUrl(url); loader = makeLoaderFromTemplates(urls); } else if (typeof url === "function") { loader = makeLoaderFromGetter(url); } else { throw new Error( "The url option must be a single template, an array of templates, or a function for getting a URL" ); } return loader; } var keyCount = 0; function keyFromUrlLike(url) { if (Array.isArray(url)) { return url.join("\n"); } if (typeof url === "string") { return url; } ++keyCount; return "url-function-key-" + keyCount; } var ImageTileSource = class extends DataTile_default3 { /** * @param {Options} [options] DataTile source options. */ constructor(options) { options = options || {}; let loader = options.loader; let key; if (options.url) { loader = makeLoaderFromUrlLike(options.url); key = keyFromUrlLike(options.url); } const state = !loader ? "loading" : options.state; const wrapX = options.wrapX === void 0 ? true : options.wrapX; super({ loader, key, attributions: options.attributions, attributionsCollapsible: options.attributionsCollapsible, maxZoom: options.maxZoom, minZoom: options.minZoom, tileSize: options.tileSize, gutter: options.gutter, maxResolution: options.maxResolution, projection: options.projection, tileGrid: options.tileGrid, state, wrapX, transition: options.transition, interpolate: options.interpolate !== false, crossOrigin: options.crossOrigin, zDirection: options.zDirection }); } /** * @param {UrlLike} url The new URL. * @api */ setUrl(url) { const loader = makeLoaderFromUrlLike(url); this.setLoader(loader); this.setKey(keyFromUrlLike(url)); if (this.getState() !== "ready") { this.setState("ready"); } } }; var ImageTile_default2 = ImageTileSource; // node_modules/ol/source/wms.js var DEFAULT_VERSION = "1.3.0"; var GETFEATUREINFO_IMAGE_SIZE = [101, 101]; function getRequestUrl2(baseUrl, extent, size, projection, params) { params["WIDTH"] = size[0]; params["HEIGHT"] = size[1]; const axisOrientation = projection.getAxisOrientation(); const v13 = compareVersions(params["VERSION"], "1.3") >= 0; params[v13 ? "CRS" : "SRS"] = projection.getCode(); const bbox = v13 && axisOrientation.startsWith("ne") ? [extent[1], extent[0], extent[3], extent[2]] : extent; params["BBOX"] = bbox.join(","); return appendParams(baseUrl, params); } function getImageSrc(extent, resolution, pixelRatio, projection, url, params, serverType) { params = Object.assign({ REQUEST: "GetMap" }, params); const imageResolution = resolution / pixelRatio; const imageSize = [ round(getWidth(extent) / imageResolution, DECIMALS), round(getHeight(extent) / imageResolution, DECIMALS) ]; if (pixelRatio != 1) { switch (serverType) { case "geoserver": const dpi = 90 * pixelRatio + 0.5 | 0; if ("FORMAT_OPTIONS" in params) { params["FORMAT_OPTIONS"] += ";dpi:" + dpi; } else { params["FORMAT_OPTIONS"] = "dpi:" + dpi; } break; case "mapserver": params["MAP_RESOLUTION"] = 90 * pixelRatio; break; case "carmentaserver": case "qgis": params["DPI"] = 90 * pixelRatio; break; default: throw new Error("Unknown `serverType` configured"); } } const src = getRequestUrl2(url, extent, imageSize, projection, params); return src; } function getRequestParams(params, request) { return Object.assign( { "REQUEST": request, "SERVICE": "WMS", "VERSION": DEFAULT_VERSION, "FORMAT": "image/png", "STYLES": "", "TRANSPARENT": "TRUE" }, params ); } function createLoader4(options) { const hidpi = options.hidpi === void 0 ? true : options.hidpi; const projection = get(options.projection || "EPSG:3857"); const ratio = options.ratio || 1.5; const load = options.load || decode; const crossOrigin = options.crossOrigin ?? null; return (extent, resolution, pixelRatio) => { extent = getRequestExtent(extent, resolution, pixelRatio, ratio); if (pixelRatio != 1 && (!hidpi || options.serverType === void 0)) { pixelRatio = 1; } const src = getImageSrc( extent, resolution, pixelRatio, projection, options.url, getRequestParams(options.params, "GetMap"), options.serverType ); const image = new Image(); image.crossOrigin = crossOrigin; return load(image, src).then((image2) => ({ image: image2, extent, pixelRatio })); }; } function getFeatureInfoUrl(options, coordinate, resolution) { if (options.url === void 0) { return void 0; } const projectionObj = get(options.projection || "EPSG:3857"); const extent = getForViewAndSize( coordinate, resolution, 0, GETFEATUREINFO_IMAGE_SIZE ); const baseParams = { "QUERY_LAYERS": options.params["LAYERS"], "INFO_FORMAT": "application/json" }; Object.assign( baseParams, getRequestParams(options.params, "GetFeatureInfo"), options.params ); const x = floor((coordinate[0] - extent[0]) / resolution, DECIMALS); const y = floor((extent[3] - coordinate[1]) / resolution, DECIMALS); const v13 = compareVersions(baseParams["VERSION"], "1.3") >= 0; baseParams[v13 ? "I" : "X"] = x; baseParams[v13 ? "J" : "Y"] = y; return getRequestUrl2( options.url, extent, GETFEATUREINFO_IMAGE_SIZE, projectionObj, baseParams ); } function getLegendUrl(options, resolution) { if (options.url === void 0) { return void 0; } const baseParams = { "SERVICE": "WMS", "VERSION": DEFAULT_VERSION, "REQUEST": "GetLegendGraphic", "FORMAT": "image/png" }; if (resolution !== void 0) { const mpu = get(options.projection || "EPSG:3857").getMetersPerUnit() || 1; const pixelSize = 28e-5; baseParams["SCALE"] = resolution * mpu / pixelSize; } Object.assign(baseParams, options.params); if (options.params !== void 0 && baseParams["LAYER"] === void 0) { const layers = baseParams["LAYERS"]; const isSingleLayer = !Array.isArray(layers) || layers.length !== 1; if (!isSingleLayer) { return void 0; } baseParams["LAYER"] = layers; } return appendParams(options.url, baseParams); } // node_modules/ol/source/ImageWMS.js var ImageWMS = class extends Image_default4 { /** * @param {Options} [options] ImageWMS options. */ constructor(options) { options = options ? options : {}; super({ attributions: options.attributions, interpolate: options.interpolate, projection: options.projection, resolutions: options.resolutions }); this.crossOrigin_ = options.crossOrigin !== void 0 ? options.crossOrigin : null; this.url_ = options.url; this.imageLoadFunction_ = options.imageLoadFunction !== void 0 ? options.imageLoadFunction : defaultImageLoadFunction; this.params_ = Object.assign({}, options.params); this.serverType_ = options.serverType; this.hidpi_ = options.hidpi !== void 0 ? options.hidpi : true; this.renderedRevision_ = 0; this.ratio_ = options.ratio !== void 0 ? options.ratio : 1.5; this.loaderProjection_ = null; } /** * Return the GetFeatureInfo URL for the passed coordinate, resolution, and * projection. Return `undefined` if the GetFeatureInfo URL cannot be * constructed. * @param {import("../coordinate.js").Coordinate} coordinate Coordinate. * @param {number} resolution Resolution. * @param {import("../proj.js").ProjectionLike} projection Projection. * @param {!Object} params GetFeatureInfo params. `INFO_FORMAT` at least should * be provided. If `QUERY_LAYERS` is not provided then the layers specified * in the `LAYERS` parameter will be used. `VERSION` should not be * specified here. * @return {string|undefined} GetFeatureInfo URL. * @api */ getFeatureInfoUrl(coordinate, resolution, projection, params) { const projectionObj = get(projection); const sourceProjectionObj = this.getProjection(); if (sourceProjectionObj && sourceProjectionObj !== projectionObj) { resolution = calculateSourceResolution( sourceProjectionObj, projectionObj, coordinate, resolution ); coordinate = transform(coordinate, projectionObj, sourceProjectionObj); } const options = { url: this.url_, params: { ...this.params_, ...params }, projection: sourceProjectionObj || projectionObj }; return getFeatureInfoUrl(options, coordinate, resolution); } /** * Return the GetLegendGraphic URL, optionally optimized for the passed * resolution and possibly including any passed specific parameters. Returns * `undefined` if the GetLegendGraphic URL cannot be constructed. * * @param {number} [resolution] Resolution. If set to undefined, `SCALE` * will not be calculated and included in URL. * @param {Object} [params] GetLegendGraphic params. If `LAYER` is set, the * request is generated for this wms layer, else it will try to use the * configured wms layer. Default `FORMAT` is `image/png`. * `VERSION` should not be specified here. * @return {string|undefined} GetLegendGraphic URL. * @api */ getLegendUrl(resolution, params) { return getLegendUrl( { url: this.url_, params: { ...this.params_, ...params } }, resolution ); } /** * Get the user-provided params, i.e. those passed to the constructor through * the "params" option, and possibly updated using the updateParams method. * @return {Object} Params. * @api */ getParams() { return this.params_; } /** * @param {import("../extent.js").Extent} extent Extent. * @param {number} resolution Resolution. * @param {number} pixelRatio Pixel ratio. * @param {import("../proj/Projection.js").default} projection Projection. * @return {import("../Image.js").default} Single image. * @override */ getImageInternal(extent, resolution, pixelRatio, projection) { if (this.url_ === void 0) { return null; } if (!this.loader || this.loaderProjection_ !== projection) { this.loaderProjection_ = projection; this.loader = createLoader4({ crossOrigin: this.crossOrigin_, params: this.params_, projection, serverType: this.serverType_, hidpi: this.hidpi_, url: this.url_, ratio: this.ratio_, load: (image, src) => { this.image.setImage(image); this.imageLoadFunction_(this.image, src); return decode(image); } }); } return super.getImageInternal(extent, resolution, pixelRatio, projection); } /** * Return the image load function of the source. * @return {import("../Image.js").LoadFunction} The image load function. * @api */ getImageLoadFunction() { return this.imageLoadFunction_; } /** * Return the URL used for this WMS source. * @return {string|undefined} URL. * @api */ getUrl() { return this.url_; } /** * Set the image load function of the source. * @param {import("../Image.js").LoadFunction} imageLoadFunction Image load function. * @api */ setImageLoadFunction(imageLoadFunction) { this.imageLoadFunction_ = imageLoadFunction; this.changed(); } /** * Set the URL to use for requests. * @param {string|undefined} url URL. * @api */ setUrl(url) { if (url != this.url_) { this.url_ = url; this.loader = null; this.changed(); } } /** * Set the user-provided params. * @param {Object} params Params. * @api */ setParams(params) { this.params_ = Object.assign({}, params); this.changed(); } /** * Update the user-provided params. * @param {Object} params Params. * @api */ updateParams(params) { Object.assign(this.params_, params); this.changed(); } /** * @override */ changed() { this.image = null; super.changed(); } }; var ImageWMS_default = ImageWMS; // node_modules/ol/net.js function jsonp(url, callback, errback, callbackParam) { const script = document.createElement("script"); const key = "olc_" + getUid(callback); function cleanup() { delete window[key]; script.parentNode.removeChild(script); } script.async = true; script.src = url + (url.includes("?") ? "&" : "?") + (callbackParam || "callback") + "=" + key; const timer = setTimeout(function() { cleanup(); if (errback) { errback(); } }, 1e4); window[key] = function(data) { clearTimeout(timer); cleanup(); callback(data); }; document.head.appendChild(script); } var ResponseError = class extends Error { /** * @param {XMLHttpRequest} response The XHR object. */ constructor(response) { const message = "Unexpected response status: " + response.status; super(message); this.name = "ResponseError"; this.response = response; } }; var ClientError = class extends Error { /** * @param {XMLHttpRequest} client The XHR object. */ constructor(client) { super("Failed to issue request"); this.name = "ClientError"; this.client = client; } }; function getJSON(url) { return new Promise(function(resolve, reject) { function onLoad(event) { const client2 = event.target; if (!client2.status || client2.status >= 200 && client2.status < 300) { let data; try { data = JSON.parse(client2.responseText); } catch (err) { const message = "Error parsing response text as JSON: " + err.message; reject(new Error(message)); return; } resolve(data); return; } reject(new ResponseError(client2)); } function onError(event) { reject(new ClientError(event.target)); } const client = new XMLHttpRequest(); client.addEventListener("load", onLoad); client.addEventListener("error", onError); client.open("GET", url); client.setRequestHeader("Accept", "application/json"); client.send(); }); } function resolveUrl(base, url) { if (url.includes("://")) { return url; } return new URL(url, base).href; } // node_modules/ol/source/ogcTileUtil.js var knownMapMediaTypes = { "image/png": true, "image/jpeg": true, "image/gif": true, "image/webp": true }; var knownVectorMediaTypes = { "application/vnd.mapbox-vector-tile": true, "application/geo+json": true }; function appendCollectionsQueryParam(tileUrlTemplate, collections) { if (!collections.length) { return tileUrlTemplate; } const url = new URL(tileUrlTemplate, "file:/"); if (url.pathname.split("/").includes("collections")) { error( 'The "collections" query parameter cannot be added to collection endpoints' ); return tileUrlTemplate; } const encodedCollections = collections.map((c) => encodeURIComponent(c)).join(","); url.searchParams.append("collections", encodedCollections); const baseUrl = tileUrlTemplate.split("?")[0]; const queryParams = decodeURIComponent(url.searchParams.toString()); return `${baseUrl}?${queryParams}`; } function getMapTileUrlTemplate(links, mediaType, collections) { let tileUrlTemplate; let fallbackUrlTemplate; for (let i = 0; i < links.length; ++i) { const link = links[i]; if (link.rel === "item") { if (link.type === mediaType) { tileUrlTemplate = link.href; break; } if (knownMapMediaTypes[link.type]) { fallbackUrlTemplate = link.href; } else if (!fallbackUrlTemplate && link.type.startsWith("image/")) { fallbackUrlTemplate = link.href; } } } if (!tileUrlTemplate) { if (fallbackUrlTemplate) { tileUrlTemplate = fallbackUrlTemplate; } else { throw new Error('Could not find "item" link'); } } if (collections) { tileUrlTemplate = appendCollectionsQueryParam(tileUrlTemplate, collections); } return tileUrlTemplate; } function getVectorTileUrlTemplate(links, mediaType, supportedMediaTypes, collections) { let tileUrlTemplate; let fallbackUrlTemplate; const hrefLookup = {}; for (let i = 0; i < links.length; ++i) { const link = links[i]; hrefLookup[link.type] = link.href; if (link.rel === "item") { if (link.type === mediaType) { tileUrlTemplate = link.href; break; } if (knownVectorMediaTypes[link.type]) { fallbackUrlTemplate = link.href; } } } if (!tileUrlTemplate && supportedMediaTypes) { for (let i = 0; i < supportedMediaTypes.length; ++i) { const supportedMediaType = supportedMediaTypes[i]; if (hrefLookup[supportedMediaType]) { tileUrlTemplate = hrefLookup[supportedMediaType]; break; } } } if (!tileUrlTemplate) { if (fallbackUrlTemplate) { tileUrlTemplate = fallbackUrlTemplate; } else { throw new Error('Could not find "item" link'); } } if (collections) { tileUrlTemplate = appendCollectionsQueryParam(tileUrlTemplate, collections); } return tileUrlTemplate; } function parseTileMatrixSet(sourceInfo, tileMatrixSet, tileUrlTemplate, tileMatrixSetLimits) { let projection = sourceInfo.projection; if (!projection) { if (typeof tileMatrixSet.crs === "string") { projection = get(tileMatrixSet.crs); } else if ("uri" in tileMatrixSet.crs) { projection = get(tileMatrixSet.crs.uri); } if (!projection) { throw new Error(`Unsupported CRS: ${JSON.stringify(tileMatrixSet.crs)}`); } } const orderedAxes = tileMatrixSet.orderedAxes; const axisOrientation = orderedAxes ? orderedAxes.slice(0, 2).map((s) => s.replace(/E|X|Lon/i, "e").replace(/N|Y|Lat/i, "n")).join("") : projection.getAxisOrientation(); const backwards = !axisOrientation.startsWith("en"); const matrices = tileMatrixSet.tileMatrices; const matrixLookup = {}; for (let i = 0; i < matrices.length; ++i) { const matrix = matrices[i]; matrixLookup[matrix.id] = matrix; } const limitLookup = {}; const matrixIds = []; if (tileMatrixSetLimits) { for (let i = 0; i < tileMatrixSetLimits.length; ++i) { const limit = tileMatrixSetLimits[i]; const id = limit.tileMatrix; matrixIds.push(id); limitLookup[id] = limit; } } else { for (let i = 0; i < matrices.length; ++i) { const id = matrices[i].id; matrixIds.push(id); } } const length = matrixIds.length; const origins = new Array(length); const resolutions = new Array(length); const sizes = new Array(length); const tileSizes = new Array(length); const extent = [-Infinity, -Infinity, Infinity, Infinity]; for (let i = 0; i < length; ++i) { const id = matrixIds[i]; const matrix = matrixLookup[id]; const origin = matrix.pointOfOrigin; if (backwards) { origins[i] = [origin[1], origin[0]]; } else { origins[i] = origin; } resolutions[i] = matrix.cellSize; sizes[i] = [matrix.matrixWidth, matrix.matrixHeight]; tileSizes[i] = [matrix.tileWidth, matrix.tileHeight]; const limit = limitLookup[id]; if (limit) { const tileMapWidth = matrix.cellSize * matrix.tileWidth; const minX = origins[i][0] + limit.minTileCol * tileMapWidth; const maxX = origins[i][0] + (limit.maxTileCol + 1) * tileMapWidth; const tileMapHeight = matrix.cellSize * matrix.tileHeight; const upsideDown = matrix.cornerOfOrigin === "bottomLeft"; let minY; let maxY; if (upsideDown) { minY = origins[i][1] + limit.minTileRow * tileMapHeight; maxY = origins[i][1] + (limit.maxTileRow + 1) * tileMapHeight; } else { minY = origins[i][1] - (limit.maxTileRow + 1) * tileMapHeight; maxY = origins[i][1] - limit.minTileRow * tileMapHeight; } getIntersection(extent, [minX, minY, maxX, maxY], extent); } } const tileGrid = new TileGrid_default({ origins, resolutions, sizes, tileSizes, extent: tileMatrixSetLimits ? extent : void 0 }); const context = sourceInfo.context; const base = sourceInfo.url; function tileUrlFunction(tileCoord, pixelRatio, projection2) { if (!tileCoord) { return void 0; } const id = matrixIds[tileCoord[0]]; const matrix = matrixLookup[id]; const upsideDown = matrix.cornerOfOrigin === "bottomLeft"; const localContext = { tileMatrix: id, tileCol: tileCoord[1], tileRow: upsideDown ? -tileCoord[2] - 1 : tileCoord[2] }; if (tileMatrixSetLimits) { const limit = limitLookup[matrix.id]; if (localContext.tileCol < limit.minTileCol || localContext.tileCol > limit.maxTileCol || localContext.tileRow < limit.minTileRow || localContext.tileRow > limit.maxTileRow) { return void 0; } } Object.assign( localContext, { z: localContext.tileMatrix, x: localContext.tileCol, y: localContext.tileRow }, context ); const url = tileUrlTemplate.replace(/\{(\w+?)\}/g, function(m, p) { return localContext[p]; }); return resolveUrl(base, url); } return { grid: tileGrid, projection, urlTemplate: tileUrlTemplate, urlFunction: tileUrlFunction }; } function parseTileSetMetadata(sourceInfo, tileSet) { const tileMatrixSetLimits = tileSet.tileMatrixSetLimits; let tileUrlTemplate; if (tileSet.dataType === "map") { tileUrlTemplate = getMapTileUrlTemplate( tileSet.links, sourceInfo.mediaType, sourceInfo.collections ); } else if (tileSet.dataType === "vector") { tileUrlTemplate = getVectorTileUrlTemplate( tileSet.links, sourceInfo.mediaType, sourceInfo.supportedMediaTypes, sourceInfo.collections ); } else { throw new Error('Expected tileset data type to be "map" or "vector"'); } if (tileSet.tileMatrixSet) { return parseTileMatrixSet( sourceInfo, tileSet.tileMatrixSet, tileUrlTemplate, tileMatrixSetLimits ); } const tileMatrixSetLink = tileSet.links.find( (link) => link.rel === "http://www.opengis.net/def/rel/ogc/1.0/tiling-scheme" ); if (!tileMatrixSetLink) { throw new Error( "Expected http://www.opengis.net/def/rel/ogc/1.0/tiling-scheme link or tileMatrixSet" ); } const tileMatrixSetDefinition = tileMatrixSetLink.href; const url = resolveUrl(sourceInfo.url, tileMatrixSetDefinition); return getJSON(url).then(function(tileMatrixSet) { return parseTileMatrixSet( sourceInfo, tileMatrixSet, tileUrlTemplate, tileMatrixSetLimits ); }); } function getTileSetInfo(sourceInfo) { return getJSON(sourceInfo.url).then(function(tileSet) { return parseTileSetMetadata(sourceInfo, tileSet); }); } // node_modules/ol/source/OGCMapTile.js var OGCMapTile = class extends TileImage_default { /** * @param {Options} options OGC map tile options. */ constructor(options) { super({ attributions: options.attributions, cacheSize: options.cacheSize, crossOrigin: options.crossOrigin, interpolate: options.interpolate, projection: options.projection, reprojectionErrorThreshold: options.reprojectionErrorThreshold, state: "loading", tileLoadFunction: options.tileLoadFunction, wrapX: options.wrapX !== void 0 ? options.wrapX : true, transition: options.transition }); const sourceInfo = { url: options.url, projection: this.getProjection(), mediaType: options.mediaType, context: options.context || null, collections: options.collections }; getTileSetInfo(sourceInfo).then(this.handleTileSetInfo_.bind(this)).catch(this.handleError_.bind(this)); } /** * @param {import("./ogcTileUtil.js").TileSetInfo} tileSetInfo Tile set info. * @private */ handleTileSetInfo_(tileSetInfo) { this.tileGrid = tileSetInfo.grid; this.projection = tileSetInfo.projection; this.setTileUrlFunction(tileSetInfo.urlFunction, tileSetInfo.urlTemplate); this.setState("ready"); } /** * @private * @param {Error} error The error. */ handleError_(error2) { error(error2); this.setState("error"); } }; var OGCMapTile_default = OGCMapTile; // node_modules/ol/VectorRenderTile.js var canvasPool = []; var VectorRenderTile = class extends Tile_default { /** * @param {import("./tilecoord.js").TileCoord} tileCoord Tile coordinate. * @param {import("./TileState.js").default} state State. * @param {import("./tilecoord.js").TileCoord} urlTileCoord Wrapped tile coordinate for source urls. * @param {function(VectorRenderTile):Array} getSourceTiles Function. * @param {function(VectorRenderTile):void} removeSourceTiles Function. */ constructor(tileCoord, state, urlTileCoord, getSourceTiles, removeSourceTiles) { super(tileCoord, state, { transition: 0 }); this.context_ = null; this.executorGroups = {}; this.loadingSourceTiles = 0; this.hitDetectionImageData = {}; this.replayState_ = {}; this.sourceTiles = []; this.errorTileKeys = {}; this.wantedResolution; this.getSourceTiles = getSourceTiles.bind(void 0, this); this.removeSourceTiles_ = removeSourceTiles; this.wrappedTileCoord = urlTileCoord; } /** * @return {CanvasRenderingContext2D|OffscreenCanvasRenderingContext2D} The rendering context. */ getContext() { if (!this.context_) { this.context_ = createCanvasContext2D(1, 1, canvasPool); } return this.context_; } /** * @return {boolean} Tile has a rendering context. */ hasContext() { return !!this.context_; } /** * Get the Canvas for this tile. * @return {HTMLCanvasElement|OffscreenCanvas} Canvas. */ getImage() { return this.hasContext() ? this.getContext().canvas : null; } /** * @param {import("./layer/Layer.js").default} layer Layer. * @return {ReplayState} The replay state. */ getReplayState(layer) { const key = getUid(layer); if (!(key in this.replayState_)) { this.replayState_[key] = { dirty: false, renderedRenderOrder: null, renderedResolution: NaN, renderedRevision: -1, renderedTileResolution: NaN, renderedTileRevision: -1, renderedTileZ: -1 }; } return this.replayState_[key]; } /** * Load the tile. * @override */ load() { this.getSourceTiles(); } /** * Remove from the cache due to expiry * @override */ release() { if (this.context_) { releaseCanvas(this.context_); canvasPool.push(this.context_.canvas); this.context_ = null; } this.removeSourceTiles_(this); this.sourceTiles.length = 0; super.release(); } }; var VectorRenderTile_default = VectorRenderTile; // node_modules/ol/VectorTile.js var VectorTile = class extends Tile_default { /** * @param {import("./tilecoord.js").TileCoord} tileCoord Tile coordinate. * @param {import("./TileState.js").default} state State. * @param {string} src Data source url. * @param {import("./format/Feature.js").default} format Feature format. * @param {import("./Tile.js").LoadFunction} tileLoadFunction Tile load function. * @param {import("./Tile.js").Options} [options] Tile options. */ constructor(tileCoord, state, src, format, tileLoadFunction, options) { super(tileCoord, state, options); this.extent = null; this.format_ = format; this.features_ = null; this.loader_; this.projection = null; this.resolution; this.tileLoadFunction_ = tileLoadFunction; this.url_ = src; this.key = src; } /** * @return {string} Tile url. */ getTileUrl() { return this.url_; } /** * Get the feature format assigned for reading this tile's features. * @return {import("./format/Feature.js").default} Feature format. * @api */ getFormat() { return this.format_; } /** * Get the features for this tile. Geometries will be in the view projection. * @return {Array} Features. * @api */ getFeatures() { return this.features_; } /** * Load not yet loaded URI. * @override */ load() { if (this.state == TileState_default.IDLE) { this.setState(TileState_default.LOADING); this.tileLoadFunction_(this, this.url_); if (this.loader_) { this.loader_(this.extent, this.resolution, this.projection); } } } /** * Handler for successful tile load. * @param {Array} features The loaded features. * @param {import("./proj/Projection.js").default} dataProjection Data projection. */ onLoad(features, dataProjection) { this.setFeatures(features); } /** * Handler for tile load errors. */ onError() { this.setState(TileState_default.ERROR); } /** * Function for use in a {@link module:ol/source/VectorTile~VectorTile}'s `tileLoadFunction`. * Sets the features for the tile. * @param {Array} features Features. * @api */ setFeatures(features) { this.features_ = features; this.setState(TileState_default.LOADED); } /** * Set the feature loader for reading this tile's features. * @param {import("./featureloader.js").FeatureLoader} loader Feature loader. * @api */ setLoader(loader) { this.loader_ = loader; } }; var VectorTile_default = VectorTile; // node_modules/ol/source/VectorTile.js var VectorTile2 = class extends UrlTile_default { /** * @param {!Options} options Vector tile options. */ constructor(options) { const projection = options.projection || "EPSG:3857"; const extent = options.extent || extentFromProjection(projection); const tileGrid = options.tileGrid || createXYZ({ extent, maxResolution: options.maxResolution, maxZoom: options.maxZoom !== void 0 ? options.maxZoom : 22, minZoom: options.minZoom, tileSize: options.tileSize || 512 }); super({ attributions: options.attributions, attributionsCollapsible: options.attributionsCollapsible, cacheSize: options.cacheSize, interpolate: true, projection, state: options.state, tileGrid, tileLoadFunction: options.tileLoadFunction ? options.tileLoadFunction : defaultLoadFunction, tileUrlFunction: options.tileUrlFunction, url: options.url, urls: options.urls, wrapX: options.wrapX === void 0 ? true : options.wrapX, transition: options.transition, zDirection: options.zDirection === void 0 ? 1 : options.zDirection }); this.format_ = options.format ? options.format : null; this.tileKeysBySourceTileUrl_ = {}; this.sourceTiles_ = {}; this.overlaps_ = options.overlaps == void 0 ? true : options.overlaps; this.tileClass = options.tileClass ? options.tileClass : VectorTile_default; this.tileGrids_ = {}; } /** * @return {boolean} The source can have overlapping geometries. */ getOverlaps() { return this.overlaps_; } /** * @param {number} pixelRatio Pixel ratio. * @param {import("../proj/Projection").default} projection Projection. * @param {VectorRenderTile} tile Vector render tile. * @return {Array} Tile keys. */ getSourceTiles(pixelRatio, projection, tile) { if (tile.getState() === TileState_default.IDLE) { tile.setState(TileState_default.LOADING); const urlTileCoord = tile.wrappedTileCoord; const tileGrid = this.getTileGridForProjection(projection); let extent = tileGrid.getTileCoordExtent(urlTileCoord); const z = urlTileCoord[0]; const resolution = tileGrid.getResolution(z); buffer(extent, -resolution, extent); const sourceProjection = this.projection; if (projection && this.projection && !equivalent(projection, sourceProjection)) { extent = transformExtent(extent, projection, sourceProjection); } const sourceTileGrid = this.tileGrid; const sourceExtent = sourceTileGrid.getExtent(); if (sourceExtent) { getIntersection(extent, sourceExtent, extent); } let sourceResolution = resolution; if (projection && sourceProjection && !equivalent(projection, sourceProjection)) { sourceResolution = resolution / sourceProjection.getMetersPerUnit() / projection.getMetersPerUnit(); } const sourceZ = sourceTileGrid.getZForResolution( sourceResolution, this.zDirection ); sourceTileGrid.forEachTileCoord(extent, sourceZ, (sourceTileCoord) => { const tileUrl = this.tileUrlFunction( sourceTileCoord, pixelRatio, projection ); if (!this.sourceTiles_[tileUrl]) { this.sourceTiles_[tileUrl] = new this.tileClass( sourceTileCoord, tileUrl ? TileState_default.IDLE : TileState_default.EMPTY, tileUrl, this.format_, this.tileLoadFunction ); } const sourceTile = this.sourceTiles_[tileUrl]; tile.sourceTiles.push(sourceTile); if (!this.tileKeysBySourceTileUrl_[tileUrl]) { this.tileKeysBySourceTileUrl_[tileUrl] = []; } this.tileKeysBySourceTileUrl_[tileUrl].push(tile.getKey()); const sourceTileState = sourceTile.getState(); if (sourceTileState < TileState_default.LOADED) { const listenChange = (event) => { this.handleTileChange(event); const state = sourceTile.getState(); if (state === TileState_default.LOADED || state === TileState_default.ERROR) { const sourceTileKey = sourceTile.getKey(); if (sourceTileKey in tile.errorTileKeys) { if (sourceTile.getState() === TileState_default.LOADED) { delete tile.errorTileKeys[sourceTileKey]; } } else { tile.loadingSourceTiles--; } if (state === TileState_default.ERROR) { tile.errorTileKeys[sourceTileKey] = true; } else { sourceTile.removeEventListener(EventType_default.CHANGE, listenChange); } if (tile.loadingSourceTiles === 0) { tile.setState( isEmpty(tile.errorTileKeys) ? TileState_default.LOADED : TileState_default.ERROR ); } } }; sourceTile.addEventListener(EventType_default.CHANGE, listenChange); tile.loadingSourceTiles++; } if (sourceTileState === TileState_default.IDLE) { sourceTile.extent = sourceTileGrid.getTileCoordExtent(sourceTileCoord); sourceTile.projection = this.projection; sourceTile.resolution = sourceTileGrid.getResolution( sourceTileCoord[0] ); sourceTile.load(); } }); if (!tile.loadingSourceTiles) { tile.setState( tile.sourceTiles.some( (sourceTile) => sourceTile.getState() === TileState_default.ERROR ) ? TileState_default.ERROR : TileState_default.LOADED ); } } return tile.sourceTiles; } /** * @param {VectorRenderTile} tile Vector render tile. */ removeSourceTiles(tile) { const tileKey = tile.getKey(); const sourceTiles = tile.sourceTiles; for (let i = 0, ii = sourceTiles.length; i < ii; ++i) { const sourceTileUrl = sourceTiles[i].getTileUrl(); if (!this.tileKeysBySourceTileUrl_[sourceTileUrl]) { return; } const index = this.tileKeysBySourceTileUrl_[sourceTileUrl].indexOf(tileKey); if (index === -1) { continue; } this.tileKeysBySourceTileUrl_[sourceTileUrl].splice(index, 1); if (this.tileKeysBySourceTileUrl_[sourceTileUrl].length === 0) { delete this.tileKeysBySourceTileUrl_[sourceTileUrl]; delete this.sourceTiles_[sourceTileUrl]; } } } /** * @param {number} z Tile coordinate z. * @param {number} x Tile coordinate x. * @param {number} y Tile coordinate y. * @param {number} pixelRatio Pixel ratio. * @param {import("../proj/Projection.js").default} projection Projection. * @return {!VectorRenderTile} Tile. * @override */ getTile(z, x, y, pixelRatio, projection) { const tileCoord = [z, x, y]; let urlTileCoord = this.getTileCoordForTileUrlFunction( tileCoord, projection ); const sourceExtent = this.getTileGrid().getExtent(); const sourceProjection = this.projection; const tileGrid = this.getTileGridForProjection(projection); if (urlTileCoord && sourceExtent) { const tileExtent = tileGrid.getTileCoordExtent(urlTileCoord); buffer(tileExtent, -tileGrid.getResolution(z), tileExtent); if (!intersects( sourceExtent, !projection || !sourceProjection || equivalent(projection, sourceProjection) ? tileExtent : transformExtent(tileExtent, projection, sourceProjection) )) { urlTileCoord = null; } } let empty = true; if (urlTileCoord !== null) { const sourceTileGrid = this.tileGrid; const resolution = tileGrid.getResolution(z); let sourceResolution = resolution; if (projection && sourceProjection && !equivalent(projection, sourceProjection)) { sourceResolution = resolution / sourceProjection.getMetersPerUnit() / projection.getMetersPerUnit(); } const sourceZ = sourceTileGrid.getZForResolution(sourceResolution, 1); const extent = tileGrid.getTileCoordExtent(urlTileCoord); buffer(extent, -resolution, extent); sourceTileGrid.forEachTileCoord( !projection || !sourceProjection || equivalent(projection, sourceProjection) ? extent : transformExtent(extent, projection, sourceProjection), sourceZ, (sourceTileCoord) => { empty = empty && !this.tileUrlFunction( sourceTileCoord, pixelRatio, sourceProjection ); } ); } const newTile = new VectorRenderTile_default( tileCoord, empty ? TileState_default.EMPTY : TileState_default.IDLE, urlTileCoord, this.getSourceTiles.bind(this, pixelRatio, projection), this.removeSourceTiles.bind(this) ); newTile.key = this.getKey(); return newTile; } /** * @param {import("../proj/Projection.js").default} projection Projection. * @return {!import("../tilegrid/TileGrid.js").default} Tile grid. * @override */ getTileGridForProjection(projection) { const code = projection.getCode(); let tileGrid = this.tileGrids_[code]; if (!tileGrid) { const sourceProjection = this.projection; if (sourceProjection !== null && !equivalent(sourceProjection, projection)) { return getForProjection(projection); } const sourceTileGrid = this.tileGrid; const resolutions = sourceTileGrid.getResolutions().slice(); const origins = resolutions.map(function(resolution, z) { return sourceTileGrid.getOrigin(z); }); const tileSizes = resolutions.map(function(resolution, z) { return sourceTileGrid.getTileSize(z); }); const length = DEFAULT_MAX_ZOOM + 1; for (let z = resolutions.length; z < length; ++z) { resolutions.push(resolutions[z - 1] / 2); origins.push(origins[z - 1]); tileSizes.push(tileSizes[z - 1]); } tileGrid = new TileGrid_default({ extent: sourceTileGrid.getExtent(), origins, resolutions, tileSizes }); this.tileGrids_[code] = tileGrid; } return tileGrid; } /** * Get the tile pixel ratio for this source. * @param {number} pixelRatio Pixel ratio. * @return {number} Tile pixel ratio. * @override */ getTilePixelRatio(pixelRatio) { return pixelRatio; } /** * @param {number} z Z. * @param {number} pixelRatio Pixel ratio. * @param {import("../proj/Projection.js").default} projection Projection. * @return {import("../size.js").Size} Tile size. * @override */ getTilePixelSize(z, pixelRatio, projection) { const tileGrid = this.getTileGridForProjection(projection); const tileSize = toSize(tileGrid.getTileSize(z), this.tmpSize); return [ Math.round(tileSize[0] * pixelRatio), Math.round(tileSize[1] * pixelRatio) ]; } /** * @param {boolean} overlaps The source has overlapping geometries. */ setOverlaps(overlaps) { this.overlaps_ = overlaps; this.changed(); } }; var VectorTile_default2 = VectorTile2; function defaultLoadFunction(tile, url) { tile.setLoader( /** * @param {import("../extent.js").Extent} extent Extent. * @param {number} resolution Resolution. * @param {import("../proj/Projection.js").default} projection Projection. */ function(extent, resolution, projection) { loadFeaturesXhr( url, tile.getFormat(), extent, resolution, projection, tile.onLoad.bind(tile), tile.onError.bind(tile) ); } ); } // node_modules/ol/source/OGCVectorTile.js var OGCVectorTile = class extends VectorTile_default2 { /** * @param {Options} options OGC vector tile options. */ constructor(options) { super({ attributions: options.attributions, attributionsCollapsible: options.attributionsCollapsible, cacheSize: options.cacheSize, format: options.format, overlaps: options.overlaps, projection: options.projection, tileClass: options.tileClass, transition: options.transition, wrapX: options.wrapX, zDirection: options.zDirection, state: "loading" }); const sourceInfo = { url: options.url, projection: this.getProjection(), mediaType: options.mediaType, supportedMediaTypes: options.format.supportedMediaTypes, context: options.context || null, collections: options.collections }; getTileSetInfo(sourceInfo).then(this.handleTileSetInfo_.bind(this)).catch(this.handleError_.bind(this)); } /** * @param {import("./ogcTileUtil.js").TileSetInfo} tileSetInfo Tile set info. * @private */ handleTileSetInfo_(tileSetInfo) { this.tileGrid = tileSetInfo.grid; this.projection = tileSetInfo.projection; this.setTileUrlFunction(tileSetInfo.urlFunction, tileSetInfo.urlTemplate); this.setState("ready"); } /** * @private * @param {Error} error The error. */ handleError_(error2) { error(error2); this.setState("error"); } }; var OGCVectorTile_default = OGCVectorTile; // node_modules/ol/source/Raster.js function createMinion(operation) { return function(data) { const buffers = data["buffers"]; const meta = data["meta"]; const imageOps = data["imageOps"]; const width = data["width"]; const height = data["height"]; const numBuffers = buffers.length; const numBytes = buffers[0].byteLength; if (imageOps) { const images = new Array(numBuffers); for (let b = 0; b < numBuffers; ++b) { images[b] = new ImageData( new Uint8ClampedArray(buffers[b]), width, height ); } const output2 = operation(images, meta).data; return output2.buffer; } const output = new Uint8ClampedArray(numBytes); const arrays = new Array(numBuffers); const pixels = new Array(numBuffers); for (let b = 0; b < numBuffers; ++b) { arrays[b] = new Uint8ClampedArray(buffers[b]); pixels[b] = [0, 0, 0, 0]; } for (let i = 0; i < numBytes; i += 4) { for (let j = 0; j < numBuffers; ++j) { const array = arrays[j]; pixels[j][0] = array[i]; pixels[j][1] = array[i + 1]; pixels[j][2] = array[i + 2]; pixels[j][3] = array[i + 3]; } const pixel = operation(pixels, meta); output[i] = pixel[0]; output[i + 1] = pixel[1]; output[i + 2] = pixel[2]; output[i + 3] = pixel[3]; } return output.buffer; }; } function createWorker(config, onMessage) { const lib = Object.keys(config.lib || {}).map(function(name) { return "const " + name + " = " + config.lib[name].toString() + ";"; }); const lines = lib.concat([ "const __minion__ = (" + createMinion.toString() + ")(", config.operation.toString(), ");", 'self.addEventListener("message", function(event) {', " const buffer = __minion__(event.data);", " self.postMessage({buffer: buffer, meta: event.data.meta}, [buffer]);", "});" ]); const worker = new Worker( typeof Blob === "undefined" ? "data:text/javascript;base64," + Buffer.from(lines.join("\n"), "binary").toString("base64") : URL.createObjectURL(new Blob(lines, { type: "text/javascript" })) ); worker.addEventListener("message", onMessage); return worker; } function createFauxWorker(config, onMessage) { const minion = createMinion(config.operation); let terminated = false; return { postMessage: function(data) { setTimeout(function() { if (terminated) { return; } onMessage({ data: { buffer: minion(data), meta: data["meta"] } }); }, 0); }, terminate: function() { terminated = true; } }; } var Processor = class extends Disposable_default { /** * @param {ProcessorOptions} config Configuration. */ constructor(config) { super(); this.imageOps_ = !!config.imageOps; let threads; if (config.threads === 0) { threads = 0; } else if (this.imageOps_) { threads = 1; } else { threads = config.threads || 1; } const workers = new Array(threads); if (threads) { for (let i = 0; i < threads; ++i) { workers[i] = createWorker(config, this.onWorkerMessage_.bind(this, i)); } } else { workers[0] = createFauxWorker( config, this.onWorkerMessage_.bind(this, 0) ); } this.workers_ = workers; this.queue_ = []; this.maxQueueLength_ = config.queue || Infinity; this.running_ = 0; this.dataLookup_ = {}; this.job_ = null; } /** * Run operation on input data. * @param {Array} inputs Array of image data. * @param {Object} meta A user data object. This is passed to all operations * and must be serializable. * @param {function(Error, ImageData, Object): void} callback Called when work * completes. The first argument is any error. The second is the ImageData * generated by operations. The third is the user data object. */ process(inputs, meta, callback) { this.enqueue_({ inputs, meta, callback }); this.dispatch_(); } /** * Add a job to the queue. * @param {Job} job The job. */ enqueue_(job) { this.queue_.push(job); while (this.queue_.length > this.maxQueueLength_) { this.queue_.shift().callback(null, null); } } /** * Dispatch a job. */ dispatch_() { if (this.running_ || this.queue_.length === 0) { return; } const job = this.queue_.shift(); this.job_ = job; const width = job.inputs[0].width; const height = job.inputs[0].height; const buffers = job.inputs.map(function(input) { return input.data.buffer; }); const threads = this.workers_.length; this.running_ = threads; if (threads === 1) { this.workers_[0].postMessage( { buffers, meta: job.meta, imageOps: this.imageOps_, width, height }, buffers ); return; } const length = job.inputs[0].data.length; const segmentLength = 4 * Math.ceil(length / 4 / threads); for (let i = 0; i < threads; ++i) { const offset = i * segmentLength; const slices = []; for (let j = 0, jj = buffers.length; j < jj; ++j) { slices.push(buffers[j].slice(offset, offset + segmentLength)); } this.workers_[i].postMessage( { buffers: slices, meta: job.meta, imageOps: this.imageOps_, width, height }, slices ); } } /** * Handle messages from the worker. * @param {number} index The worker index. * @param {MessageEvent} event The message event. */ onWorkerMessage_(index, event) { if (this.disposed) { return; } this.dataLookup_[index] = event.data; --this.running_; if (this.running_ === 0) { this.resolveJob_(); } } /** * Resolve a job. If there are no more worker threads, the processor callback * will be called. */ resolveJob_() { const job = this.job_; const threads = this.workers_.length; let data, meta; if (threads === 1) { data = new Uint8ClampedArray(this.dataLookup_[0]["buffer"]); meta = this.dataLookup_[0]["meta"]; } else { const length = job.inputs[0].data.length; data = new Uint8ClampedArray(length); meta = new Array(threads); const segmentLength = 4 * Math.ceil(length / 4 / threads); for (let i = 0; i < threads; ++i) { const buffer3 = this.dataLookup_[i]["buffer"]; const offset = i * segmentLength; data.set(new Uint8ClampedArray(buffer3), offset); meta[i] = this.dataLookup_[i]["meta"]; } } this.job_ = null; this.dataLookup_ = {}; job.callback( null, new ImageData(data, job.inputs[0].width, job.inputs[0].height), meta ); this.dispatch_(); } /** * Terminate all workers associated with the processor. * @override */ disposeInternal() { for (let i = 0; i < this.workers_.length; ++i) { this.workers_[i].terminate(); } this.workers_.length = 0; } }; var RasterEventType = { /** * Triggered before operations are run. Listeners will receive an event object with * a `data` property that can be used to make data available to operations. * @event module:ol/source/Raster.RasterSourceEvent#beforeoperations * @api */ BEFOREOPERATIONS: "beforeoperations", /** * Triggered after operations are run. Listeners will receive an event object with * a `data` property. If more than one thread is used, `data` will be an array of * objects. If a single thread is used, `data` will be a single object. * @event module:ol/source/Raster.RasterSourceEvent#afteroperations * @api */ AFTEROPERATIONS: "afteroperations" }; var RasterSourceEvent = class extends Event_default { /** * @param {string} type Type. * @param {import("../Map.js").FrameState} frameState The frame state. * @param {Object|Array} data An object made available to operations. For "afteroperations" evenets * this will be an array of objects if more than one thread is used. */ constructor(type, frameState, data) { super(type); this.extent = frameState.extent; this.resolution = frameState.viewState.resolution / frameState.pixelRatio; this.data = data; } }; var RasterSource = class extends Image_default4 { /** * @param {Options} options Options. */ constructor(options) { super({ projection: null }); this.on; this.once; this.un; this.processor_ = null; this.operationType_ = options.operationType !== void 0 ? options.operationType : "pixel"; this.threads_ = options.threads !== void 0 ? options.threads : 1; this.layers_ = createLayers(options.sources); const changed = this.changed.bind(this); for (let i = 0, ii = this.layers_.length; i < ii; ++i) { this.layers_[i].addEventListener(EventType_default.CHANGE, changed); } this.useResolutions_ = options.resolutions !== null; this.tileQueue_ = new TileQueue_default(function() { return 1; }, this.processSources_.bind(this)); this.requestedFrameState_; this.renderedImageCanvas_ = null; this.renderedRevision_; this.frameState_ = { animate: false, coordinateToPixelTransform: create(), declutter: null, extent: null, index: 0, layerIndex: 0, layerStatesArray: getLayerStatesArray(this.layers_), pixelRatio: 1, pixelToCoordinateTransform: create(), postRenderFunctions: [], size: [0, 0], tileQueue: this.tileQueue_, time: Date.now(), usedTiles: {}, viewState: ( /** @type {import("../View.js").State} */ { rotation: 0 } ), viewHints: [], wantedTiles: {}, mapId: getUid(this), renderTargets: {} }; this.setAttributions(function(frameState) { var _a; const attributions = []; for (let i = 0, iMax = options.sources.length; i < iMax; ++i) { const sourceOrLayer = options.sources[i]; const source = sourceOrLayer instanceof Source_default ? sourceOrLayer : sourceOrLayer.getSource(); if (!source) { continue; } const sourceAttributions = (_a = source.getAttributions()) == null ? void 0 : _a(frameState); if (typeof sourceAttributions === "string") { attributions.push(sourceAttributions); } else if (sourceAttributions !== void 0) { attributions.push(...sourceAttributions); } } return attributions; }); if (options.operation !== void 0) { this.setOperation(options.operation, options.lib); } } /** * Set the operation. * @param {Operation} operation New operation. * @param {Object} [lib] Functions that will be available to operations run * in a worker. * @api */ setOperation(operation, lib) { if (this.processor_) { this.processor_.dispose(); } this.processor_ = new Processor({ operation, imageOps: this.operationType_ === "image", queue: 1, lib, threads: this.threads_ }); this.changed(); } /** * Update the stored frame state. * @param {import("../extent.js").Extent} extent The view extent (in map units). * @param {number} resolution The view resolution. * @param {import("../proj/Projection.js").default} projection The view projection. * @return {import("../Map.js").FrameState} The updated frame state. * @private */ updateFrameState_(extent, resolution, projection) { const frameState = ( /** @type {import("../Map.js").FrameState} */ Object.assign({}, this.frameState_) ); frameState.viewState = /** @type {import("../View.js").State} */ Object.assign({}, frameState.viewState); const center = getCenter(extent); frameState.size[0] = Math.ceil(getWidth(extent) / resolution); frameState.size[1] = Math.ceil(getHeight(extent) / resolution); frameState.extent = [ center[0] - frameState.size[0] * resolution / 2, center[1] - frameState.size[1] * resolution / 2, center[0] + frameState.size[0] * resolution / 2, center[1] + frameState.size[1] * resolution / 2 ]; frameState.time = Date.now(); const viewState = frameState.viewState; viewState.center = center; viewState.projection = projection; viewState.resolution = resolution; return frameState; } /** * Determine if all sources are ready. * @return {boolean} All sources are ready. * @private */ allSourcesReady_() { let ready = true; let source; for (let i = 0, ii = this.layers_.length; i < ii; ++i) { source = this.layers_[i].getSource(); if (!source || source.getState() !== "ready") { ready = false; break; } } return ready; } /** * @param {import("../extent.js").Extent} extent Extent. * @param {number} resolution Resolution. * @param {number} pixelRatio Pixel ratio. * @param {import("../proj/Projection.js").default} projection Projection. * @return {import("../ImageCanvas.js").default} Single image. * @override */ getImage(extent, resolution, pixelRatio, projection) { if (!this.allSourcesReady_()) { return null; } this.tileQueue_.loadMoreTiles(16, 16); resolution = this.findNearestResolution(resolution); const frameState = this.updateFrameState_(extent, resolution, projection); this.requestedFrameState_ = frameState; if (this.renderedImageCanvas_) { const renderedResolution = this.renderedImageCanvas_.getResolution(); const renderedExtent = this.renderedImageCanvas_.getExtent(); if (resolution !== renderedResolution || !equals(frameState.extent, renderedExtent)) { this.renderedImageCanvas_ = null; } } if (!this.renderedImageCanvas_ || this.getRevision() !== this.renderedRevision_) { this.processSources_(); } if (frameState.animate) { requestAnimationFrame(this.changed.bind(this)); } return this.renderedImageCanvas_; } /** * Start processing source data. * @private */ processSources_() { const frameState = this.requestedFrameState_; const len = this.layers_.length; const imageDatas = new Array(len); for (let i = 0; i < len; ++i) { frameState.layerIndex = i; frameState.renderTargets = {}; const imageData = getImageData(this.layers_[i], frameState); if (imageData) { imageDatas[i] = imageData; } else { return; } } const data = {}; this.dispatchEvent( new RasterSourceEvent(RasterEventType.BEFOREOPERATIONS, frameState, data) ); this.processor_.process( imageDatas, data, this.onWorkerComplete_.bind(this, frameState) ); } /** * Called when pixel processing is complete. * @param {import("../Map.js").FrameState} frameState The frame state. * @param {Error} err Any error during processing. * @param {ImageData} output The output image data. * @param {Object|Array} data The user data (or an array if more than one thread). * @private */ onWorkerComplete_(frameState, err, output, data) { if (err || !output) { return; } const extent = frameState.extent; const resolution = frameState.viewState.resolution; if (resolution !== this.requestedFrameState_.viewState.resolution || !equals(extent, this.requestedFrameState_.extent)) { return; } let context; if (this.renderedImageCanvas_) { context = /** @type {CanvasRenderingContext2D|OffscreenCanvasRenderingContext2D} */ this.renderedImageCanvas_.getImage().getContext("2d"); } else { const width = Math.round(getWidth(extent) / resolution); const height = Math.round(getHeight(extent) / resolution); context = createCanvasContext2D(width, height); this.renderedImageCanvas_ = new ImageCanvas_default( extent, resolution, 1, context.canvas ); } context.putImageData(output, 0, 0); if (frameState.animate) { requestAnimationFrame(this.changed.bind(this)); } else { this.changed(); } this.renderedRevision_ = this.getRevision(); this.dispatchEvent( new RasterSourceEvent(RasterEventType.AFTEROPERATIONS, frameState, data) ); } /** * @param {import("../proj/Projection").default} [projection] Projection. * @return {Array|null} Resolutions. * @override */ getResolutions(projection) { if (!this.useResolutions_) { return null; } let resolutions = super.getResolutions(); if (!resolutions) { for (let i = 0, ii = this.layers_.length; i < ii; ++i) { const source = this.layers_[i].getSource(); resolutions = source.getResolutions(projection); if (resolutions) { break; } } } return resolutions; } /** * @override */ disposeInternal() { if (this.processor_) { this.processor_.dispose(); } super.disposeInternal(); } }; RasterSource.prototype.dispose; var sharedContext = null; function getImageData(layer, frameState) { const renderer = layer.getRenderer(); if (!renderer) { throw new Error("Unsupported layer type: " + layer); } if (!renderer.prepareFrame(frameState)) { return null; } const width = frameState.size[0]; const height = frameState.size[1]; if (width === 0 || height === 0) { return null; } const container = renderer.renderFrame(frameState, null); let element; if (container instanceof HTMLCanvasElement) { element = container; } else { if (container) { element = container.firstElementChild; } if (!(element instanceof HTMLCanvasElement)) { throw new Error("Unsupported rendered element: " + element); } if (element.width === width && element.height === height) { const context = element.getContext("2d"); return context.getImageData(0, 0, width, height); } } if (!sharedContext) { sharedContext = createCanvasContext2D(width, height, void 0, { willReadFrequently: true }); } else { const canvas = sharedContext.canvas; if (canvas.width !== width || canvas.height !== height) { sharedContext = createCanvasContext2D(width, height, void 0, { willReadFrequently: true }); } else { sharedContext.clearRect(0, 0, width, height); } } sharedContext.drawImage(element, 0, 0, width, height); return sharedContext.getImageData(0, 0, width, height); } function getLayerStatesArray(layers) { return layers.map(function(layer) { return layer.getLayerState(); }); } function createLayers(sources) { const len = sources.length; const layers = new Array(len); for (let i = 0; i < len; ++i) { layers[i] = createLayer(sources[i]); } return layers; } function createLayer(layerOrSource) { let layer; if (layerOrSource instanceof Source_default) { if (layerOrSource instanceof Tile_default3) { layer = new Tile_default2({ source: layerOrSource }); } else if (layerOrSource instanceof Image_default4) { layer = new Image_default2({ source: layerOrSource }); } } else { layer = layerOrSource; } return layer; } var Raster_default = RasterSource; // node_modules/ol/source/StadiaMaps.js var STADIA_ATTRIBUTION = '© Stadia Maps'; var OMT_ATTRIBUTION = '© OpenMapTiles'; var STAMEN_ATTRIBUTION = '© Stamen Design'; var LayerConfig = { "stamen_terrain": { extension: "png" }, "stamen_terrain_background": { extension: "png" }, "stamen_terrain_labels": { extension: "png" }, "stamen_terrain_lines": { extension: "png" }, "stamen_toner_background": { extension: "png" }, "stamen_toner": { extension: "png" }, "stamen_toner_labels": { extension: "png" }, "stamen_toner_lines": { extension: "png" }, "stamen_toner_lite": { extension: "png" }, "stamen_toner_dark": { extension: "png" }, "stamen_toner_blacklite": { extension: "png" }, "stamen_watercolor": { extension: "jpg" }, "alidade_smooth": { extension: "png" }, "alidade_smooth_dark": { extension: "png" }, "alidade_satellite": { extension: "png" }, "outdoors": { extension: "png" }, "osm_bright": { extension: "png" } }; var ProviderConfig = { "stamen_terrain": { minZoom: 0, maxZoom: 18, retina: true }, "stamen_toner": { minZoom: 0, maxZoom: 20, retina: true }, "stamen_toner_dark": { minZoom: 0, maxZoom: 20, retina: true }, "stamen_toner_blacklite": { minZoom: 0, maxZoom: 20, retina: true }, "stamen_watercolor": { minZoom: 1, maxZoom: 18, retina: false } }; var StadiaMaps = class extends XYZ_default { /** * @param {Options} options StadiaMaps options. */ constructor(options) { const i = options.layer.indexOf("-"); const provider = i == -1 ? options.layer : options.layer.slice(0, i); const providerConfig = ProviderConfig[provider] || { "minZoom": 0, "maxZoom": 20, "retina": true }; const layerConfig = LayerConfig[options.layer]; const query = options.apiKey ? "?api_key=" + options.apiKey : ""; const retina = providerConfig.retina && options.retina ? "@2x" : ""; const url = options.url !== void 0 ? options.url : "https://tiles.stadiamaps.com/tiles/" + options.layer + "/{z}/{x}/{y}" + retina + "." + layerConfig.extension + query; const attributions = [STADIA_ATTRIBUTION, OMT_ATTRIBUTION, ATTRIBUTION]; if (options.layer.startsWith("stamen_")) { attributions.splice(1, 0, STAMEN_ATTRIBUTION); } super({ attributions, cacheSize: options.cacheSize, crossOrigin: "anonymous", interpolate: options.interpolate, maxZoom: options.maxZoom !== void 0 ? options.maxZoom : providerConfig.maxZoom, minZoom: options.minZoom !== void 0 ? options.minZoom : providerConfig.minZoom, reprojectionErrorThreshold: options.reprojectionErrorThreshold, tileLoadFunction: options.tileLoadFunction, transition: options.transition, url, tilePixelRatio: retina ? 2 : 1, wrapX: options.wrapX, zDirection: options.zDirection }); } }; var StadiaMaps_default = StadiaMaps; // node_modules/ol/source/TileArcGISRest.js var TileArcGISRest = class extends TileImage_default { /** * @param {Options} [options] Tile ArcGIS Rest options. */ constructor(options) { options = options ? options : {}; super({ attributions: options.attributions, cacheSize: options.cacheSize, crossOrigin: options.crossOrigin, interpolate: options.interpolate, projection: options.projection, reprojectionErrorThreshold: options.reprojectionErrorThreshold, tileGrid: options.tileGrid, tileLoadFunction: options.tileLoadFunction, url: options.url, urls: options.urls, wrapX: options.wrapX !== void 0 ? options.wrapX : true, transition: options.transition, zDirection: options.zDirection }); this.params_ = Object.assign({}, options.params); this.hidpi_ = options.hidpi !== void 0 ? options.hidpi : true; this.tmpExtent_ = createEmpty(); this.setKey(this.getKeyForParams_()); } /** * @private * @return {string} The key for the current params. */ getKeyForParams_() { let i = 0; const res = []; for (const key in this.params_) { res[i++] = key + "-" + this.params_[key]; } return res.join("/"); } /** * Get the user-provided params, i.e. those passed to the constructor through * the "params" option, and possibly updated using the updateParams method. * @return {Object} Params. * @api */ getParams() { return this.params_; } /** * @param {import("../tilecoord.js").TileCoord} tileCoord Tile coordinate. * @param {import("../size.js").Size} tileSize Tile size. * @param {import("../extent.js").Extent} tileExtent Tile extent. * @param {number} pixelRatio Pixel ratio. * @param {import("../proj/Projection.js").default} projection Projection. * @param {Object} params Params. * @return {string|undefined} Request URL. * @private */ getRequestUrl_(tileCoord, tileSize, tileExtent, pixelRatio, projection, params) { const urls = this.urls; if (!urls) { return void 0; } let url; if (urls.length == 1) { url = urls[0]; } else { const index = modulo(hash(tileCoord), urls.length); url = urls[index]; } return getRequestUrl( url, tileExtent, (this.tileGrid || this.getTileGridForProjection(projection)).getResolution(tileCoord[0]), pixelRatio, projection, params ); } /** * Get the tile pixel ratio for this source. * @param {number} pixelRatio Pixel ratio. * @return {number} Tile pixel ratio. * @override */ getTilePixelRatio(pixelRatio) { return this.hidpi_ ? pixelRatio : 1; } /** * Set the user-provided params. * @param {Object} params Params. * @api */ setParams(params) { this.params_ = Object.assign({}, params); this.setKey(this.getKeyForParams_()); } /** * Update the user-provided params. * @param {Object} params Params. * @api */ updateParams(params) { Object.assign(this.params_, params); this.setKey(this.getKeyForParams_()); } /** * @param {import("../tilecoord.js").TileCoord} tileCoord The tile coordinate * @param {number} pixelRatio The pixel ratio * @param {import("../proj/Projection.js").default} projection The projection * @return {string|undefined} The tile URL * @override */ tileUrlFunction(tileCoord, pixelRatio, projection) { let tileGrid = this.getTileGrid(); if (!tileGrid) { tileGrid = this.getTileGridForProjection(projection); } if (tileGrid.getResolutions().length <= tileCoord[0]) { return void 0; } if (pixelRatio != 1 && !this.hidpi_) { pixelRatio = 1; } const tileExtent = tileGrid.getTileCoordExtent(tileCoord, this.tmpExtent_); let tileSize = toSize(tileGrid.getTileSize(tileCoord[0]), this.tmpSize); if (pixelRatio != 1) { tileSize = scale2(tileSize, pixelRatio, this.tmpSize); } const baseParams = { "F": "image", "FORMAT": "PNG32", "TRANSPARENT": true }; Object.assign(baseParams, this.params_); return this.getRequestUrl_( tileCoord, tileSize, tileExtent, pixelRatio, projection, baseParams ); } }; var TileArcGISRest_default = TileArcGISRest; // node_modules/ol/source/TileDebug.js var TileDebug = class extends ImageTile_default2 { /** * @param {Options} [options] Debug tile options. */ constructor(options) { options = options || {}; const template = options.template || "z:{z} x:{x} y:{y}"; const source = options.source; const color = options.color || "grey"; super({ transition: 0, wrapX: options.wrapX !== void 0 ? options.wrapX : source !== void 0 ? source.getWrapX() : void 0 }); const setReady = () => { var _a; this.projection = options.projection !== void 0 ? get(options.projection) : source !== void 0 ? source.getProjection() : this.projection; this.tileGrid = options.tileGrid !== void 0 ? options.tileGrid : source !== void 0 ? source.getTileGrid() : this.tileGrid; this.zDirection = options.zDirection !== void 0 ? options.zDirection : source !== void 0 ? source.zDirection : this.zDirection; if (source instanceof DataTile_default3) { this.transformMatrix = ((_a = source.transformMatrix) == null ? void 0 : _a.slice()) || null; } const tileGrid = this.tileGrid; if (tileGrid) { this.setTileSizes( tileGrid.getResolutions().map( (r, i) => toSize(tileGrid.getTileSize(i)).map( (s) => Math.max(Math.floor(s), 1) ) ) ); } this.setLoader((z, x, y, loaderOptions) => { const text = renderXYZTemplate(template, z, x, y, loaderOptions.maxY); const [width, height] = this.getTileSize(z); const context = createCanvasContext2D(width, height); context.strokeStyle = color; context.strokeRect(0.5, 0.5, width + 0.5, height + 0.5); context.fillStyle = color; context.strokeStyle = "white"; context.textAlign = "center"; context.textBaseline = "middle"; context.font = "24px sans-serif"; context.lineWidth = 4; context.strokeText(text, width / 2, height / 2, width); context.fillText(text, width / 2, height / 2, width); return Promise.resolve(context.canvas); }); this.setState("ready"); }; if (source === void 0 || source.getState() === "ready") { setReady(); } else { const handler2 = () => { if (source.getState() === "ready") { source.removeEventListener(EventType_default.CHANGE, handler2); setReady(); } }; source.addEventListener(EventType_default.CHANGE, handler2); } } }; var TileDebug_default = TileDebug; // node_modules/ol/source/TileJSON.js var TileJSON = class extends TileImage_default { /** * @param {Options} options TileJSON options. */ constructor(options) { super({ attributions: options.attributions, cacheSize: options.cacheSize, crossOrigin: options.crossOrigin, interpolate: options.interpolate, projection: get("EPSG:3857"), reprojectionErrorThreshold: options.reprojectionErrorThreshold, state: "loading", tileLoadFunction: options.tileLoadFunction, wrapX: options.wrapX !== void 0 ? options.wrapX : true, transition: options.transition, zDirection: options.zDirection }); this.tileJSON_ = null; this.tileSize_ = options.tileSize; if (options.url) { if (options.jsonp) { jsonp( options.url, this.handleTileJSONResponse.bind(this), this.handleTileJSONError.bind(this) ); } else { const client = new XMLHttpRequest(); client.addEventListener("load", this.onXHRLoad_.bind(this)); client.addEventListener("error", this.onXHRError_.bind(this)); client.open("GET", options.url); client.send(); } } else if (options.tileJSON) { this.handleTileJSONResponse(options.tileJSON); } else { throw new Error("Either `url` or `tileJSON` options must be provided"); } } /** * @private * @param {Event} event The load event. */ onXHRLoad_(event) { const client = ( /** @type {XMLHttpRequest} */ event.target ); if (!client.status || client.status >= 200 && client.status < 300) { let response; try { response = /** @type {Config} */ JSON.parse(client.responseText); } catch { this.handleTileJSONError(); return; } this.handleTileJSONResponse(response); } else { this.handleTileJSONError(); } } /** * @private * @param {Event} event The error event. */ onXHRError_(event) { this.handleTileJSONError(); } /** * @return {Config} The tilejson object. * @api */ getTileJSON() { return this.tileJSON_; } /** * @protected * @param {Config} tileJSON Tile JSON. */ handleTileJSONResponse(tileJSON) { const epsg4326Projection = get("EPSG:4326"); const sourceProjection = this.getProjection(); let extent; if (tileJSON["bounds"] !== void 0) { const transform2 = getTransformFromProjections( epsg4326Projection, sourceProjection ); extent = applyTransform(tileJSON["bounds"], transform2); } const gridExtent = extentFromProjection(sourceProjection); const minZoom = tileJSON["minzoom"] || 0; const maxZoom2 = tileJSON["maxzoom"] || 22; const tileGrid = createXYZ({ extent: gridExtent, maxZoom: maxZoom2, minZoom, tileSize: this.tileSize_ }); this.tileGrid = tileGrid; this.tileUrlFunction = createFromTemplates(tileJSON["tiles"], tileGrid); if (tileJSON["attribution"] && !this.getAttributions()) { const attributionExtent = extent !== void 0 ? extent : gridExtent; this.setAttributions(function(frameState) { if (intersects(attributionExtent, frameState.extent)) { return [tileJSON["attribution"]]; } return null; }); } this.tileJSON_ = tileJSON; this.setState("ready"); } /** * @protected */ handleTileJSONError() { this.setState("error"); } }; var TileJSON_default = TileJSON; // node_modules/ol/source/TileWMS.js var TileWMS = class extends TileImage_default { /** * @param {Options} [options] Tile WMS options. */ constructor(options) { options = options ? options : ( /** @type {Options} */ {} ); const params = Object.assign({}, options.params); super({ attributions: options.attributions, attributionsCollapsible: options.attributionsCollapsible, cacheSize: options.cacheSize, crossOrigin: options.crossOrigin, interpolate: options.interpolate, projection: options.projection, reprojectionErrorThreshold: options.reprojectionErrorThreshold, tileClass: options.tileClass, tileGrid: options.tileGrid, tileLoadFunction: options.tileLoadFunction, url: options.url, urls: options.urls, wrapX: options.wrapX !== void 0 ? options.wrapX : true, transition: options.transition, zDirection: options.zDirection }); this.gutter_ = options.gutter !== void 0 ? options.gutter : 0; this.params_ = params; this.v13_ = true; this.serverType_ = options.serverType; this.hidpi_ = options.hidpi !== void 0 ? options.hidpi : true; this.tmpExtent_ = createEmpty(); this.updateV13_(); this.setKey(this.getKeyForParams_()); } /** * Return the GetFeatureInfo URL for the passed coordinate, resolution, and * projection. Return `undefined` if the GetFeatureInfo URL cannot be * constructed. * @param {import("../coordinate.js").Coordinate} coordinate Coordinate. * @param {number} resolution Resolution. * @param {import("../proj.js").ProjectionLike} projection Projection. * @param {!Object} params GetFeatureInfo params. `INFO_FORMAT` at least should * be provided. If `QUERY_LAYERS` is not provided then the layers specified * in the `LAYERS` parameter will be used. `VERSION` should not be * specified here. * @return {string|undefined} GetFeatureInfo URL. * @api */ getFeatureInfoUrl(coordinate, resolution, projection, params) { const projectionObj = get(projection); const sourceProjectionObj = this.getProjection() || projectionObj; let tileGrid = this.getTileGrid(); if (!tileGrid) { tileGrid = this.getTileGridForProjection(sourceProjectionObj); } const sourceProjCoord = transform( coordinate, projectionObj, sourceProjectionObj ); const sourceResolution = calculateSourceResolution( sourceProjectionObj, projectionObj, coordinate, resolution ); const z = tileGrid.getZForResolution(sourceResolution, this.zDirection); const tileResolution = tileGrid.getResolution(z); const tileCoord = tileGrid.getTileCoordForCoordAndZ(sourceProjCoord, z); if (tileGrid.getResolutions().length <= tileCoord[0]) { return void 0; } let tileExtent = tileGrid.getTileCoordExtent(tileCoord, this.tmpExtent_); const gutter = this.gutter_; if (gutter !== 0) { tileExtent = buffer(tileExtent, tileResolution * gutter, tileExtent); } const baseParams = { "QUERY_LAYERS": this.params_["LAYERS"] }; Object.assign( baseParams, getRequestParams(this.params_, "GetFeatureInfo"), params ); const x = Math.floor((sourceProjCoord[0] - tileExtent[0]) / tileResolution); const y = Math.floor((tileExtent[3] - sourceProjCoord[1]) / tileResolution); baseParams[this.v13_ ? "I" : "X"] = x; baseParams[this.v13_ ? "J" : "Y"] = y; return this.getRequestUrl_( tileCoord, tileExtent, 1, sourceProjectionObj || projectionObj, baseParams ); } /** * Return the GetLegendGraphic URL, optionally optimized for the passed * resolution and possibly including any passed specific parameters. Returns * `undefined` if the GetLegendGraphic URL cannot be constructed. * * @param {number} [resolution] Resolution. If set to undefined, `SCALE` * will not be calculated and included in URL. * @param {Object} [params] GetLegendGraphic params. If `LAYER` is set, the * request is generated for this wms layer, else it will try to use the * configured wms layer. Default `FORMAT` is `image/png`. * `VERSION` should not be specified here. * @return {string|undefined} GetLegendGraphic URL. * @api */ getLegendUrl(resolution, params) { if (this.urls[0] === void 0) { return void 0; } const baseParams = { "SERVICE": "WMS", "VERSION": DEFAULT_VERSION, "REQUEST": "GetLegendGraphic", "FORMAT": "image/png" }; if (params === void 0 || params["LAYER"] === void 0) { const layers = this.params_.LAYERS; const isSingleLayer = !Array.isArray(layers) || layers.length === 1; if (!isSingleLayer) { return void 0; } baseParams["LAYER"] = layers; } if (resolution !== void 0) { const mpu = this.getProjection() ? this.getProjection().getMetersPerUnit() : 1; const pixelSize = 28e-5; baseParams["SCALE"] = resolution * mpu / pixelSize; } Object.assign(baseParams, params); return appendParams( /** @type {string} */ this.urls[0], baseParams ); } /** * @return {number} Gutter. * @override */ getGutter() { return this.gutter_; } /** * Get the user-provided params, i.e. those passed to the constructor through * the "params" option, and possibly updated using the updateParams method. * @return {Object} Params. * @api */ getParams() { return this.params_; } /** * @param {import("../tilecoord.js").TileCoord} tileCoord Tile coordinate. * @param {import("../extent.js").Extent} tileExtent Tile extent. * @param {number} pixelRatio Pixel ratio. * @param {import("../proj/Projection.js").default} projection Projection. * @param {Object} params Params. * @return {string|undefined} Request URL. * @private */ getRequestUrl_(tileCoord, tileExtent, pixelRatio, projection, params) { const urls = this.urls; if (!urls) { return void 0; } let url; if (urls.length == 1) { url = urls[0]; } else { const index = modulo(hash(tileCoord), urls.length); url = urls[index]; } return getImageSrc( tileExtent, (this.tileGrid || this.getTileGridForProjection(projection)).getResolution(tileCoord[0]), pixelRatio, projection, url, params, this.serverType_ ); } /** * Get the tile pixel ratio for this source. * @param {number} pixelRatio Pixel ratio. * @return {number} Tile pixel ratio. * @override */ getTilePixelRatio(pixelRatio) { return !this.hidpi_ || this.serverType_ === void 0 ? 1 : pixelRatio; } /** * @private * @return {string} The key for the current params. */ getKeyForParams_() { let i = 0; const res = []; for (const key in this.params_) { res[i++] = key + "-" + this.params_[key]; } return res.join("/"); } /** * @param {Object} params New URL paremeters. * @private */ setParams_(params) { this.params_ = params; this.updateV13_(); this.setKey(this.getKeyForParams_()); } /** * Set the URL parameters passed to the WMS source. * @param {Object} params New URL paremeters. * @api */ setParams(params) { this.setParams_(Object.assign({}, params)); } /** * Update the URL parameters. This method can be used to update a subset of the WMS * parameters. Call `setParams` to set all of the parameters. * @param {Object} params Updated URL parameters. * @api */ updateParams(params) { this.setParams_(Object.assign(this.params_, params)); } /** * @private */ updateV13_() { const version = this.params_["VERSION"] || DEFAULT_VERSION; this.v13_ = compareVersions(version, "1.3") >= 0; } /** * @param {import("../tilecoord.js").TileCoord} tileCoord The tile coordinate * @param {number} pixelRatio The pixel ratio * @param {import("../proj/Projection.js").default} projection The projection * @return {string|undefined} The tile URL * @override */ tileUrlFunction(tileCoord, pixelRatio, projection) { let tileGrid = this.getTileGrid(); if (!tileGrid) { tileGrid = this.getTileGridForProjection(projection); } if (tileGrid.getResolutions().length <= tileCoord[0]) { return void 0; } if (pixelRatio != 1 && (!this.hidpi_ || this.serverType_ === void 0)) { pixelRatio = 1; } const tileResolution = tileGrid.getResolution(tileCoord[0]); let tileExtent = tileGrid.getTileCoordExtent(tileCoord, this.tmpExtent_); const gutter = this.gutter_; if (gutter !== 0) { tileExtent = buffer(tileExtent, tileResolution * gutter, tileExtent); } const baseParams = Object.assign( {}, getRequestParams(this.params_, "GetMap") ); return this.getRequestUrl_( tileCoord, tileExtent, pixelRatio, projection, baseParams ); } }; var TileWMS_default = TileWMS; // node_modules/ol/source/UTFGrid.js var CustomTile2 = class extends Tile_default { /** * @param {import("../tilecoord.js").TileCoord} tileCoord Tile coordinate. * @param {import("../TileState.js").default} state State. * @param {string} src Image source URI. * @param {import("../extent.js").Extent} extent Extent of the tile. * @param {boolean} preemptive Load the tile when visible (before it's needed). * @param {boolean} jsonp Load the tile as a script. */ constructor(tileCoord, state, src, extent, preemptive, jsonp2) { super(tileCoord, state); this.src_ = src; this.extent_ = extent; this.preemptive_ = preemptive; this.grid_ = null; this.keys_ = null; this.data_ = null; this.jsonp_ = jsonp2; } /** * Get the image element for this tile. * @return {HTMLImageElement} Image. */ getImage() { return null; } /** * Synchronously returns data at given coordinate (if available). * @param {import("../coordinate.js").Coordinate} coordinate Coordinate. * @return {*} The data. */ getData(coordinate) { if (!this.grid_ || !this.keys_) { return null; } const xRelative = (coordinate[0] - this.extent_[0]) / (this.extent_[2] - this.extent_[0]); const yRelative = (coordinate[1] - this.extent_[1]) / (this.extent_[3] - this.extent_[1]); const row = this.grid_[Math.floor((1 - yRelative) * this.grid_.length)]; if (typeof row !== "string") { return null; } let code = row.charCodeAt(Math.floor(xRelative * row.length)); if (code >= 93) { code--; } if (code >= 35) { code--; } code -= 32; let data = null; if (code in this.keys_) { const id = this.keys_[code]; if (this.data_ && id in this.data_) { data = this.data_[id]; } else { data = id; } } return data; } /** * Calls the callback (synchronously by default) with the available data * for given coordinate (or `null` if not yet loaded). * @param {import("../coordinate.js").Coordinate} coordinate Coordinate. * @param {function(*): void} callback Callback. * @param {boolean} [request] If `true` the callback is always async. * The tile data is requested if not yet loaded. */ forDataAtCoordinate(coordinate, callback, request) { if (this.state == TileState_default.EMPTY && request === true) { this.state = TileState_default.IDLE; listenOnce(this, EventType_default.CHANGE, (e) => { callback(this.getData(coordinate)); }); this.loadInternal_(); } else { if (request === true) { setTimeout(() => { callback(this.getData(coordinate)); }, 0); } else { callback(this.getData(coordinate)); } } } /** * Return the key to be used for all tiles in the source. * @return {string} The key for all tiles. * @override */ getKey() { return this.src_; } /** * @private */ handleError_() { this.state = TileState_default.ERROR; this.changed(); } /** * @param {!UTFGridJSON} json UTFGrid data. * @private */ handleLoad_(json) { this.grid_ = json["grid"]; this.keys_ = json["keys"]; this.data_ = json["data"]; this.state = TileState_default.LOADED; this.changed(); } /** * @private */ loadInternal_() { if (this.state == TileState_default.IDLE) { this.state = TileState_default.LOADING; if (this.jsonp_) { jsonp( this.src_, this.handleLoad_.bind(this), this.handleError_.bind(this) ); } else { const client = new XMLHttpRequest(); client.addEventListener("load", this.onXHRLoad_.bind(this)); client.addEventListener("error", this.onXHRError_.bind(this)); client.open("GET", this.src_); client.send(); } } } /** * @private * @param {Event} event The load event. */ onXHRLoad_(event) { const client = ( /** @type {XMLHttpRequest} */ event.target ); if (!client.status || client.status >= 200 && client.status < 300) { let response; try { response = /** @type {!UTFGridJSON} */ JSON.parse(client.responseText); } catch { this.handleError_(); return; } this.handleLoad_(response); } else { this.handleError_(); } } /** * @private * @param {Event} event The error event. */ onXHRError_(event) { this.handleError_(); } /** * @override */ load() { if (this.preemptive_) { this.loadInternal_(); } else { this.setState(TileState_default.EMPTY); } } }; var UTFGrid = class extends Tile_default3 { /** * @param {Options} options Source options. */ constructor(options) { super({ projection: get("EPSG:3857"), state: "loading", wrapX: options.wrapX !== void 0 ? options.wrapX : true, zDirection: options.zDirection }); this.preemptive_ = options.preemptive !== void 0 ? options.preemptive : true; this.tileUrlFunction_ = nullTileUrlFunction; this.template_ = void 0; this.jsonp_ = options.jsonp || false; this.tileCache_ = new LRUCache_default(512); if (options.url) { if (this.jsonp_) { jsonp( options.url, this.handleTileJSONResponse.bind(this), this.handleTileJSONError.bind(this) ); } else { const client = new XMLHttpRequest(); client.addEventListener("load", this.onXHRLoad_.bind(this)); client.addEventListener("error", this.onXHRError_.bind(this)); client.open("GET", options.url); client.send(); } } else if (options.tileJSON) { this.handleTileJSONResponse(options.tileJSON); } else { throw new Error("Either `url` or `tileJSON` options must be provided"); } } /** * @private * @param {Event} event The load event. */ onXHRLoad_(event) { const client = ( /** @type {XMLHttpRequest} */ event.target ); if (!client.status || client.status >= 200 && client.status < 300) { let response; try { response = /** @type {import("./TileJSON.js").Config} */ JSON.parse(client.responseText); } catch { this.handleTileJSONError(); return; } this.handleTileJSONResponse(response); } else { this.handleTileJSONError(); } } /** * @private * @param {Event} event The error event. */ onXHRError_(event) { this.handleTileJSONError(); } /** * Return the template from TileJSON. * @return {string|undefined} The template from TileJSON. * @api */ getTemplate() { return this.template_; } /** * Calls the callback (synchronously by default) with the available data * for given coordinate and resolution (or `null` if not yet loaded or * in case of an error). * @param {import("../coordinate.js").Coordinate} coordinate Coordinate. * @param {number} resolution Resolution. * @param {function(*): void} callback Callback. * @param {boolean} [request] If `true` the callback is always async. * The tile data is requested if not yet loaded. * @api */ forDataAtCoordinateAndResolution(coordinate, resolution, callback, request) { if (this.tileGrid) { const z = this.tileGrid.getZForResolution(resolution, this.zDirection); const tileCoord = this.tileGrid.getTileCoordForCoordAndZ(coordinate, z); const tile = ( /** @type {!CustomTile} */ this.getTile( tileCoord[0], tileCoord[1], tileCoord[2], 1, this.getProjection() ) ); if (tile.getState() == TileState_default.IDLE) { tile.load(); } tile.forDataAtCoordinate(coordinate, callback, request); } else { if (request === true) { setTimeout(function() { callback(null); }, 0); } else { callback(null); } } } /** * @protected */ handleTileJSONError() { this.setState("error"); } /** * TODO: very similar to ol/source/TileJSON#handleTileJSONResponse * @protected * @param {import("./TileJSON.js").Config} tileJSON Tile JSON. */ handleTileJSONResponse(tileJSON) { const epsg4326Projection = get("EPSG:4326"); const sourceProjection = this.getProjection(); let extent; if (tileJSON["bounds"] !== void 0) { const transform2 = getTransformFromProjections( epsg4326Projection, sourceProjection ); extent = applyTransform(tileJSON["bounds"], transform2); } const gridExtent = extentFromProjection(sourceProjection); const minZoom = tileJSON["minzoom"] || 0; const maxZoom2 = tileJSON["maxzoom"] || 22; const tileGrid = createXYZ({ extent: gridExtent, maxZoom: maxZoom2, minZoom }); this.tileGrid = tileGrid; this.template_ = tileJSON["template"]; const grids = tileJSON["grids"]; if (!grids) { this.setState("error"); return; } this.tileUrlFunction_ = createFromTemplates(grids, tileGrid); if (tileJSON["attribution"]) { const attributionExtent = extent !== void 0 ? extent : gridExtent; this.setAttributions(function(frameState) { if (intersects(attributionExtent, frameState.extent)) { return [tileJSON["attribution"]]; } return null; }); } this.setState("ready"); } /** * @param {number} z Tile coordinate z. * @param {number} x Tile coordinate x. * @param {number} y Tile coordinate y. * @param {number} pixelRatio Pixel ratio. * @param {import("../proj/Projection.js").default} projection Projection. * @return {!CustomTile} Tile. * @override */ getTile(z, x, y, pixelRatio, projection) { const tileCoord = [z, x, y]; const urlTileCoord = this.getTileCoordForTileUrlFunction( tileCoord, projection ); const tileUrl = this.tileUrlFunction_(urlTileCoord, pixelRatio, projection); const tileKey = `${this.getKey()},${getKeyZXY(z, x, y)}`; if (this.tileCache_.containsKey(tileKey)) { return this.tileCache_.get(tileKey); } this.tileCache_.expireCache(); const tile = new CustomTile2( tileCoord, tileUrl !== void 0 ? TileState_default.IDLE : TileState_default.EMPTY, tileUrl !== void 0 ? tileUrl : "", this.tileGrid.getTileCoordExtent(tileCoord), this.preemptive_, this.jsonp_ ); this.tileCache_.set(tileKey, tile); return tile; } }; var UTFGrid_default = UTFGrid; // node_modules/ol/source/WMTS.js var WMTS = class extends TileImage_default { /** * @param {Options} options WMTS options. */ constructor(options) { const requestEncoding = options.requestEncoding !== void 0 ? options.requestEncoding : "KVP"; const tileGrid = options.tileGrid; let urls = options.urls; if (urls === void 0 && options.url !== void 0) { urls = expandUrl(options.url); } super({ attributions: options.attributions, attributionsCollapsible: options.attributionsCollapsible, cacheSize: options.cacheSize, crossOrigin: options.crossOrigin, interpolate: options.interpolate, projection: options.projection, reprojectionErrorThreshold: options.reprojectionErrorThreshold, tileClass: options.tileClass, tileGrid, tileLoadFunction: options.tileLoadFunction, tilePixelRatio: options.tilePixelRatio, urls, wrapX: options.wrapX !== void 0 ? options.wrapX : false, transition: options.transition, zDirection: options.zDirection }); this.version_ = options.version !== void 0 ? options.version : "1.0.0"; this.format_ = options.format !== void 0 ? options.format : "image/jpeg"; this.dimensions_ = options.dimensions !== void 0 ? options.dimensions : {}; this.layer_ = options.layer; this.matrixSet_ = options.matrixSet; this.style_ = options.style; this.requestEncoding_ = requestEncoding; this.setKey(this.getKeyForDimensions_()); if (urls && urls.length > 0) { this.tileUrlFunction = createFromTileUrlFunctions( urls.map(this.createFromWMTSTemplate.bind(this)) ); } } /** * Set the URLs to use for requests. * URLs may contain OGC conform URL Template Variables: {TileMatrix}, {TileRow}, {TileCol}. * @param {Array} urls URLs. * @override */ setUrls(urls) { this.urls = urls; const key = urls.join("\n"); this.setTileUrlFunction( createFromTileUrlFunctions( urls.map(this.createFromWMTSTemplate.bind(this)) ), key ); } /** * Get the dimensions, i.e. those passed to the constructor through the * "dimensions" option, and possibly updated using the updateDimensions * method. * @return {!Object} Dimensions. * @api */ getDimensions() { return this.dimensions_; } /** * Return the image format of the WMTS source. * @return {string} Format. * @api */ getFormat() { return this.format_; } /** * Return the layer of the WMTS source. * @return {string} Layer. * @api */ getLayer() { return this.layer_; } /** * Return the matrix set of the WMTS source. * @return {string} MatrixSet. * @api */ getMatrixSet() { return this.matrixSet_; } /** * Return the request encoding, either "KVP" or "REST". * @return {RequestEncoding} Request encoding. * @api */ getRequestEncoding() { return this.requestEncoding_; } /** * Return the style of the WMTS source. * @return {string} Style. * @api */ getStyle() { return this.style_; } /** * Return the version of the WMTS source. * @return {string} Version. * @api */ getVersion() { return this.version_; } /** * @private * @return {string} The key for the current dimensions. */ getKeyForDimensions_() { const res = this.urls ? this.urls.slice(0) : []; for (const key in this.dimensions_) { res.push(key + "-" + this.dimensions_[key]); } return res.join("/"); } /** * Update the dimensions. * @param {Object} dimensions Dimensions. * @api */ updateDimensions(dimensions) { Object.assign(this.dimensions_, dimensions); this.setKey(this.getKeyForDimensions_()); } /** * @param {string} template Template. * @return {import("../Tile.js").UrlFunction} Tile URL function. */ createFromWMTSTemplate(template) { const requestEncoding = this.requestEncoding_; const context = { "layer": this.layer_, "style": this.style_, "tilematrixset": this.matrixSet_ }; if (requestEncoding == "KVP") { Object.assign(context, { "Service": "WMTS", "Request": "GetTile", "Version": this.version_, "Format": this.format_ }); } template = requestEncoding == "KVP" ? appendParams(template, context) : template.replace(/\{(\w+?)\}/g, function(m, p) { return p.toLowerCase() in context ? context[p.toLowerCase()] : m; }); const tileGrid = ( /** @type {import("../tilegrid/WMTS.js").default} */ this.tileGrid ); const dimensions = this.dimensions_; return ( /** * @param {import("../tilecoord.js").TileCoord} tileCoord Tile coordinate. * @param {number} pixelRatio Pixel ratio. * @param {import("../proj/Projection.js").default} projection Projection. * @return {string|undefined} Tile URL. */ (function(tileCoord, pixelRatio, projection) { if (!tileCoord) { return void 0; } const localContext = { "TileMatrix": tileGrid.getMatrixId(tileCoord[0]), "TileCol": tileCoord[1], "TileRow": tileCoord[2] }; Object.assign(localContext, dimensions); let url = template; if (requestEncoding == "KVP") { url = appendParams(url, localContext); } else { url = url.replace(/\{(\w+?)\}/g, function(m, p) { return encodeURIComponent(localContext[p]); }); } return url; }) ); } }; var WMTS_default = WMTS; // node_modules/ol/source.js function sourcesFromTileGrid(tileGrid, factory) { const sourceCache = new LRUCache_default(32); const tileGridExtent = tileGrid.getExtent(); return function(extent, resolution) { sourceCache.expireCache(); if (tileGridExtent) { extent = getIntersection(tileGridExtent, extent); } const z = tileGrid.getZForResolution(resolution); const wantedSources = []; tileGrid.forEachTileCoord(extent, z, (tileCoord) => { const key = tileCoord.toString(); if (!sourceCache.containsKey(key)) { const source = factory(tileCoord); sourceCache.set(key, source); } wantedSources.push(sourceCache.get(key)); }); return wantedSources; }; } export { BingMaps_default as BingMaps, CartoDB_default as CartoDB, Cluster_default as Cluster, DataTile_default3 as DataTile, GeoTIFF_default as GeoTIFF, Google_default as Google, IIIF_default as IIIF, Image_default4 as Image, ImageArcGISRest_default as ImageArcGISRest, ImageCanvas_default2 as ImageCanvas, ImageMapGuide_default as ImageMapGuide, ImageStatic_default as ImageStatic, ImageTile_default2 as ImageTile, ImageWMS_default as ImageWMS, OGCMapTile_default as OGCMapTile, OGCVectorTile_default as OGCVectorTile, OSM_default as OSM, Raster_default as Raster, Source_default as Source, StadiaMaps_default as StadiaMaps, Tile_default3 as Tile, TileArcGISRest_default as TileArcGISRest, TileDebug_default as TileDebug, TileImage_default as TileImage, TileJSON_default as TileJSON, TileWMS_default as TileWMS, UTFGrid_default as UTFGrid, UrlTile_default as UrlTile, Vector_default as Vector, VectorTile_default2 as VectorTile, WMTS_default as WMTS, XYZ_default as XYZ, Zoomify_default as Zoomify, createLoader as createArcGISRestLoader, createLoader2 as createMapGuideLoader, createLoader3 as createStaticLoader, createLoader4 as createWMSLoader, sourcesFromTileGrid }; //# sourceMappingURL=ol_source.js.map