astro-viewer 3.6.0 → 3.8.0

package/dist/astroviewer.cjs

@@ -3627,6 +3627,7 @@ class AstroSphere {
     pointerDownY = null;
     pointerDownAt = 0;
     _activeHiPS = null;
+    _activeHiPSLayers = [];
     _activeXYZ2 = null;
     _activeMeshHiPS = null;
     _activeBaseLayer = null;
@@ -3980,9 +3981,15 @@ class AstroSphere {
                 document.body.style.cursor = "grab";
                 const dragDirection = Global_js_1.default.insideSphere ? -1 : 1;
                 const dragSpeed = Global_js_1.default.insideSphere ? 10.0 : 1;
-                const deltaX = (dragDirection * dragSpeed * (newX - (this.lastMouseX ?? newX)) * Math.PI) /
+                const deltaX = (dragDirection *
+                    dragSpeed *
+                    (newX - (this.lastMouseX ?? newX)) *
+                    Math.PI) /
                     canvas.width;
-                const deltaY = (dragDirection * dragSpeed * (newY - (this.lastMouseY ?? newY)) * Math.PI) /
+                const deltaY = (dragDirection *
+                    dragSpeed *
+                    (newY - (this.lastMouseY ?? newY)) *
+                    Math.PI) /
                     canvas.height;
                 const filteredDelta = this.filterRotationDeltaByAstroLocks(deltaX, deltaY);
                 this.inertiaX += 0.1 * filteredDelta.deltaX;
@@ -4117,26 +4124,75 @@ class AstroSphere {
         const pickerPoint = RayPickingUtils_js_1.default.getIntersectionPointWithSingleModel(maxX / 2, maxY / 2, this._healpixGrid, this._webgl, this._camera, this._perspectiveMatrixManager.pMatrix);
         return (0, Utils_js_1.cartesianToSpherical)(pickerPoint);
     }
-    collectViewportSphericalSamples(sampleCount = 5) {
-        const rect = this.canvas.getBoundingClientRect();
-        const width = rect.width;
-        const height = rect.height;
-        const samples = [];
-        for (let ix = 0; ix < sampleCount; ix++) {
-            const x = sampleCount === 1 ? width / 2 : (ix / (sampleCount - 1)) * width;
-            for (let iy = 0; iy < sampleCount; iy++) {
-                const y = sampleCount === 1 ? height / 2 : (iy / (sampleCount - 1)) * height;
-                const hit = RayPickingUtils_js_1.default.getIntersectionPointWithSingleModel(x, y, this._healpixGrid, this._webgl, this._camera, this._perspectiveMatrixManager.pMatrix);
-                if (hit && hit.length > 0) {
-                    samples.push((0, Utils_js_1.cartesianToSpherical)(hit));
-                }
-            }
+    changeHiPSFormat(format) {
+        if (!this._activeHiPS) {
+            throw new Error("No active HiPS.");
         }
-        return samples;
+        this._activeHiPS.changeFormat(format);
+    }
+    createHiPS(hipsDescriptor) {
+        return new HiPS_js_1.HiPS(1, [0.0, 0.0, 0.0], 0, 0, hipsDescriptor, this._webgl, this._healpixGrid);
     }
     activateHiPS(hipsDescriptor) {
-        this._activeHiPS = new HiPS_js_1.HiPS(1, [0.0, 0.0, 0.0], 0, 0, hipsDescriptor, this._webgl, this._healpixGrid);
+        const tileBuffer = this._healpixGrid.visibleTilesManager.tileBuffer;
+        for (const hips of this._activeHiPSLayers) {
+            tileBuffer.removeHiPS(hips);
+        }
+        this._activeHiPSLayers = [];
+        const hips = this.createHiPS(hipsDescriptor);
+        this._activeHiPSLayers.push(hips);
+        this._activeHiPS = hips;
+        this._activeBaseLayer = "hips";
+        return hips;
+    }
+    setHiPSOpacity(hips, opacity) {
+        if (!this._activeHiPSLayers.includes(hips)) {
+            throw new Error("HiPS layer is not active in this AstroSphere.");
+        }
+        hips.setOpacity(opacity);
+    }
+    addHiPS(hipsDescriptor) {
+        const normalizeURL = (url) => String(url).replace(/\/+$/, "");
+        const descriptorURL = normalizeURL(hipsDescriptor.url);
+        const existing = this._activeHiPSLayers.find((hips) => normalizeURL(hips.baseURL) === descriptorURL);
+        if (existing) {
+            throw new Error(`HiPS already active: ${String(hipsDescriptor.url)}`);
+        }
+        const hips = this.createHiPS(hipsDescriptor);
+        this._activeHiPSLayers.push(hips);
+        this._activeHiPS = hips;
         this._activeBaseLayer = "hips";
+        return hips;
+    }
+    removeHiPS(hips) {
+        const index = this._activeHiPSLayers.indexOf(hips);
+        if (index === -1) {
+            return;
+        }
+        this._healpixGrid.visibleTilesManager.tileBuffer.removeHiPS(hips);
+        this._activeHiPSLayers.splice(index, 1);
+        if (this._activeHiPSLayers.length === 0) {
+            this._activeHiPS = null;
+            if (this._activeBaseLayer === "hips") {
+                this._activeBaseLayer = null;
+            }
+            return;
+        }
+        if (this._activeHiPS === hips) {
+            this._activeHiPS =
+                this._activeHiPSLayers[this._activeHiPSLayers.length - 1];
+        }
+    }
+    removeAllHiPS() {
+        const tileBuffer = this._healpixGrid.visibleTilesManager.tileBuffer;
+        for (const hips of this._activeHiPSLayers) {
+            tileBuffer.removeHiPS(hips);
+        }
+        this._activeHiPSLayers = [];
+        this._activeHiPS = null;
+        if (this._activeBaseLayer === "hips") {
+            this._activeBaseLayer = null;
+        }
     }
     activateXYZ(config) {
         this.activateXYZ2(new XYZMapDescriptor_js_1.XYZMapDescriptor(config.name ?? "XYZ Earth2 Layer", config.urlTemplate, config.minZoom ?? 0, config.maxZoom ?? 8, config.segmentsPerSide ?? 48, config.maxCachedTiles ?? 384, 8, config.urlResolver));
@@ -4369,6 +4425,16 @@ class AstroSphere {
     get activeHiPS() {
         return this._activeHiPS;
     }
+    get activeHiPSLayers() {
+        return this._activeHiPSLayers;
+    }
+    setActiveHiPS(hips) {
+        if (!this._activeHiPSLayers.includes(hips)) {
+            throw new Error("HiPS layer is not active in this AstroSphere.");
+        }
+        this._activeHiPS = hips;
+        this._activeBaseLayer = "hips";
+    }
     get activeXYZ() {
         return this._activeXYZ2;
     }
@@ -4528,8 +4594,9 @@ class AstroSphere {
         this._webgl.enable(this._webgl.CULL_FACE);
         this._webgl.cullFace(Global_js_1.default.insideSphere ? this._webgl.FRONT : this._webgl.BACK);
         this._webgl.blendFunc(this._webgl.SRC_ALPHA, this._webgl.ONE_MINUS_SRC_ALPHA);
-        if (this._activeBaseLayer === "hips" && this._activeHiPS) {
-            const visibleOrder = Math.min(this._healpixGrid.visibleorder, this._activeHiPS.maxOrder);
+        if (this._activeBaseLayer === "hips" && this._activeHiPSLayers.length > 0) {
+            const maxHiPSOrder = Math.max(...this._activeHiPSLayers.map((hips) => hips.maxOrder));
+            const visibleOrder = Math.min(this._healpixGrid.visibleorder, maxHiPSOrder);
             this._healpixGrid.visibleTilesManager.computeVisiblePixels(visibleOrder, this._webgl, this._camera, this._perspectiveMatrixManager.pMatrix);
         }
         if (this._activeBaseLayer === "meships" && this._activeMeshHiPS) {
@@ -4544,14 +4611,6 @@ class AstroSphere {
             Math.abs(this.inertiaX) > 0.02 ||
             Math.abs(this.inertiaY) > 0.02 ||
             nowForGrid - this.lastCameraMotionAt < 220;
-        // const skyEntityDrawInput: SkyEntityDrawInput = {
-        // fovDeg: this._healpixGrid.getMinFoV(),
-        //   camera: this._camera,
-        //   pMatrix: this._perspectiveMatrixManager.pMatrix,
-        //   centerSphericalDeg: this.updateCentralPoint().sphericalDeg,
-        //   fovPolygon: this._activeBaseLayer === 'xyz' ? this.getFoVPolygon() : undefined,
-        //   viewportSphericalSamples: this._activeBaseLayer === 'xyz' ? this.collectViewportSphericalSamples(7) : undefined,
-        // }
         const skyEntityDrawInput = {
             fovDeg: stableFovDeg,
             camera: this._camera,
@@ -4562,6 +4621,11 @@ class AstroSphere {
             cameraMoving: cameraMovingForGrid,
         };
         if (this._activeBaseLayer === "hips") {
+            for (const hips of this._activeHiPSLayers) {
+                if (hips !== this._activeHiPS) {
+                    hips.draw(skyEntityDrawInput);
+                }
+            }
             this._activeHiPS?.draw(skyEntityDrawInput);
         }
         if (this._activeBaseLayer === "xyz") {
@@ -4703,7 +4767,7 @@ class AstroViewer {
     webglContextList = new Map();
     viewfinderEl = null;
     viewfinderVisible = Config_js_1.bootSetup.showViewfinder;
-    viewfinderColor = 'rgba(75,148,226,0.68)';
+    viewfinderColor = "rgba(75,148,226,0.68)";
     options = {};
     // API
     run() {
@@ -4841,7 +4905,7 @@ class AstroViewer {
         this.astroSphere.activateXYZ(config);
     }
     activateXYZ2(config) {
-        const descriptor = new XYZMapDescriptor_js_1.XYZMapDescriptor(config.name ?? 'XYZ Earth2 Layer', config.urlTemplate, config.minZoom ?? 0, config.maxZoom ?? 8, config.segmentsPerSide ?? 48, config.maxCachedTiles ?? 384, 8, config.urlResolver);
+        const descriptor = new XYZMapDescriptor_js_1.XYZMapDescriptor(config.name ?? "XYZ Earth2 Layer", config.urlTemplate, config.minZoom ?? 0, config.maxZoom ?? 8, config.segmentsPerSide ?? 48, config.maxCachedTiles ?? 384, 8, config.urlResolver);
         this.astroSphere.activateXYZ2(descriptor);
     }
     activateWMTS(config) {
@@ -4866,8 +4930,8 @@ class AstroViewer {
         return this.astroSphere.getMeshHiPSDebugStats();
     }
     async loadHiPS(baseUrl) {
-        const hipsUrl = baseUrl.endsWith('/') ? baseUrl : baseUrl + '/';
-        const resp = await fetch(hipsUrl + 'properties');
+        const hipsUrl = baseUrl.endsWith("/") ? baseUrl : baseUrl + "/";
+        const resp = await fetch(hipsUrl + "properties");
         if (!resp.ok)
             throw new Error(`HTTP ${resp.status} fetching properties`);
         const propsText = await resp.text();
@@ -4877,37 +4941,69 @@ class AstroViewer {
         // this.activateHiPS(desc);
     }
     async loadMeshHiPS(baseUrl, config = {}) {
-        const meshHiPSUrl = baseUrl.endsWith('/') ? baseUrl : baseUrl + '/';
-        let propsText = '';
-        const resp = await fetch(meshHiPSUrl + 'properties');
+        const meshHiPSUrl = baseUrl.endsWith("/") ? baseUrl : baseUrl + "/";
+        let propsText = "";
+        const resp = await fetch(meshHiPSUrl + "properties");
         if (resp.ok) {
             propsText = await resp.text();
         }
         else {
-            const jsonResp = await fetch(meshHiPSUrl + 'properties.json');
+            const jsonResp = await fetch(meshHiPSUrl + "properties.json");
             if (!jsonResp.ok)
                 throw new Error(`HTTP ${jsonResp.status} fetching MeshHiPS properties`);
             const json = await jsonResp.json();
             propsText = Object.entries(json)
                 .map(([key, value]) => `${key}=${String(value)}`)
-                .join('\n');
+                .join("\n");
         }
         const desc = new MeshHiPSDescriptor_js_1.MeshHiPSDescriptor({ ...config, baseUrl: meshHiPSUrl }, propsText);
         this.astroSphere.activateMeshHiPS(desc);
         return desc.name;
     }
-    // changeColorMap(hips: HiPS, colorMapName: ColorMapName) {
+    setActiveHiPS(hips) {
+        this.astroSphere.setActiveHiPS(hips);
+    }
+    setHiPSOpacity(hips, opacity) {
+        this.astroSphere.setHiPSOpacity(hips, opacity);
+    }
     changeColorMap(colorMapName) {
         const colorMap = ColorMaps_js_1.default[colorMapName];
-        // hips.changeColorMap(colorMap)
         this.astroSphere.changeColorMap(colorMap);
     }
     changeCustomColorMap(colorMap) {
         this.astroSphere.changeColorMap(colorMap);
     }
+    addHiPS(hipsDescriptor) {
+        return this.astroSphere.addHiPS(hipsDescriptor);
+    }
+    async addHiPSFromUrl(baseUrl) {
+        const hipsUrl = baseUrl.endsWith("/") ? baseUrl : baseUrl + "/";
+        const resp = await fetch(hipsUrl + "properties");
+        if (!resp.ok) {
+            throw new Error(`HTTP ${resp.status} fetching properties`);
+        }
+        const propsText = await resp.text();
+        const desc = new HiPSDescriptor_js_1.HiPSDescriptor(propsText, hipsUrl);
+        return this.astroSphere.addHiPS(desc);
+    }
+    removeHiPS(hips) {
+        this.astroSphere.removeHiPS(hips);
+    }
+    removeAllHiPS() {
+        this.astroSphere.removeAllHiPS();
+    }
+    getActiveHiPSLayers() {
+        return this.astroSphere.activeHiPSLayers;
+    }
     getActiveHiPS() {
         return this.astroSphere.activeHiPS;
     }
+    changeHiPSFormat(format) {
+        this.astroSphere.changeHiPSFormat(format);
+    }
+    getActiveHiPSFormats() {
+        return this.astroSphere.activeHiPS?.availableFormats ?? [];
+    }
     getActiveXYZ() {
         return this.astroSphere.activeXYZ;
     }
@@ -4995,13 +5091,13 @@ class AstroViewer {
         return this.astroSphere.getFoVPolygon();
     }
     changeFoV(deg) {
-        this, this.astroSphere.changeFoV(deg);
+        (this, this.astroSphere.changeFoV(deg));
     }
     changeFoV2(deg) {
-        this, this.astroSphere.changeFoV2(deg);
+        (this, this.astroSphere.changeFoV2(deg));
     }
     changeFoV3(deg) {
-        this, this.astroSphere.changeFoV3(deg);
+        (this, this.astroSphere.changeFoV3(deg));
     }
     getInsideSphere() {
         return this.astroSphere.getInsideSphere();
@@ -5047,13 +5143,13 @@ class AstroViewer {
         this.webglContextList = new Map();
     }
     init(canvasEl) {
-        console.log('init webgl');
+        console.log("init webgl");
         this.canvas = canvasEl;
         this.initViewfinder();
-        const gl = this.canvas.getContext('webgl2', { alpha: false });
+        const gl = this.canvas.getContext("webgl2", { alpha: false });
         if (!gl) {
-            alert('Could not initialise WebGL, sorry :-(');
-            throw new Error('WebGL2 not available');
+            alert("Could not initialise WebGL, sorry :-(");
+            throw new Error("WebGL2 not available");
         }
         // Extend with custom fields used elsewhere
         this.webgl = gl;
@@ -5064,7 +5160,7 @@ class AstroViewer {
             this.webgl.clearColor(0 * 0.00392156862, 16 * 0.00392156862, 50 * 0.00392156862, 0.7);
         }
         catch (e) {
-            console.log('Error instantiating WebGL context');
+            console.log("Error instantiating WebGL context");
         }
         this.initListeners();
         // ; (global as any).gl = this.webgl
@@ -5076,40 +5172,64 @@ class AstroViewer {
         const parent = this.canvas.parentElement;
         if (!parent)
             return;
-        if (window.getComputedStyle(parent).position === 'static') {
-            parent.style.position = 'relative';
-        }
-        const viewfinder = document.createElement('div');
-        viewfinder.setAttribute('data-astro-viewfinder', 'true');
-        viewfinder.setAttribute('aria-hidden', 'true');
-        viewfinder.style.position = 'absolute';
-        viewfinder.style.left = '50%';
-        viewfinder.style.top = '50%';
-        viewfinder.style.width = '44px';
-        viewfinder.style.height = '44px';
-        viewfinder.style.transform = 'translate(-50%, -50%)';
-        viewfinder.style.pointerEvents = 'none';
-        viewfinder.style.zIndex = '1';
-        viewfinder.style.boxSizing = 'border-box';
+        if (window.getComputedStyle(parent).position === "static") {
+            parent.style.position = "relative";
+        }
+        const viewfinder = document.createElement("div");
+        viewfinder.setAttribute("data-astro-viewfinder", "true");
+        viewfinder.setAttribute("aria-hidden", "true");
+        viewfinder.style.position = "absolute";
+        viewfinder.style.left = "50%";
+        viewfinder.style.top = "50%";
+        viewfinder.style.width = "44px";
+        viewfinder.style.height = "44px";
+        viewfinder.style.transform = "translate(-50%, -50%)";
+        viewfinder.style.pointerEvents = "none";
+        viewfinder.style.zIndex = "1";
+        viewfinder.style.boxSizing = "border-box";
         const segments = [
-            { left: '50%', top: '7px', width: '1px', height: '11px', transform: 'translateX(-50%)' },
-            { left: '50%', bottom: '7px', width: '1px', height: '11px', transform: 'translateX(-50%)' },
-            { left: '7px', top: '50%', width: '11px', height: '1px', transform: 'translateY(-50%)' },
-            { right: '7px', top: '50%', width: '11px', height: '1px', transform: 'translateY(-50%)' },
+            {
+                left: "50%",
+                top: "7px",
+                width: "1px",
+                height: "11px",
+                transform: "translateX(-50%)",
+            },
+            {
+                left: "50%",
+                bottom: "7px",
+                width: "1px",
+                height: "11px",
+                transform: "translateX(-50%)",
+            },
+            {
+                left: "7px",
+                top: "50%",
+                width: "11px",
+                height: "1px",
+                transform: "translateY(-50%)",
+            },
+            {
+                right: "7px",
+                top: "50%",
+                width: "11px",
+                height: "1px",
+                transform: "translateY(-50%)",
+            },
         ];
         for (const segmentDef of segments) {
-            const segment = document.createElement('div');
-            segment.style.position = 'absolute';
-            segment.style.left = segmentDef.left ?? 'auto';
-            segment.style.right = segmentDef.right ?? 'auto';
-            segment.style.top = segmentDef.top ?? 'auto';
-            segment.style.bottom = segmentDef.bottom ?? 'auto';
+            const segment = document.createElement("div");
+            segment.style.position = "absolute";
+            segment.style.left = segmentDef.left ?? "auto";
+            segment.style.right = segmentDef.right ?? "auto";
+            segment.style.top = segmentDef.top ?? "auto";
+            segment.style.bottom = segmentDef.bottom ?? "auto";
             segment.style.width = segmentDef.width;
             segment.style.height = segmentDef.height;
             segment.style.transform = segmentDef.transform;
-            segment.style.background = 'currentColor';
-            segment.style.borderRadius = '999px';
-            segment.style.boxShadow = '0 0 0 1px rgba(0, 0, 0, 0.14)';
+            segment.style.background = "currentColor";
+            segment.style.borderRadius = "999px";
+            segment.style.boxShadow = "0 0 0 1px rgba(0, 0, 0, 0.14)";
             viewfinder.appendChild(segment);
         }
         parent.appendChild(viewfinder);
@@ -5120,7 +5240,7 @@ class AstroViewer {
     syncViewfinderVisibility() {
         if (!this.viewfinderEl)
             return;
-        this.viewfinderEl.style.display = this.viewfinderVisible ? 'block' : 'none';
+        this.viewfinderEl.style.display = this.viewfinderVisible ? "block" : "none";
     }
     syncViewfinderColor() {
         if (!this.viewfinderEl)
@@ -5128,9 +5248,9 @@ class AstroViewer {
         this.viewfinderEl.style.color = this.viewfinderColor;
     }
     initListeners() {
-        console.log('inside initListeners');
+        console.log("inside initListeners");
         const resizeCanvas = () => {
-            console.log('[resizeCanvas]');
+            console.log("[resizeCanvas]");
             const rect = this.canvas.getBoundingClientRect();
             const dpr = window.devicePixelRatio || 1;
             const newWidth = Math.max(1, Math.floor(rect.width * dpr));
@@ -5144,7 +5264,7 @@ class AstroViewer {
             }
         };
         const handleContextLost = (event) => {
-            console.log('[handleContextLost]');
+            console.log("[handleContextLost]");
             event.preventDefault();
             if (this.rafId !== null) {
                 cancelAnimationFrame(this.rafId);
@@ -5152,7 +5272,7 @@ class AstroViewer {
             }
         };
         const handleContextRestored = (_event) => {
-            console.log('[handleContextRestored]');
+            console.log("[handleContextRestored]");
             // this.webgl.viewportWidth = this.canvas.width
             // this.webgl.viewportHeight = this.canvas.height
             this.webgl.clearColor(0 * 0.00392156862, 16 * 0.00392156862, 50 * 0.00392156862, 0.7);
@@ -5160,16 +5280,16 @@ class AstroViewer {
             this.rafId = requestAnimationFrame(() => this.tick());
         };
         // 🔥 ResizeObserver per pannelli / split / layout dinamici
-        if ('ResizeObserver' in window) {
+        if ("ResizeObserver" in window) {
             const ro = new ResizeObserver(() => {
                 resizeCanvas();
             });
             // Osserva il canvas o il suo parent (a tua scelta)
             ro.observe(this.canvas);
         }
-        window.addEventListener('resize', resizeCanvas);
-        this.canvas.addEventListener('webglcontextlost', handleContextLost, false);
-        this.canvas.addEventListener('webglcontextrestored', handleContextRestored, false);
+        window.addEventListener("resize", resizeCanvas);
+        this.canvas.addEventListener("webglcontextlost", handleContextLost, false);
+        this.canvas.addEventListener("webglcontextrestored", handleContextRestored, false);
         resizeCanvas();
     }
     tick() {
@@ -11887,6 +12007,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", ({ value: true }));
 const Global_js_1 = __importDefault(__webpack_require__(4382));
+const FitsTileLoader_js_1 = __webpack_require__(1399);
 class AllSky {
     _ready = false;
     _hips;
@@ -11894,11 +12015,12 @@ class AllSky {
     _baseurl;
     _isGalacticHips;
     _order = 3;
-    opacity = 1.0;
+    // public opacity = 1.0;
     _hipsShaderIndex = 0;
     _texture = null;
     _image;
     _texurl;
+    _fitsTile;
     _textureLoaded = false;
     _maxTiles = 0;
     _numFacesXTile = 0;
@@ -11921,15 +12043,34 @@ class AllSky {
         this.initImage();
     }
     initImage() {
-        this._image = new Image();
         this._texurl = `${this._baseurl}/Norder3/Allsky.${this._format}`;
+        if (this._format === "fits") {
+            void this.loadFits();
+            return;
+        }
+        this.loadImage();
+    }
+    loadImage() {
+        this._image = new Image();
         this._image.onload = () => this.imageLoaded();
         this._image.onerror = () => {
-            console.error('File not found? %s', this._texurl);
+            console.error("File not found? %s", this._texurl);
         };
-        this._image.setAttribute('crossorigin', 'anonymous');
+        this._image.setAttribute("crossorigin", "anonymous");
         this._image.src = this._texurl;
     }
+    async loadFits() {
+        try {
+            this._fitsTile = await (0, FitsTileLoader_js_1.loadFitsTile)(this._texurl);
+            this.textureLoaded();
+            this.initModelBuffer();
+            this._textureLoaded = true;
+            this._ready = true;
+        }
+        catch (error) {
+            console.error(`[AllSky] Unable to load FITS atlas ${this._texurl}`, error);
+        }
+    }
     imageLoaded() {
         this.textureLoaded();
         this.initModelBuffer();
@@ -11937,31 +12078,58 @@ class AllSky {
         this._ready = true;
     }
     textureLoaded() {
-        // hipsShaderProgram.enableProgram()
         this._hipsShaderProgram.enableProgram();
         const gl = this._webgl;
         this._texture = gl.createTexture();
         gl.activeTexture(gl.TEXTURE0 + this._hipsShaderIndex);
-        gl.pixelStorei(gl.UNPACK_FLIP_Y_WEBGL, true);
+        gl.pixelStorei(gl.UNPACK_FLIP_Y_WEBGL, this._format !== "fits");
         gl.bindTexture(gl.TEXTURE_2D, this._texture);
-        // gl.uniform1i(hipsShaderProgram.shaderProgram.samplerUniform, this._hipsShaderIndex)
-        if (!gl.isTexture(this._texture)) {
-            console.log('error in texture');
+        if (this._format === "fits") {
+            const fits = this._fitsTile;
+            if (!fits) {
+                throw new Error(`FITS AllSky data not loaded: ${this._texurl}`);
+            }
+            gl.texImage2D(gl.TEXTURE_2D, 0, gl.R32F, fits.width, fits.height, 0, gl.RED, gl.FLOAT, fits.pixels);
+            gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.NEAREST);
+            gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.NEAREST);
+        }
+        else {
+            gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, gl.RGBA, gl.UNSIGNED_BYTE, this._image);
+            gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.LINEAR_MIPMAP_LINEAR);
+            gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.LINEAR);
+            gl.generateMipmap(gl.TEXTURE_2D);
         }
-        gl.activeTexture(gl.TEXTURE0 + this._hipsShaderIndex);
-        gl.bindTexture(gl.TEXTURE_2D, this._texture);
-        gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, gl.RGBA, gl.UNSIGNED_BYTE, this._image);
         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);
-        const useMipmaps = true;
-        gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, useMipmaps ? gl.LINEAR_MIPMAP_LINEAR : gl.LINEAR);
-        // MAG filter: ONLY NEAREST or LINEAR are valid
-        gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.LINEAR);
-        // gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.LINEAR_MIPMAP_LINEAR)
-        // gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.LINEAR_MIPMAP_LINEAR)
-        // gl.generateMipmap(gl.TEXTURE_2D)
-        if (useMipmaps)
-            gl.generateMipmap(gl.TEXTURE_2D);
+        if (!gl.isTexture(this._texture)) {
+            console.log("error in texture");
+        }
+    }
+    getFitsDataRange() {
+        const hipsRange = this._hips.dataRange;
+        if (hipsRange.min !== undefined &&
+            hipsRange.max !== undefined &&
+            Number.isFinite(hipsRange.min) &&
+            Number.isFinite(hipsRange.max) &&
+            hipsRange.max > hipsRange.min) {
+            return {
+                min: hipsRange.min,
+                max: hipsRange.max,
+            };
+        }
+        const fits = this._fitsTile;
+        if (fits &&
+            fits.dataMin !== null &&
+            fits.dataMax !== null &&
+            Number.isFinite(fits.dataMin) &&
+            Number.isFinite(fits.dataMax) &&
+            fits.dataMax > fits.dataMin) {
+            return {
+                min: fits.dataMin,
+                max: fits.dataMax,
+            };
+        }
+        return null;
     }
     initModelBuffer() {
         const gl = this._webgl;
@@ -12026,13 +12194,16 @@ class AllSky {
                 this.vertexPosition[20 * this.vidx] = facesVec3Array[0].x;
                 this.vertexPosition[20 * this.vidx + 1] = facesVec3Array[0].y;
                 this.vertexPosition[20 * this.vidx + 2] = facesVec3Array[0].z;
-                this.vertexPosition[20 * this.vidx + 3] = s_step + base_s - s_pixel_size;
-                this.vertexPosition[20 * this.vidx + 4] = 1 - (t_step + base_t) + t_pixel_size;
+                this.vertexPosition[20 * this.vidx + 3] =
+                    s_step + base_s - s_pixel_size;
+                this.vertexPosition[20 * this.vidx + 4] =
+                    1 - (t_step + base_t) + t_pixel_size;
                 // top right
                 this.vertexPosition[20 * this.vidx + 5] = facesVec3Array[1].x;
                 this.vertexPosition[20 * this.vidx + 6] = facesVec3Array[1].y;
                 this.vertexPosition[20 * this.vidx + 7] = facesVec3Array[1].z;
-                this.vertexPosition[20 * this.vidx + 8] = s_step + base_s - s_pixel_size;
+                this.vertexPosition[20 * this.vidx + 8] =
+                    s_step + base_s - s_pixel_size;
                 this.vertexPosition[20 * this.vidx + 9] = 1 - base_t - t_pixel_size;
                 // top left
                 this.vertexPosition[20 * this.vidx + 10] = facesVec3Array[2].x;
@@ -12045,7 +12216,8 @@ class AllSky {
                 this.vertexPosition[20 * this.vidx + 16] = facesVec3Array[3].y;
                 this.vertexPosition[20 * this.vidx + 17] = facesVec3Array[3].z;
                 this.vertexPosition[20 * this.vidx + 18] = base_s + s_pixel_size;
-                this.vertexPosition[20 * this.vidx + 19] = 1 - (t_step + base_t) + t_pixel_size;
+                this.vertexPosition[20 * this.vidx + 19] =
+                    1 - (t_step + base_t) + t_pixel_size;
                 this.vidx++;
             }
         }
@@ -12065,6 +12237,17 @@ class AllSky {
         }
         const gl = this._webgl;
         this._hipsShaderProgram.enableShaders(pMatrix, vMatrix, mMatrix, colorMapIdx);
+        if (this._format === "fits") {
+            const range = this.getFitsDataRange();
+            if (!range) {
+                console.error(`[AllSky] No display range available for FITS atlas ${this._texurl}`);
+                return false;
+            }
+            this._hipsShaderProgram.setTextureDataMode(this._hipsShaderIndex, true, range.min, range.max);
+        }
+        else {
+            this._hipsShaderProgram.setTextureDataMode(this._hipsShaderIndex, false);
+        }
         gl.enableVertexAttribArray(this._hipsShaderProgram.locations.vertexPositionAttribute);
         gl.enableVertexAttribArray(this._hipsShaderProgram.locations.textureCoordAttribute);
         // hipsShaderProgram.enableShaders(pMatrix, vMatrix, mMatrix, colorMapIdx)
@@ -12072,8 +12255,11 @@ class AllSky {
         // gl.enableVertexAttribArray((hipsShaderProgram as any).locations.textureCoordAttribute)
         gl.activeTexture(gl.TEXTURE0 + this._hipsShaderIndex);
         gl.bindTexture(gl.TEXTURE_2D, this._texture);
-        // gl.uniform1f(hipsShaderProgram.locations.textureAlpha, this.opacity)
-        gl.uniform1f(this._hipsShaderProgram.locations.textureAlpha, this.opacity);
+        const factorLocation = this._hipsShaderProgram.locations.textureAlpha[this._hipsShaderIndex];
+        if (factorLocation !== null) {
+            gl.uniform1f(factorLocation, 1.0);
+        }
+        this._hipsShaderProgram.setLayerOpacity(this._hips.opacity);
         gl.bindBuffer(gl.ARRAY_BUFFER, this.vertexPositionBuffer);
         gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, this.vertexIndexBuffer);
         gl.vertexAttribPointer(
@@ -12101,13 +12287,13 @@ class AllSky {
         const allSkyTiles2Skip = [];
         for (let i = 0; i < visibleTiles.length; i++) {
             const tileno = visibleTiles[i];
+            if (!this._hips.intersectsCoverage(childrenOrder, tileno)) {
+                allSkyTiles2Skip.push(tileno);
+                continue;
+            }
             const childTile = this._isGalacticHips
                 ? this._tileBuffer.getGalTile(tileno, childrenOrder, this._hips)
                 : this._tileBuffer.getTile(tileno, childrenOrder, this._hips);
-            // const childTile = this._isGalacticHips
-            //   ? newTileBuffer.getGalTile(tileno, childrenOrder, this._hips)
-            //   : newTileBuffer.getTile(tileno, childrenOrder, this._hips)
-            // childTile.draw(visibleOrder, visibleTilesMap, pMatrix, vMatrix, mMatrix, colorMapIdx)
             childTile.draw(visibleOrder, visibleTilesMap, pMatrix, vMatrix, mMatrix, colorMapIdx, this._hipsShaderProgram);
             if (childTile.getReadyState()) {
                 allSkyTiles2Skip.push(tileno);
@@ -12141,6 +12327,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", ({ value: true }));
 const Global_js_1 = __importDefault(__webpack_require__(4382));
 const FoVHelper_js_1 = __webpack_require__(229);
+const FitsTileLoader_js_1 = __webpack_require__(1399);
 class AncestorTile {
     _hips;
     _tileno;
@@ -12154,7 +12341,8 @@ class AncestorTile {
     _pixels = [];
     _texture = null;
     _image;
-    _texurl = '';
+    _texurl = "";
+    _fitsTile;
     vertexPosition;
     vertexPositionBuffer;
     vertexIndices;
@@ -12180,14 +12368,41 @@ class AncestorTile {
     }
     initImage() {
         const dirnumber = Math.floor(this._tileno / 10000) * 10000;
-        this._texurl = `${this._baseurl}/Norder${this._order}/Dir${dirnumber}/Npix${this._tileno}.${this._format}`;
+        this._texurl =
+            `${this._baseurl}/Norder${this._order}/Dir${dirnumber}` +
+                `/Npix${this._tileno}.${this._format}`;
+        if (this._format === "fits") {
+            void this.loadFits();
+            return;
+        }
+        this.loadImage();
+    }
+    async loadFits() {
+        try {
+            this._fitsTile = await (0, FitsTileLoader_js_1.loadFitsTile)(this._texurl);
+            this.textureLoaded();
+            const fits = this._fitsTile;
+            if (!fits) {
+                throw new Error(`FITS tile data not loaded: ${this._texurl}`);
+            }
+            const gl = this._webgl;
+            gl.activeTexture(gl.TEXTURE0 + this._hipsShaderIndex);
+            gl.bindTexture(gl.TEXTURE_2D, this._texture);
+            gl.texImage2D(gl.TEXTURE_2D, 0, gl.R32F, fits.width, fits.height, 0, gl.RED, gl.FLOAT, fits.pixels);
+            this.initModelBuffer();
+            this._ready = true;
+        }
+        catch (error) {
+            console.error(`[AncestorTile] Unable to load FITS tile ${this._texurl}`, error);
+        }
+    }
+    loadImage() {
         this._image = new Image();
         this._image.onload = () => this.imageLoaded();
         this._image.onerror = () => {
-            console.error('File not found? %s', this._texurl);
+            console.error("File not found? %s", this._texurl);
         };
-        this._image.crossOrigin = 'anonymous';
-        // If you ever need FITS handling, call this.loadImage() instead.
+        this._image.crossOrigin = "anonymous";
         this._image.src = this._texurl;
     }
     imageLoaded() {
@@ -12205,15 +12420,47 @@ class AncestorTile {
         const gl = this._webgl;
         this._texture = gl.createTexture();
         gl.activeTexture(gl.TEXTURE0 + this._hipsShaderIndex);
-        gl.pixelStorei(gl.UNPACK_FLIP_Y_WEBGL, true);
+        gl.pixelStorei(gl.UNPACK_FLIP_Y_WEBGL, this._format !== "fits");
         gl.bindTexture(gl.TEXTURE_2D, this._texture);
         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.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.LINEAR);
-        gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.LINEAR);
+        if (this._format === "fits") {
+            gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.NEAREST);
+            gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.NEAREST);
+        }
+        else {
+            gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.LINEAR);
+            gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.LINEAR);
+        }
         if (!gl.isTexture(this._texture)) {
-            console.log('error in texture');
+            console.log("error in texture");
+        }
+    }
+    getFitsDataRange() {
+        const hipsRange = this._hips.dataRange;
+        if (hipsRange.min !== undefined &&
+            hipsRange.max !== undefined &&
+            Number.isFinite(hipsRange.min) &&
+            Number.isFinite(hipsRange.max) &&
+            hipsRange.max > hipsRange.min) {
+            return {
+                min: hipsRange.min,
+                max: hipsRange.max,
+            };
         }
+        const fits = this._fitsTile;
+        if (fits &&
+            fits.dataMin !== null &&
+            fits.dataMax !== null &&
+            Number.isFinite(fits.dataMin) &&
+            Number.isFinite(fits.dataMax) &&
+            fits.dataMax > fits.dataMin) {
+            return {
+                min: fits.dataMin,
+                max: fits.dataMax,
+            };
+        }
+        return null;
     }
     initModelBuffer() {
         const gl = this._webgl;
@@ -12256,43 +12503,6 @@ class AncestorTile {
         }
         return vertexIndices;
     }
-    // Version that uses getPointsForXyfNoStep (kept for reference; not used in this class)
-    setupPositionAndTexture4Quadrant2(dxmin, dxmax, dymin, dymax, qidx, healpix, orderjump, origxyf) {
-        this.vertexPosition[qidx] = new Float32Array(20 * (dxmax - dxmin) * (dymax - dymin));
-        const step = 1 / (1 << orderjump);
-        let p = 0;
-        for (let dx = dxmin; dx < dxmax; dx++) {
-            for (let dy = dymin; dy < dymax; dy++) {
-                const facesVec3Array = healpix.getPointsForXyfNoStep(dx, dy, origxyf.face);
-                const uindex = dy - (origxyf.iy << orderjump);
-                const vindex = dx - (origxyf.ix << orderjump);
-                this.vertexPosition[qidx][20 * p] = facesVec3Array[0].x;
-                this.vertexPosition[qidx][20 * p + 1] = facesVec3Array[0].y;
-                this.vertexPosition[qidx][20 * p + 2] = facesVec3Array[0].z;
-                this.vertexPosition[qidx][20 * p + 3] = step + step * uindex;
-                this.vertexPosition[qidx][20 * p + 4] = 1 - (step + step * vindex);
-                this.vertexPosition[qidx][20 * p + 5] = facesVec3Array[1].x;
-                this.vertexPosition[qidx][20 * p + 6] = facesVec3Array[1].y;
-                this.vertexPosition[qidx][20 * p + 7] = facesVec3Array[1].z;
-                this.vertexPosition[qidx][20 * p + 8] = step + step * uindex;
-                this.vertexPosition[qidx][20 * p + 9] = 1 - step * vindex;
-                this.vertexPosition[qidx][20 * p + 10] = facesVec3Array[2].x;
-                this.vertexPosition[qidx][20 * p + 11] = facesVec3Array[2].y;
-                this.vertexPosition[qidx][20 * p + 12] = facesVec3Array[2].z;
-                this.vertexPosition[qidx][20 * p + 13] = step * uindex;
-                this.vertexPosition[qidx][20 * p + 14] = 1 - step * vindex;
-                this.vertexPosition[qidx][20 * p + 15] = facesVec3Array[3].x;
-                this.vertexPosition[qidx][20 * p + 16] = facesVec3Array[3].y;
-                this.vertexPosition[qidx][20 * p + 17] = facesVec3Array[3].z;
-                this.vertexPosition[qidx][20 * p + 18] = step * uindex;
-                this.vertexPosition[qidx][20 * p + 19] = 1 - (step + step * vindex);
-                p++;
-            }
-        }
-        this.vertexPositionBuffer[qidx] = this._webgl.createBuffer();
-        this._webgl.bindBuffer(this._webgl.ARRAY_BUFFER, this.vertexPositionBuffer[qidx]);
-        this._webgl.bufferData(this._webgl.ARRAY_BUFFER, this.vertexPosition[qidx], this._webgl.STATIC_DRAW);
-    }
     // Version used by the original JS, collecting _pixels via xyf2nest + getBoundaries
     setupPositionAndTexture4Quadrant(dxmin, dxmax, dymin, dymax, qidx, healpix, orderjump, origxyf) {
         const gl = this._webgl;
@@ -12344,12 +12554,26 @@ class AncestorTile {
                 quadrantsToDraw = q;
         }
         this._hipsShaderProgram.enableShaders(pMatrix, vMatrix, mMatrix, colorMapIdx);
+        if (this._format === "fits") {
+            const range = this.getFitsDataRange();
+            if (!range) {
+                console.error(`[AncestorTile] No display range available for FITS tile ${this._texurl}`);
+                return false;
+            }
+            this._hipsShaderProgram.setTextureDataMode(this._hipsShaderIndex, true, range.min, range.max);
+        }
+        else {
+            this._hipsShaderProgram.setTextureDataMode(this._hipsShaderIndex, false);
+        }
         const gl = this._webgl;
         gl.enableVertexAttribArray(this._hipsShaderProgram.locations.vertexPositionAttribute);
         gl.enableVertexAttribArray(this._hipsShaderProgram.locations.textureCoordAttribute);
         gl.activeTexture(gl.TEXTURE0 + this._hipsShaderIndex);
         gl.bindTexture(gl.TEXTURE_2D, this._texture);
-        gl.uniform1f(this._hipsShaderProgram.locations.textureAlpha, this.opacity);
+        const factorLocation = this._hipsShaderProgram.locations.textureAlpha[this._hipsShaderIndex];
+        if (factorLocation) {
+            gl.uniform1f(factorLocation, this.opacity);
+        }
         gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, this.vertexIndexBuffer);
         const elemno = this.vertexIndices.length;
         quadrantsToDraw.forEach((qidx) => {
@@ -12369,15 +12593,21 @@ class AncestorTile {
             return;
         for (let c = 0; c < 4; c++) {
             const childTileNo = (this._tileno << 2) + c;
+            if (!this._hips.intersectsCoverage(childrenOrder, childTileNo)) {
+                continue;
+            }
             const visibleChildren = visibleTilesMap.get(childrenOrder);
             if (visibleChildren.includes(childTileNo)) {
+                if (!this._hips.intersectsCoverage(childrenOrder, childTileNo)) {
+                    quadrantsToDraw.delete(c);
+                    continue;
+                }
                 const childTile = this._isGalacticHips
                     ? this._tileBuffer.getGalTile(childTileNo, childrenOrder, this._hips)
                     : this._tileBuffer.getTile(childTileNo, childrenOrder, this._hips);
-                // childTile.draw(visibleOrder, visibleTilesMap, pMatrix, vMatrix, mMatrix, colorMapIdx)
                 childTile.draw(visibleOrder, visibleTilesMap, pMatrix, vMatrix, mMatrix, colorMapIdx, this._hipsShaderProgram);
-                if (childTile._ready) {
-                    quadrantsToDraw.delete(childTile._tileno - (this._tileno << 2));
+                if (childTile.getReadyState()) {
+                    quadrantsToDraw.delete(c);
                 }
             }
         }
@@ -12387,6 +12617,81 @@ class AncestorTile {
 exports["default"] = AncestorTile;
 
 
+/***/ },
+
+/***/ 1399
+(__unused_webpack_module, exports, __webpack_require__) {
+
+var __webpack_unused_export__;
+
+/*
+ * AstroViewer
+ * Copyright (C) Fabrizio Giordano
+ * SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-AstroViewer-Commercial
+ *
+ * AstroViewer is dual-licensed under the GNU Affero General Public License
+ * version 3 and a separate commercial license.
+ *
+ * See LICENSE.md, LICENSE-AGPL.md, and LICENSE-COMMERCIAL.md for details.
+ */
+__webpack_unused_export__ = ({ value: true });
+exports.loadFitsTile = loadFitsTile;
+const jsfitsio_1 = __webpack_require__(4971);
+async function loadFitsTile(url) {
+    const fitsFile = await jsfitsio_1.FITSParser.loadFITSFile(url);
+    if (!fitsFile?.primaryHDU) {
+        throw new Error(`Unable to load FITS tile: ${url}`);
+    }
+    const image = fitsFile.primaryHDU;
+    if (image.naxis !== 2) {
+        throw new Error(`Expected a 2D FITS tile, got NAXIS=${image.naxis}: ${url}`);
+    }
+    const [width, height] = image.shape;
+    if (!Number.isInteger(width) ||
+        !Number.isInteger(height) ||
+        width <= 0 ||
+        height <= 0) {
+        throw new Error(`Invalid FITS tile dimensions: ${url}`);
+    }
+    const data = image.typedData;
+    if (!data || data.length !== width * height) {
+        throw new Error(`Invalid FITS tile payload: ${url}`);
+    }
+    if (data instanceof BigInt64Array) {
+        throw new Error(`BITPIX=64 FITS tiles are not supported for HiPS rendering: ${url}`);
+    }
+    const bscale = getNumericHeaderValue(image.header, jsfitsio_1.FITSHeaderManager.BSCALE) ?? 1;
+    const bzero = getNumericHeaderValue(image.header, jsfitsio_1.FITSHeaderManager.BZERO) ?? 0;
+    const blank = getNumericHeaderValue(image.header, jsfitsio_1.FITSHeaderManager.BLANK);
+    const dataMin = getNumericHeaderValue(image.header, jsfitsio_1.FITSHeaderManager.DATAMIN);
+    const dataMax = getNumericHeaderValue(image.header, jsfitsio_1.FITSHeaderManager.DATAMAX);
+    const pixels = new Float32Array(data.length);
+    for (let i = 0; i < data.length; i++) {
+        const rawValue = data[i];
+        if (!Number.isFinite(rawValue) || (blank !== null && rawValue === blank)) {
+            pixels[i] = Number.NaN;
+            continue;
+        }
+        pixels[i] = rawValue * bscale + bzero;
+    }
+    return {
+        width,
+        height,
+        pixels,
+        dataMin,
+        dataMax,
+    };
+}
+function getNumericHeaderValue(header, key) {
+    const item = header.findById(key);
+    if (!item) {
+        return null;
+    }
+    const value = Number(item.value);
+    return Number.isFinite(value) ? value : null;
+}
+
+
 /***/ },
 
 /***/ 229
@@ -12579,10 +12884,14 @@ const FoVHelper_js_1 = __webpack_require__(229);
 const ColorMaps_js_1 = __importDefault(__webpack_require__(619));
 const AncestorTile_js_1 = __importDefault(__webpack_require__(2885));
 const AllSky_js_1 = __importDefault(__webpack_require__(2368));
+const HiPSCoverage_js_1 = __webpack_require__(9912);
 class HiPS extends AbstractSkyEntity_js_1.AbstractSkyEntity {
     _ancestorTiles;
     _allSkyTile;
     _descriptor;
+    _coverage;
+    _coverageResolved = false;
+    _opacity = 1.0;
     _format;
     _baseurl;
     _maxorder;
@@ -12591,30 +12900,58 @@ class HiPS extends AbstractSkyEntity_js_1.AbstractSkyEntity {
     _allSky = true;
     samplerIdx = 0;
     colorMapIdx = 0;
-    colorMap = ColorMaps_js_1.default['native'];
+    colorMap = ColorMaps_js_1.default["native"];
     _healpixGrid;
     // exposed read-only helpers
-    get maxOrder() { return this._maxorder; }
-    get minOrder() { return this._minorder; }
-    get baseURL() { return this._baseurl; }
-    get format() { return this._format; }
-    get propertiesRawText() { return this._descriptor.propertiesRawText; }
-    get properties() { return this._descriptor.properties; }
+    get maxOrder() {
+        return this._maxorder;
+    }
+    get minOrder() {
+        return this._minorder;
+    }
+    get baseURL() {
+        return this._baseurl;
+    }
+    get format() {
+        return this._format;
+    }
+    get propertiesRawText() {
+        return this._descriptor.propertiesRawText;
+    }
+    get properties() {
+        return this._descriptor.properties;
+    }
     constructor(radius, position, xrad, yrad, descriptor, webgl, healpixGrid) {
         super(radius, position, xrad, yrad, descriptor.surveyName, webgl, descriptor.isGalactic);
         this._descriptor = descriptor;
         this.initGL(webgl);
         this._healpixGrid = healpixGrid;
-        this._healpixGrid.visibleTilesManager.tileBuffer.addHiPS(this);
-        // DEBUG logs kept from JS (optional)
-        // eslint-disable-next-line no-console
-        console.log('HiPS frame ' + descriptor.hipsFrame);
-        // eslint-disable-next-line no-console
-        console.log('HiPS minOrder ' + descriptor.minOrder);
-        this._format = descriptor.imgFormats[0];
+        this._format = this.selectDefaultFormat(descriptor.imgFormats);
         this._baseurl = descriptor.url;
         this._maxorder = descriptor.maxOrder;
         this._minorder = descriptor.minOrder;
+        this._coverage = new HiPSCoverage_js_1.HiPSCoverage();
+        void this._coverage
+            .load(this._baseurl)
+            .then(() => {
+            this._coverageResolved = true;
+        })
+            .catch((error) => {
+            console.warn(`[HiPS] Coverage unavailable for ${this._baseurl}; continuing without MOC filtering.`, error);
+            this._coverage.clear();
+            this._coverageResolved = true;
+        });
+        if (this.isGalacticHips) {
+            this._healpixGrid.visibleTilesManager.tileBuffer.addGalHiPS(this);
+        }
+        else {
+            this._healpixGrid.visibleTilesManager.tileBuffer.addHiPS(this);
+        }
+        // DEBUG logs kept from JS (optional)
+        // eslint-disable-next-line no-console
+        console.log("HiPS frame " + descriptor.hipsFrame);
+        // eslint-disable-next-line no-console
+        console.log("HiPS minOrder " + descriptor.minOrder);
         this.initShaders();
         // pick initial order from a starting FoV
         const fov = 180;
@@ -12624,39 +12961,77 @@ class HiPS extends AbstractSkyEntity_js_1.AbstractSkyEntity {
         this._allSkyTile = null;
         // auto-detect all-sky: original code forces true
         this._allSky = true;
+        this.initBaseTiles();
+    }
+    setOpacity(opacity) {
+        if (!Number.isFinite(opacity)) {
+            throw new Error(`Invalid HiPS opacity: ${opacity}`);
+        }
+        this._opacity = Math.min(1, Math.max(0, opacity));
+    }
+    get opacity() {
+        return this._opacity;
+    }
+    intersectsCoverage(order, pixel) {
+        /*
+         * While Moc.fits is being resolved, do not start tile requests.
+         *
+         * Once loading has completed:
+         * - valid MOC -> filter using coverage
+         * - unavailable MOC -> HiPSCoverage is cleared and normal loading resumes
+         */
+        if (!this._coverageResolved) {
+            return false;
+        }
+        return this._coverage.intersectsTile(order, pixel);
+    }
+    get coverageLoaded() {
+        return this._coverage.loaded;
+    }
+    initBaseTiles() {
+        this._ancestorTiles = [];
+        this._allSkyTile = null;
         if (this._allSky) {
             this._allSkyTile = new AllSky_js_1.default(this, this._webgl, this._healpixGrid.visibleTilesManager.tileBuffer, super.hipsShaderProgram);
+            return;
         }
-        else {
-            for (let t = 0; t < 12; t++) {
-                this._ancestorTiles.push(new AncestorTile_js_1.default(t, 0, this, this._healpixGrid.visibleTilesManager.tileBuffer, super.hipsShaderProgram, this._webgl));
-            }
+        for (let t = 0; t < 12; t++) {
+            this._ancestorTiles.push(new AncestorTile_js_1.default(t, 0, this, this._healpixGrid.visibleTilesManager.tileBuffer, super.hipsShaderProgram, this._webgl));
         }
     }
     getProperty(key) {
         return this._descriptor.getProperty(key);
     }
     changeFormat(format) {
-        this._format = format;
-        // original code referenced _tileBuffer; if you have one, wire it back.
-        // Keeping calls no-op to avoid breaking at runtime if _tileBuffer is undefined.
-        // (newVisibleTilesManager + TileBuffer drive the actual tile lifecycle)
-        // @ts-ignore
-        if (this._tileBuffer?.clearAll)
-            this._tileBuffer.clearAll();
-        // @ts-ignore
-        if (this._tileBuffer)
-            this._tileBuffer._format = this._format;
-        const pixelByOrder = this.isGalacticHips
-            ? this._healpixGrid.visibleTilesManager.galVisibleTilesByOrder
-            : this._healpixGrid.visibleTilesManager.visibleTilesByOrder;
-        // const pixelByOrder =
-        //   this.isGalacticHips
-        //     ? visibleTilesManager.galVisibleTilesByOrder
-        //     : visibleTilesManager.visibleTilesByOrder
-        // @ts-ignore
-        if (this._tileBuffer?.updateTiles)
-            this._tileBuffer.updateTiles(pixelByOrder.pixels, pixelByOrder.order);
+        const normalizedFormat = format.toLowerCase();
+        if (!this._descriptor.imgFormats.includes(normalizedFormat)) {
+            throw new Error(`HiPS format "${format}" is not supported. ` +
+                `Available formats: ${this._descriptor.imgFormats.join(", ")}`);
+        }
+        if (normalizedFormat === this._format.toLowerCase()) {
+            return;
+        }
+        const tileBuffer = this._healpixGrid.visibleTilesManager.tileBuffer;
+        /*
+         * Remove Tile instances created using the previous format.
+         *
+         * TileBuffer invalidates by HiPS identity/base URL rather than by the
+         * current format, so both active and cached resources are discarded.
+         */
+        tileBuffer.invalidateHiPS(this);
+        /*
+         * Change format before recreating AllSky/AncestorTile because their
+         * constructors read hips.format.
+         */
+        this._format = normalizedFormat;
+        /*
+         * AllSky and AncestorTile also keep the format they were constructed
+         * with, so they must be recreated.
+         */
+        this.initBaseTiles();
+    }
+    get availableFormats() {
+        return this._descriptor.imgFormats;
     }
     /**
      * Shader colormap switcher
@@ -12669,60 +13044,60 @@ class HiPS extends AbstractSkyEntity_js_1.AbstractSkyEntity {
      * 6 -> cubehelix
      */
     changeColorMap(colorMap) {
-        console.log('HiPS.changeColorMap -> shaderProgram', super.hipsShaderProgram.shaderProgram);
+        console.log("HiPS.changeColorMap -> shaderProgram", super.hipsShaderProgram.shaderProgram);
         this.colorMap = colorMap;
         switch (colorMap.name) {
-            case 'grayscale':
+            case "grayscale":
                 this.colorMapIdx = 1;
                 // hipsShaderProgram.setGrayscaleShader()
-                this.colorMap = ColorMaps_js_1.default['grayscale'];
+                this.colorMap = ColorMaps_js_1.default["grayscale"];
                 super.hipsShaderProgram.setGrayscaleShader();
                 break;
-            case 'planck':
+            case "planck":
                 this.colorMapIdx = 2;
-                this.colorMap = ColorMaps_js_1.default['planck'];
+                this.colorMap = ColorMaps_js_1.default["planck"];
                 // hipsShaderProgram.setColorMapShader()
                 super.hipsShaderProgram.setColorMapShader();
                 break;
-            case 'cmb':
+            case "cmb":
                 this.colorMapIdx = 3;
-                this.colorMap = ColorMaps_js_1.default['cmb'];
+                this.colorMap = ColorMaps_js_1.default["cmb"];
                 // hipsShaderProgram.setColorMapShader()
                 super.hipsShaderProgram.setColorMapShader();
                 break;
-            case 'rainbow':
+            case "rainbow":
                 this.colorMapIdx = 4;
-                this.colorMap = ColorMaps_js_1.default['rainbow'];
+                this.colorMap = ColorMaps_js_1.default["rainbow"];
                 // hipsShaderProgram.setColorMapShader()
                 super.hipsShaderProgram.setColorMapShader();
                 break;
-            case 'eosb':
+            case "eosb":
                 this.colorMapIdx = 5;
-                this.colorMap = ColorMaps_js_1.default['eosb'];
+                this.colorMap = ColorMaps_js_1.default["eosb"];
                 super.hipsShaderProgram.setColorMapShader();
                 // hipsShaderProgram.setColorMapShader()
                 break;
-            case 'cubehelix':
+            case "cubehelix":
                 this.colorMapIdx = 6;
-                this.colorMap = ColorMaps_js_1.default['cubehelix'];
+                this.colorMap = ColorMaps_js_1.default["cubehelix"];
                 super.hipsShaderProgram.setColorMapShader();
                 // hipsShaderProgram.setColorMapShader()
                 break;
-            case 'hot':
+            case "hot":
                 this.colorMapIdx = 7;
-                this.colorMap = ColorMaps_js_1.default['hot'];
+                this.colorMap = ColorMaps_js_1.default["hot"];
                 super.hipsShaderProgram.setColorMapShader();
                 // hipsShaderProgram.setColorMapShader()
                 break;
-            case 'gray':
+            case "gray":
                 this.colorMapIdx = 8;
-                this.colorMap = ColorMaps_js_1.default['gray'];
+                this.colorMap = ColorMaps_js_1.default["gray"];
                 super.hipsShaderProgram.setColorMapShader();
                 // hipsShaderProgram.setColorMapShader()
                 break;
-            case 'native':
+            case "native":
                 this.colorMapIdx = 0;
-                this.colorMap = ColorMaps_js_1.default['native'];
+                this.colorMap = ColorMaps_js_1.default["native"];
                 super.hipsShaderProgram.setNativeShader();
                 break;
             default:
@@ -12737,6 +13112,30 @@ class HiPS extends AbstractSkyEntity_js_1.AbstractSkyEntity {
         // this.shaderProgram = super.hipsShaderProgram.shaderProgram
         // this.shaderProgram = hipsShaderProgram.shaderProgram
     }
+    //   private selectDefaultFormat(formats: string[]): string {
+    //   if (formats.includes("fits")) return "fits";
+    //   if (formats.includes("png")) return "png";
+    //   if (formats.includes("jpg")) return "jpg";
+    //   if (formats.length > 0) {
+    //     return formats[0];
+    //   }
+    //   throw new Error("HiPS descriptor does not define a tile format");
+    // }
+    selectDefaultFormat(formats) {
+        if (formats.includes("png"))
+            return "png";
+        if (formats.includes("jpg"))
+            return "jpg";
+        if (formats.includes("fits"))
+            return "fits";
+        if (formats.length > 0) {
+            return formats[0];
+        }
+        throw new Error("HiPS descriptor does not define a tile format");
+    }
+    get dataRange() {
+        return this._descriptor.dataRange;
+    }
     getCurrentHealpixOrder() {
         return this._visibleorder;
     }
@@ -12746,7 +13145,7 @@ class HiPS extends AbstractSkyEntity_js_1.AbstractSkyEntity {
             ? this._healpixGrid.visibleTilesManager.galVisibleTilesByOrder
             : this._healpixGrid.visibleTilesManager.visibleTilesByOrder;
         return {
-            activeBaseLayer: 'hips',
+            activeBaseLayer: "hips",
             hipsName: this._descriptor.surveyName,
             hipsUrl: this._baseurl,
             isGalactic: this.isGalacticHips,
@@ -12778,16 +13177,10 @@ class HiPS extends AbstractSkyEntity_js_1.AbstractSkyEntity {
         super.hipsShaderProgram.setRuntimeColorMap(this.colorMap);
         if (this._allSky && this._allSkyTile) {
             if (this.isGalacticHips) {
-                this._allSkyTile.draw(this._healpixGrid.visibleTilesManager.galVisibleTilesByOrder.order, this._healpixGrid.visibleTilesManager.galAncestorsMap, 
-                // visibleTilesManager.galVisibleTilesByOrder.order,
-                // visibleTilesManager.galAncestorsMap,
-                pMatrix, vMatrix, mMatrix, this.colorMapIdx);
+                this._allSkyTile.draw(this._healpixGrid.visibleTilesManager.galVisibleTilesByOrder.order, this._healpixGrid.visibleTilesManager.galAncestorsMap, pMatrix, vMatrix, mMatrix, this.colorMapIdx);
             }
             else {
-                this._allSkyTile.draw(this._healpixGrid.visibleTilesManager.visibleTilesByOrder.order, this._healpixGrid.visibleTilesManager.ancestorsMap, 
-                // visibleTilesManager.visibleTilesByOrder.order,
-                // visibleTilesManager.ancestorsMap,
-                pMatrix, vMatrix, mMatrix, this.colorMapIdx);
+                this._allSkyTile.draw(this._healpixGrid.visibleTilesManager.visibleTilesByOrder.order, this._healpixGrid.visibleTilesManager.ancestorsMap, pMatrix, vMatrix, mMatrix, this.colorMapIdx);
             }
             return;
         }
@@ -12808,8 +13201,10 @@ exports.HiPS = HiPS;
 
 /***/ },
 
-/***/ 5087
-(__unused_webpack_module, exports) {
+/***/ 9912
+(__unused_webpack_module, exports, __webpack_require__) {
+
+var __webpack_unused_export__;
 
 /*
  * AstroViewer
@@ -12821,10 +13216,185 @@ exports.HiPS = HiPS;
  *
  * See LICENSE.md, LICENSE-AGPL.md, and LICENSE-COMMERCIAL.md for details.
  */
-// HiPSDescriptor.ts
-
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.HiPSDescriptor = void 0;
+__webpack_unused_export__ = ({ value: true });
+exports.HiPSCoverage = void 0;
+const jsfitsio_1 = __webpack_require__(4971);
+class HiPSCoverage {
+    intersec(intersec, arg1) {
+        throw new Error("Method not implemented.");
+    }
+    ises(ises, expents, of, arg3) {
+        throw new Error("Method not implemented.");
+    }
+    intersexpect(co, t, expe, arg3) {
+        throw new Error("Method not implemented.");
+    }
+    intersectsT19(intersectsT19, arg1) {
+        throw new Error("Method not implemented.");
+    }
+    _maxOrder = 0;
+    _intervals = [];
+    _loaded = false;
+    get loaded() {
+        return this._loaded;
+    }
+    get maxOrder() {
+        return this._maxOrder;
+    }
+    get intervalCount() {
+        return this._intervals.length;
+    }
+    clear() {
+        this._maxOrder = 0;
+        this._intervals = [];
+        this._loaded = false;
+    }
+    async load(baseUrl) {
+        const baseUrlString = baseUrl instanceof URL ? baseUrl.href : String(baseUrl);
+        const normalizedBaseUrl = baseUrlString.endsWith("/")
+            ? baseUrlString
+            : `${baseUrlString}/`;
+        await this.loadMoc(`${normalizedBaseUrl}Moc.fits`);
+    }
+    async loadMoc(mocUrl) {
+        this.clear();
+        const fits = await jsfitsio_1.FITSParser.loadFITSFile(mocUrl);
+        if (!fits) {
+            throw new Error("Unable to load HiPS Moc.fits");
+        }
+        const mocHDU = fits.hdus.find((hdu) => hdu instanceof jsfitsio_1.BinaryTableHDU);
+        if (!(mocHDU instanceof jsfitsio_1.BinaryTableHDU)) {
+            throw new Error("HiPS Moc.fits does not contain a BINTABLE HDU.");
+        }
+        const mocOrderItem = mocHDU.header.findById("MOCORDER");
+        if (!mocOrderItem) {
+            throw new Error("HiPS Moc.fits does not define MOCORDER.");
+        }
+        const maxOrder = Number(mocOrderItem.value);
+        if (!Number.isInteger(maxOrder) || maxOrder < 0) {
+            throw new Error(`Invalid MOCORDER value: ${mocOrderItem.value}`);
+        }
+        this._maxOrder = maxOrder;
+        const intervals = [];
+        for (let row = 0; row < mocHDU.rowCount; row++) {
+            const rawUniq = mocHDU.getCell(row, "UNIQ");
+            if (typeof rawUniq !== "number" ||
+                !Number.isInteger(rawUniq) ||
+                rawUniq < 4) {
+                throw new Error(`Invalid MOC UNIQ value at row ${row}: ${String(rawUniq)}`);
+            }
+            const { order, pixel } = HiPSCoverage.decodeUniq(rawUniq);
+            if (order > this._maxOrder) {
+                throw new Error(`MOC cell order ${order} exceeds MOCORDER ${this._maxOrder}.`);
+            }
+            const scale = 4 ** (this._maxOrder - order);
+            intervals.push({
+                first: pixel * scale,
+                last: (pixel + 1) * scale - 1,
+            });
+        }
+        this._intervals = HiPSCoverage.mergeIntervals(intervals);
+        this._loaded = true;
+    }
+    intersectsTile(order, pixel) {
+        if (!this._loaded) {
+            return true;
+        }
+        if (!Number.isInteger(order) ||
+            order < 0 ||
+            !Number.isInteger(pixel) ||
+            pixel < 0) {
+            return false;
+        }
+        let first;
+        let last;
+        if (order <= this._maxOrder) {
+            const scale = 4 ** (this._maxOrder - order);
+            first = pixel * scale;
+            last = (pixel + 1) * scale - 1;
+        }
+        else {
+            /*
+             * At orders finer than the MOC resolution, reduce the tile
+             * to its ancestor at MOCORDER.
+             */
+            const shift = 2 * (order - this._maxOrder);
+            const ancestor = Math.floor(pixel / 2 ** shift);
+            first = ancestor;
+            last = ancestor;
+        }
+        return this.intersectsInterval(first, last);
+    }
+    intersectsInterval(first, last) {
+        let low = 0;
+        let high = this._intervals.length - 1;
+        while (low <= high) {
+            const middle = Math.floor((low + high) / 2);
+            const interval = this._intervals[middle];
+            if (interval.last < first) {
+                low = middle + 1;
+                continue;
+            }
+            if (interval.first > last) {
+                high = middle - 1;
+                continue;
+            }
+            return true;
+        }
+        return false;
+    }
+    static decodeUniq(uniq) {
+        let order = 0;
+        while (4 ** (order + 2) <= uniq) {
+            order++;
+        }
+        const base = 4 ** (order + 1);
+        return {
+            order,
+            pixel: uniq - base,
+        };
+    }
+    static mergeIntervals(intervals) {
+        if (intervals.length === 0) {
+            return [];
+        }
+        intervals.sort((a, b) => a.first - b.first);
+        const merged = [{ ...intervals[0] }];
+        for (let i = 1; i < intervals.length; i++) {
+            const current = intervals[i];
+            const previous = merged[merged.length - 1];
+            if (current.first <= previous.last + 1) {
+                previous.last = Math.max(previous.last, current.last);
+            }
+            else {
+                merged.push({ ...current });
+            }
+        }
+        return merged;
+    }
+}
+exports.HiPSCoverage = HiPSCoverage;
+
+
+/***/ },
+
+/***/ 5087
+(__unused_webpack_module, exports) {
+
+/*
+ * AstroViewer
+ * Copyright (C) Fabrizio Giordano
+ * SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-AstroViewer-Commercial
+ *
+ * AstroViewer is dual-licensed under the GNU Affero General Public License
+ * version 3 and a separate commercial license.
+ *
+ * See LICENSE.md, LICENSE-AGPL.md, and LICENSE-COMMERCIAL.md for details.
+ */
+// HiPSDescriptor.ts
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.HiPSDescriptor = void 0;
 class HiPSDescriptor {
     _minOrder = 3;
     _imgformats = [];
@@ -12980,6 +13550,7 @@ Object.defineProperty(exports, "__esModule", ({ value: true }));
 // Tile.ts
 const Global_js_1 = __importDefault(__webpack_require__(4382));
 const FoVHelper_js_1 = __webpack_require__(229);
+const FitsTileLoader_js_1 = __webpack_require__(1399);
 // ------------------------------------------------------------------------
 class Tile {
     _hips;
@@ -12994,8 +13565,9 @@ class Tile {
     _image;
     _textureLoaded = false;
     _texture;
-    _texurl = '';
+    _texurl = "";
     _hipsShaderIndex = 0;
+    _fitsTile;
     _cacheTime0;
     _inView = true;
     _amIStillInFoV_requsetID;
@@ -13005,7 +13577,7 @@ class Tile {
     vertexIndices = new Uint16Array();
     vertexIndexBuffer;
     _tileBuffer;
-    opacity = 1.0;
+    // public opacity = 1.0;
     _webgl;
     _visibleTileManager;
     // private _hipsShaderProgram
@@ -13052,50 +13624,66 @@ class Tile {
             console.warn(`[Tile] Skipping tile request above max order: requested order ${this._order}, max order ${this._maxorder}, url ${this._baseurl}`);
             return;
         }
-        this._image = new Image();
         const dirnumber = Math.floor(this._tileno / 10000) * 10000;
         this._texurl = `${this._baseurl}/Norder${this._order}/Dir${dirnumber}/Npix${this._tileno}.${this._format}`;
+        if (this._format === "fits") {
+            void this.loadFits();
+            return;
+        }
+        this.loadImage();
+    }
+    loadImage() {
+        this._image = new Image();
         this._image.onload = () => this.imageLoaded();
         this._image.onerror = () => {
-            // console.error('File not found?', this._texurl)
             this._ready = false;
             this._abort = true;
             this.destroyIntervals();
         };
-        this._image.crossOrigin = 'anonymous';
+        this._image.crossOrigin = "anonymous";
         this._image.src = this._texurl;
     }
+    async loadFits() {
+        try {
+            this._fitsTile = await (0, FitsTileLoader_js_1.loadFitsTile)(this._texurl);
+            this._ready = true;
+        }
+        catch (error) {
+            console.error(`[Tile] Unable to load FITS tile ${this._texurl}`, error);
+            this._ready = false;
+            this._abort = true;
+            this.destroyIntervals();
+        }
+    }
     imageLoaded() {
         // this.textureLoaded()
         // this.initModelBuffer()
         // this._textureLoaded = true
         this._ready = true;
     }
-    // private textureLoaded(): void {
     textureLoaded(hipsShaderProgram) {
-        // this._hipsShaderProgram.enableProgram()
         hipsShaderProgram.enableProgram();
         const gl = this._webgl;
         this._texture = gl.createTexture();
         gl.activeTexture(gl.TEXTURE0 + this._hipsShaderIndex);
-        gl.pixelStorei(gl.UNPACK_FLIP_Y_WEBGL, true);
+        gl.pixelStorei(gl.UNPACK_FLIP_Y_WEBGL, this._format !== "fits");
         gl.bindTexture(gl.TEXTURE_2D, this._texture);
-        if (!gl.isTexture(this._texture)) {
-            console.log('error in texture');
+        if (this._format === "fits") {
+            const fits = this._fitsTile;
+            if (!fits) {
+                throw new Error(`FITS tile data not loaded: ${this._texurl}`);
+            }
+            gl.texImage2D(gl.TEXTURE_2D, 0, gl.R32F, fits.width, fits.height, 0, gl.RED, gl.FLOAT, fits.pixels);
+            gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.NEAREST);
+            gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.NEAREST);
+        }
+        else {
+            gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, gl.RGBA, gl.UNSIGNED_BYTE, this._image);
+            gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.LINEAR);
+            gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.LINEAR);
         }
-        gl.activeTexture(gl.TEXTURE0 + this._hipsShaderIndex);
-        gl.bindTexture(gl.TEXTURE_2D, this._texture);
-        gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, gl.RGBA, gl.UNSIGNED_BYTE, this._image);
         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.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.LINEAR);
-        gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.LINEAR);
-        // FIX: use the sampler location we fetched in enableShaders()
-        // gl.uniform1i((this._hipsShaderProgram.locations as ShaderLocations).sampler, this._hipsShaderIndex)
-        // gl.uniform1i((hipsShaderProgram.locations as ShaderLocations).sampler, this._hipsShaderIndex)
-        if (!gl.isTexture(this._texture)) {
-            console.warn('Texture creation failed');
-        }
         this.initModelBuffer();
         this._textureLoaded = true;
     }
@@ -13162,26 +13750,32 @@ class Tile {
                 this.vertexPosition[qidx][20 * p] = facesVec3Array[0].x;
                 this.vertexPosition[qidx][20 * p + 1] = facesVec3Array[0].y;
                 this.vertexPosition[qidx][20 * p + 2] = facesVec3Array[0].z;
-                this.vertexPosition[qidx][20 * p + 3] = step + step * uindex + s_pixel_size;
-                this.vertexPosition[qidx][20 * p + 4] = 1 - (step + step * vindex) - t_pixel_size;
+                this.vertexPosition[qidx][20 * p + 3] =
+                    step + step * uindex + s_pixel_size;
+                this.vertexPosition[qidx][20 * p + 4] =
+                    1 - (step + step * vindex) - t_pixel_size;
                 // v1
                 this.vertexPosition[qidx][20 * p + 5] = facesVec3Array[1].x;
                 this.vertexPosition[qidx][20 * p + 6] = facesVec3Array[1].y;
                 this.vertexPosition[qidx][20 * p + 7] = facesVec3Array[1].z;
-                this.vertexPosition[qidx][20 * p + 8] = step + step * uindex + s_pixel_size;
-                this.vertexPosition[qidx][20 * p + 9] = 1 - step * vindex + t_pixel_size;
+                this.vertexPosition[qidx][20 * p + 8] =
+                    step + step * uindex + s_pixel_size;
+                this.vertexPosition[qidx][20 * p + 9] =
+                    1 - step * vindex + t_pixel_size;
                 // v2
                 this.vertexPosition[qidx][20 * p + 10] = facesVec3Array[2].x;
                 this.vertexPosition[qidx][20 * p + 11] = facesVec3Array[2].y;
                 this.vertexPosition[qidx][20 * p + 12] = facesVec3Array[2].z;
                 this.vertexPosition[qidx][20 * p + 13] = step * uindex - s_pixel_size;
-                this.vertexPosition[qidx][20 * p + 14] = 1 - step * vindex + t_pixel_size;
+                this.vertexPosition[qidx][20 * p + 14] =
+                    1 - step * vindex + t_pixel_size;
                 // v3
                 this.vertexPosition[qidx][20 * p + 15] = facesVec3Array[3].x;
                 this.vertexPosition[qidx][20 * p + 16] = facesVec3Array[3].y;
                 this.vertexPosition[qidx][20 * p + 17] = facesVec3Array[3].z;
                 this.vertexPosition[qidx][20 * p + 18] = step * uindex - s_pixel_size;
-                this.vertexPosition[qidx][20 * p + 19] = 1 - (step + step * vindex) - t_pixel_size;
+                this.vertexPosition[qidx][20 * p + 19] =
+                    1 - (step + step * vindex) - t_pixel_size;
                 p++;
             }
         }
@@ -13189,6 +13783,32 @@ class Tile {
         gl.bindBuffer(gl.ARRAY_BUFFER, this.vertexPositionBuffer[qidx]);
         gl.bufferData(gl.ARRAY_BUFFER, this.vertexPosition[qidx], gl.STATIC_DRAW);
     }
+    getFitsDataRange() {
+        const hipsRange = this._hips.dataRange;
+        if (hipsRange.min !== undefined &&
+            hipsRange.max !== undefined &&
+            Number.isFinite(hipsRange.min) &&
+            Number.isFinite(hipsRange.max) &&
+            hipsRange.max > hipsRange.min) {
+            return {
+                min: hipsRange.min,
+                max: hipsRange.max,
+            };
+        }
+        const fits = this._fitsTile;
+        if (fits &&
+            fits.dataMin !== null &&
+            fits.dataMax !== null &&
+            Number.isFinite(fits.dataMin) &&
+            Number.isFinite(fits.dataMax) &&
+            fits.dataMax > fits.dataMin) {
+            return {
+                min: fits.dataMin,
+                max: fits.dataMax,
+            };
+        }
+        return null;
+    }
     get inView() {
         return this._inView;
     }
@@ -13203,7 +13823,9 @@ class Tile {
             this._ready = true;
         if (this._isGalacticHips) {
             if (this._visibleTileManager.galAncestorsMap.has(this._order)) {
-                if (!this._visibleTileManager.galAncestorsMap.get(this._order).includes(this._tileno)) {
+                if (!this._visibleTileManager.galAncestorsMap
+                    .get(this._order)
+                    .includes(this._tileno)) {
                     this.moveToCache();
                 }
                 else {
@@ -13235,7 +13857,9 @@ class Tile {
         }
         else {
             if (this._visibleTileManager.ancestorsMap.has(this._order)) {
-                if (!this._visibleTileManager.ancestorsMap.get(this._order).includes(this._tileno)) {
+                if (!this._visibleTileManager.ancestorsMap
+                    .get(this._order)
+                    .includes(this._tileno)) {
                     this.moveToCache();
                 }
                 else {
@@ -13281,33 +13905,40 @@ class Tile {
         }
         const gl = this._webgl;
         hipsShaderProgram.enableShaders(pMatrix, vMatrix, mMatrix, colorMapIdx);
-        // this._hipsShaderProgram.enableShaders(pMatrix, vMatrix, mMatrix, colorMapIdx)
-        // Enable attributes (these locations are retrieved in enableShaders)
-        // gl.enableVertexAttribArray(this._hipsShaderProgram.locations.vertexPositionAttribute)
-        // gl.enableVertexAttribArray(this._hipsShaderProgram.locations.textureCoordAttribute)
-        gl.enableVertexAttribArray(hipsShaderProgram.locations.vertexPositionAttribute);
-        gl.enableVertexAttribArray(hipsShaderProgram.locations.textureCoordAttribute);
+        if (this._format === "fits") {
+            const range = this.getFitsDataRange();
+            if (!range) {
+                console.error(`[Tile] No display range available for FITS tile ${this._texurl}`);
+                return;
+            }
+            hipsShaderProgram.setTextureDataMode(this._hipsShaderIndex, true, range.min, range.max);
+        }
+        else {
+            hipsShaderProgram.setTextureDataMode(this._hipsShaderIndex, false);
+        }
+        const locations = hipsShaderProgram.locations;
+        gl.enableVertexAttribArray(locations.vertexPositionAttribute);
+        gl.enableVertexAttribArray(locations.textureCoordAttribute);
         gl.activeTexture(gl.TEXTURE0 + this._hipsShaderIndex);
         gl.bindTexture(gl.TEXTURE_2D, this._texture);
-        // gl.uniform1f(this._hipsShaderProgram.locations.textureAlpha, this.opacity)
-        gl.uniform1f(hipsShaderProgram.locations.textureAlpha, this.opacity);
+        const factorLocation = locations.textureAlpha[this._hipsShaderIndex];
+        if (factorLocation) {
+            gl.uniform1f(factorLocation, 1.0);
+        }
+        hipsShaderProgram.setLayerOpacity(this._hips.opacity);
         gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, this.vertexIndexBuffer);
         const elemno = this.vertexIndices.length;
-        const indexType = this.vertexIndices instanceof Uint32Array ? gl.UNSIGNED_INT : gl.UNSIGNED_SHORT;
+        const indexType = this.vertexIndices instanceof Uint32Array
+            ? gl.UNSIGNED_INT
+            : gl.UNSIGNED_SHORT;
         quadrantsToDraw.forEach((qidx) => {
             gl.bindBuffer(gl.ARRAY_BUFFER, this.vertexPositionBuffer[qidx]);
-            gl.vertexAttribPointer(
-            // this._hipsShaderProgram.locations.vertexPositionAttribute,
-            hipsShaderProgram.locations.vertexPositionAttribute, 3, gl.FLOAT, false, 5 * 4, 0);
-            gl.vertexAttribPointer(
-            // this._hipsShaderProgram.locations.textureCoordAttribute,
-            hipsShaderProgram.locations.textureCoordAttribute, 2, gl.FLOAT, false, 5 * 4, 3 * 4);
+            gl.vertexAttribPointer(locations.vertexPositionAttribute, 3, gl.FLOAT, false, 5 * 4, 0);
+            gl.vertexAttribPointer(locations.textureCoordAttribute, 2, gl.FLOAT, false, 5 * 4, 3 * 4);
             gl.drawElements(gl.TRIANGLES, elemno, indexType, 0);
         });
-        // gl.disableVertexAttribArray(this._hipsShaderProgram.locations.vertexPositionAttribute)
-        // gl.disableVertexAttribArray(this._hipsShaderProgram.locations.textureCoordAttribute)
-        gl.disableVertexAttribArray(hipsShaderProgram.locations.vertexPositionAttribute);
-        gl.disableVertexAttribArray(hipsShaderProgram.locations.textureCoordAttribute);
+        gl.disableVertexAttribArray(locations.vertexPositionAttribute);
+        gl.disableVertexAttribArray(locations.textureCoordAttribute);
     }
     drawChildren(visibleOrder, visibleTilesMap, pMatrix, vMatrix, mMatrix, colorMapIdx, hipsShaderProgram) {
         const quadrantsToDraw = new Set([0, 1, 2, 3]);
@@ -13318,16 +13949,15 @@ class Tile {
             const childTileNo = (this._tileno << 2) + c;
             const list = visibleTilesMap.get(childrenOrder);
             if (list.includes(childTileNo)) {
+                if (!this._hips.intersectsCoverage(childrenOrder, childTileNo)) {
+                    continue;
+                }
                 const childTile = this._isGalacticHips
                     ? this._tileBuffer.getGalTile(childTileNo, childrenOrder, this._hips)
                     : this._tileBuffer.getTile(childTileNo, childrenOrder, this._hips);
-                // const childTile = this._isGalacticHips
-                //   ? newTileBuffer.getGalTile(childTileNo, childrenOrder, this._hips)
-                //   : newTileBuffer.getTile(childTileNo, childrenOrder, this._hips)
-                // childTile.draw(visibleOrder, visibleTilesMap, pMatrix, vMatrix, mMatrix, colorMapIdx)
                 childTile.draw(visibleOrder, visibleTilesMap, pMatrix, vMatrix, mMatrix, colorMapIdx, hipsShaderProgram);
-                if (childTile._ready) {
-                    quadrantsToDraw.delete(childTileNo - (this._tileno << 2));
+                if (childTile.getReadyState()) {
+                    quadrantsToDraw.delete(c);
                 }
             }
         }
@@ -13393,7 +14023,7 @@ class TileBuffer {
     /** Register an equatorial HiPS into the buffer. */
     addHiPS(hips) {
         if (this._activeHiPS.has(hips)) {
-            console.error('HiPS already present in TileBuffer');
+            console.error("HiPS already present in TileBuffer");
             return;
         }
         this._activeHiPS.set(hips, new Map());
@@ -13401,7 +14031,7 @@ class TileBuffer {
     /** Register a galactic HiPS into the buffer. */
     addGalHiPS(hips) {
         if (this._galActiveHiPS.has(hips)) {
-            console.error('HiPS already present in TileBuffer');
+            console.error("HiPS already present in TileBuffer");
             return;
         }
         this._galActiveHiPS.set(hips, new Map());
@@ -13412,6 +14042,9 @@ class TileBuffer {
             if (order > hips.maxOrder) {
                 continue;
             }
+            if (!hips.intersectsCoverage(order, tileno)) {
+                continue;
+            }
             this.getTile(tileno, order, hips);
         }
     }
@@ -13421,12 +14054,15 @@ class TileBuffer {
             if (order > hips.maxOrder) {
                 continue;
             }
+            if (!hips.intersectsCoverage(order, tileno)) {
+                continue;
+            }
             this.getGalTile(tileno, order, hips);
         }
     }
     /** Fetch (or create) an equatorial tile, reviving from cache if present. */
     getTile(tileno, order, hips) {
-        const tileKey = this.key(order, tileno, hips.baseURL);
+        const tileKey = this.key(order, tileno, hips);
         if (!this._tiles.has(tileKey)) {
             if (this._cachedTiles.has(tileKey)) {
                 const tile = this._cachedTiles.get(tileKey);
@@ -13444,7 +14080,7 @@ class TileBuffer {
     }
     /** Fetch (or create) a galactic tile, reviving from cache if present. */
     getGalTile(tileno, order, hips) {
-        const tileKey = this.key(order, tileno, hips.baseURL);
+        const tileKey = this.key(order, tileno, hips);
         if (!this._galTiles.has(tileKey)) {
             if (this._galCachedTiles.has(tileKey)) {
                 const tile = this._galCachedTiles.get(tileKey);
@@ -13462,7 +14098,7 @@ class TileBuffer {
     }
     /** Move a tile (equatorial or galactic) into cache. */
     moveTileToCache(tileno, order, hips) {
-        const tileKey = this.key(order, tileno, hips.baseURL);
+        const tileKey = this.key(order, tileno, hips);
         if (this._tiles.has(tileKey)) {
             const tile = this._tiles.get(tileKey);
             tile.setCacheTime0();
@@ -13481,29 +14117,64 @@ class TileBuffer {
         const now = Date.now();
         for (const [tileKey, tile] of this._cachedTiles) {
             const t0 = tile.cacheTime0;
-            if (!tile.inView && t0 !== undefined && now - t0 > this._cacheAliveMilliSeconds) {
+            if (!tile.inView &&
+                t0 !== undefined &&
+                now - t0 > this._cacheAliveMilliSeconds) {
                 tile.destroyIntervals();
                 this._cachedTiles.delete(tileKey);
             }
         }
         for (const [tileKey, tile] of this._galCachedTiles) {
             const t0 = tile.cacheTime0;
-            if (!tile.inView && t0 !== undefined && now - t0 > this._cacheAliveMilliSeconds) {
+            if (!tile.inView &&
+                t0 !== undefined &&
+                now - t0 > this._cacheAliveMilliSeconds) {
                 tile.destroyIntervals();
                 this._galCachedTiles.delete(tileKey);
             }
         }
     }
     /** Compose a stable key for maps. */
-    key(order, tileno, baseURL) {
-        return `${order}#${tileno}#${baseURL}`;
+    key(order, tileno, hips) {
+        return `${order}#${tileno}#${hips.baseURL}#${hips.format}`;
+    }
+    removeHiPS(hips) {
+        this.invalidateHiPS(hips);
+        this._activeHiPS.delete(hips);
+        this._galActiveHiPS.delete(hips);
+    }
+    /**
+     * Remove all active and cached tiles belonging to a specific HiPS.
+     *
+     * Tile keys contain the HiPS base URL and format. We intentionally
+     * ignore the format here so that a format change removes resources
+     * created with the previous format as well.
+     */
+    invalidateHiPS(hips) {
+        const belongsToHiPS = (tileKey) => tileKey.includes(`#${hips.baseURL}#`);
+        const clearTiles = (tiles) => {
+            for (const [tileKey, tile] of tiles) {
+                if (!belongsToHiPS(tileKey)) {
+                    continue;
+                }
+                tile.destroyIntervals();
+                tiles.delete(tileKey);
+            }
+        };
+        clearTiles(this._tiles);
+        clearTiles(this._cachedTiles);
+        clearTiles(this._galTiles);
+        clearTiles(this._galCachedTiles);
     }
     /** Optional: call to stop internal timers if you dispose this buffer. */
     dispose() {
         window.clearInterval(this._cleanerId);
     }
     get size() {
-        return this._tiles.size + this._cachedTiles.size + this._galTiles.size + this._galCachedTiles.size;
+        return (this._tiles.size +
+            this._cachedTiles.size +
+            this._galTiles.size +
+            this._galCachedTiles.size);
     }
     get activeTileCount() {
         return this._tiles.size + this._galTiles.size;
@@ -13581,11 +14252,8 @@ exports.VisibleTilesManager = void 0;
 const Global_js_1 = __importDefault(__webpack_require__(4382));
 const healpix_1 = __webpack_require__(4851);
 const RayPickingUtils_js_1 = __importDefault(__webpack_require__(4639));
-// import { newTileBuffer } from './TileBuffer.js';
 const TileBuffer_js_1 = __webpack_require__(4006);
 const gl_matrix_1 = __webpack_require__(3890);
-// import healpixGridSingleton from '../grid/HealpixGridSingleton.js';
-// import {HealpixGridSingleton} from '../grid/HealpixGridSingleton.js';
 const Config_js_1 = __webpack_require__(2919);
 class VisibleTilesManager {
     _visibleTilesByOrder;
@@ -13625,18 +14293,13 @@ class VisibleTilesManager {
     init(insideSphere) {
         this.initialised = true;
         this.insideSphere = insideSphere;
-        // this.computeVisiblePixels();
-        // setInterval(() => this.computeVisiblePixels(), 500);
     }
     getVisibleOrder() {
-        // return healpixGridSingleton.visibleorder;
         return this._healpixGrid.visibleorder;
     }
-    // computeVisiblePixels(): void {
     computeVisiblePixels(order, webgl, camera, pMatrix) {
         if (!this.initialised)
             return;
-        // let order = healpixGridSingleton.visibleorder;
         if (Global_js_1.default.insideSphere && order < 3) {
             order = 3;
         }
@@ -13656,8 +14319,6 @@ class VisibleTilesManager {
         }
         else {
             const geomhealpix = Global_js_1.default.getHealpix(order);
-            // const maxX = (global.gl as GL).canvas.width;
-            // const maxY = (global.gl as GL).canvas.height;
             const maxX = webgl.canvas.width;
             const maxY = webgl.canvas.height;
             // Sample a grid of screen points, project to the sphere, then to galactic
@@ -13677,13 +14338,11 @@ class VisibleTilesManager {
                         if (!pixels.includes(currPixNo)) {
                             pixels.push(currPixNo);
                             this._ancestorsMap.get(order).push(currPixNo);
-                            // newTileBuffer.addTile(order, currPixNo);
                             this._tileBuffer.addTile(order, currPixNo);
                         }
                         if (!galTiles.includes(galTileNo)) {
                             galTiles.push(galTileNo);
                             this._galAncestorsMap.get(order).push(galTileNo);
-                            // newTileBuffer.addGalTile(order, galTileNo);
                             this._tileBuffer.addGalTile(order, galTileNo);
                         }
                     }
@@ -13701,7 +14360,6 @@ class VisibleTilesManager {
                 const parent = pixels[p] >> (2 * o);
                 if (!list.includes(parent)) {
                     list.push(parent);
-                    // newTileBuffer.addTile(tgtOrder, parent);
                     this._tileBuffer.addTile(tgtOrder, parent);
                 }
             }
@@ -13714,7 +14372,6 @@ class VisibleTilesManager {
                 const parent = galTiles[p] >> (2 * o);
                 if (!list.includes(parent)) {
                     list.push(parent);
-                    // newTileBuffer.addGalTile(tgtOrder, parent);
                     this._tileBuffer.addGalTile(tgtOrder, parent);
                 }
             }
@@ -16078,7 +16735,7 @@ class HiPSShaderProgram {
     _UBO_colorMapVariableInfo = {
         r_palette: { index: 0, offset: 0 },
         g_palette: { index: 0, offset: 0 },
-        b_palette: { index: 0, offset: 0 }
+        b_palette: { index: 0, offset: 0 },
     };
     gl_uniforms;
     gl_attributes;
@@ -16087,54 +16744,68 @@ class HiPSShaderProgram {
     constructor(webgl) {
         this._webgl = webgl;
         this.gl_uniforms = {
-            sampler: 'uSampler0',
-            factor: 'uFactor0',
-            m_perspective: 'uPMatrix',
-            m_model: 'uMMatrix',
-            m_view: 'uVMatrix',
-            colormapIdx: 'cmapIdx',
-            colormap_red: 'r',
-            colormap_green: 'g',
-            colormap_blue: 'b'
+            sampler: "uSampler0",
+            factor: "uFactor0",
+            m_perspective: "uPMatrix",
+            m_model: "uMMatrix",
+            m_view: "uVMatrix",
+            colormapIdx: "cmapIdx",
+            colormap_red: "r",
+            colormap_green: "g",
+            colormap_blue: "b",
+            textureMode: "uTextureMode",
+            dataMin: "uDataMin",
+            dataMax: "uDataMax",
         };
         this.gl_attributes = {
-            vertex_pos: 'aVertexPosition',
-            text_coords: 'aTextureCoord'
+            vertex_pos: "aVertexPosition",
+            text_coords: "aTextureCoord",
         };
         this.locations = {
             pMatrix: null,
             mMatrix: null,
             vMatrix: null,
-            sampler: null,
-            textureAlpha: null,
+            samplers: new Array(8).fill(null),
+            textureAlpha: new Array(8).fill(null),
+            textureMode: new Array(8).fill(null),
+            dataMin: new Array(8).fill(null),
+            dataMax: new Array(8).fill(null),
+            layerOpacity: null,
             clorMapIdx: null,
             vertexPositionAttribute: -1,
-            textureCoordAttribute: -1
+            textureCoordAttribute: -1,
         };
     }
     get shaderProgram() {
         const gl = this._webgl;
         if (!this._shaderProgram) {
-            // const gl = global.gl as GL
-            this._shaderProgram = gl.createProgram();
-            this.initShaders();
+            const program = gl.createProgram();
+            this._shaderProgram = program;
+            this.initShaders(program);
         }
-        ;
         gl.useProgram(this._shaderProgram);
         return this._shaderProgram;
     }
+    setLayerOpacity(opacity) {
+        const gl = this._webgl;
+        this.locations.layerOpacity = gl.getUniformLocation(this.shaderProgram, "uLayerOpacity");
+        if (this.locations.layerOpacity !== null) {
+            gl.uniform1f(this.locations.layerOpacity, opacity);
+        }
+    }
     setRuntimeColorMap(colorMap) {
         this._runtimeColorMap = colorMap;
     }
-    initShaders() {
-        // const gl = global.gl as GL
+    initShaders(program) {
+        // const gl = global.gl
         const gl = this._webgl;
         const fragmentShaderStr = ShaderManager_js_1.default.hipsNativeFS();
         this._fragmentShader = gl.createShader(gl.FRAGMENT_SHADER);
         gl.shaderSource(this._fragmentShader, fragmentShaderStr);
         gl.compileShader(this._fragmentShader);
         if (!gl.getShaderParameter(this._fragmentShader, gl.COMPILE_STATUS)) {
-            alert(gl.getShaderInfoLog(this._fragmentShader) || 'Fragment shader compile error');
+            alert(gl.getShaderInfoLog(this._fragmentShader) ||
+                "Fragment shader compile error");
             return;
         }
         const vertexShaderStr = ShaderManager_js_1.default.hipsVS();
@@ -16142,43 +16813,44 @@ class HiPSShaderProgram {
         gl.shaderSource(this._vertexShader, vertexShaderStr);
         gl.compileShader(this._vertexShader);
         if (!gl.getShaderParameter(this._vertexShader, gl.COMPILE_STATUS)) {
-            alert(gl.getShaderInfoLog(this._vertexShader) || 'Vertex shader compile error');
+            alert(gl.getShaderInfoLog(this._vertexShader) ||
+                "Vertex shader compile error");
             return;
         }
-        gl.attachShader(this._shaderProgram, this._vertexShader);
-        gl.attachShader(this._shaderProgram, this._fragmentShader);
-        gl.linkProgram(this._shaderProgram);
-        if (!gl.getProgramParameter(this._shaderProgram, gl.LINK_STATUS)) {
-            alert('Could not initialise shaders');
+        gl.attachShader(program, this._vertexShader);
+        gl.attachShader(program, this._fragmentShader);
+        gl.linkProgram(program);
+        if (!gl.getProgramParameter(program, gl.LINK_STATUS)) {
+            alert("Could not initialise shaders");
         }
     }
     enableProgram() {
-        // (global.gl as GL).useProgram(this._shaderProgram as WebGLProgram)
+        // (global.gl).useProgram(this._shaderProgram)
         this._webgl.useProgram(this.shaderProgram);
     }
     setGrayscaleShader() {
-        // const gl = global.gl as GL
+        // const gl = global.gl
         const gl = this._webgl;
         gl.detachShader(this.shaderProgram, this._fragmentShader);
         const fragmentShaderStr = ShaderManager_js_1.default.hipsGrayscaleFS();
         this.changeFSShader(fragmentShaderStr);
     }
     setNativeShader() {
-        // const gl = global.gl as GL
+        // const gl = global.gl
         const gl = this._webgl;
         gl.detachShader(this.shaderProgram, this._fragmentShader);
         const fragmentShaderStr = ShaderManager_js_1.default.hipsNativeFS();
         this.changeFSShader(fragmentShaderStr);
     }
     setColorMapShader() {
-        // const gl = global.gl as GL
+        // const gl = global.gl
         const gl = this._webgl;
         // Swap fragment shader
         gl.detachShader(this.shaderProgram, this._fragmentShader);
         const fragmentShaderStr = ShaderManager_js_1.default.hipsColorMapFS();
         this.changeFSShader(fragmentShaderStr);
         // UBO discovery for the "colormap" block
-        const blockIndex = gl.getUniformBlockIndex(this.shaderProgram, 'colormap');
+        const blockIndex = gl.getUniformBlockIndex(this.shaderProgram, "colormap");
         // INVALID_INDEX == 0xFFFFFFFF in WebGL2
         if (blockIndex === gl.INVALID_INDEX) {
             console.warn('HiPSShaderProgram: uniform block "colormap" not found in hipsColorMapFS()');
@@ -16188,11 +16860,11 @@ class HiPSShaderProgram {
         }
         this._colorMapBlockIndex = blockIndex;
         // const blockSize = gl.getActiveUniformBlockParameter(
-        //   this.shaderProgram as WebGLProgram,
+        //   this.shaderProgram,
         //   blockIndex,
         //   gl.UNIFORM_BLOCK_DATA_SIZE
         // ) as number
-        const uboVariableNames = ['r_palette', 'g_palette', 'b_palette'];
+        const uboVariableNames = ["r_palette", "g_palette", "b_palette"];
         const uboVariableIndices = gl.getUniformIndices(this.shaderProgram, uboVariableNames);
         const uboVariableOffsets = gl.getActiveUniforms(this.shaderProgram, uboVariableIndices, gl.UNIFORM_OFFSET);
         // Create buffer only once
@@ -16209,49 +16881,80 @@ class HiPSShaderProgram {
         uboVariableNames.forEach((name, index) => {
             this._UBO_colorMapVariableInfo[name] = {
                 index: uboVariableIndices[index],
-                offset: uboVariableOffsets[index]
+                offset: uboVariableOffsets[index],
             };
         });
     }
     changeFSShader(fragmentShaderStr) {
-        // const gl = global.gl as GL
+        // const gl = global.gl
         const gl = this._webgl;
         this._fragmentShader = gl.createShader(gl.FRAGMENT_SHADER);
         gl.shaderSource(this._fragmentShader, fragmentShaderStr);
         gl.compileShader(this._fragmentShader);
         if (!gl.getShaderParameter(this._fragmentShader, gl.COMPILE_STATUS)) {
-            alert(gl.getShaderInfoLog(this._fragmentShader) || 'Fragment shader compile error');
+            alert(gl.getShaderInfoLog(this._fragmentShader) ||
+                "Fragment shader compile error");
             return;
         }
         gl.attachShader(this.shaderProgram, this._fragmentShader);
         gl.linkProgram(this.shaderProgram);
         if (!gl.getProgramParameter(this.shaderProgram, gl.LINK_STATUS)) {
-            alert('Could not initialise shaders');
+            alert("Could not initialise shaders");
         }
         gl.useProgram(this.shaderProgram);
     }
+    setTextureDataMode(samplerIndex, fits, min, max) {
+        if (samplerIndex < 0 || samplerIndex >= 8) {
+            throw new Error(`Invalid HiPS sampler index: ${samplerIndex}`);
+        }
+        const gl = this._webgl;
+        const modeLocation = this.locations.textureMode[samplerIndex];
+        if (modeLocation) {
+            gl.uniform1i(modeLocation, fits ? 1 : 0);
+        }
+        if (!fits) {
+            return;
+        }
+        if (min === undefined ||
+            max === undefined ||
+            !Number.isFinite(min) ||
+            !Number.isFinite(max) ||
+            max <= min) {
+            throw new Error("Invalid FITS display range.");
+        }
+        const minLocation = this.locations.dataMin[samplerIndex];
+        const maxLocation = this.locations.dataMax[samplerIndex];
+        if (minLocation) {
+            gl.uniform1f(minLocation, min);
+        }
+        if (maxLocation) {
+            gl.uniform1f(maxLocation, max);
+        }
+    }
     enableShaders(pMatrix, vMatrix, mMatrix, colorMapIdx) {
-        // const gl = global.gl as GL
+        // const gl = global.gl
         const gl = this._webgl;
         gl.useProgram(this.shaderProgram);
         this.locations.pMatrix = gl.getUniformLocation(this.shaderProgram, this.gl_uniforms.m_perspective);
         this.locations.mMatrix = gl.getUniformLocation(this.shaderProgram, this.gl_uniforms.m_model);
         this.locations.vMatrix = gl.getUniformLocation(this.shaderProgram, this.gl_uniforms.m_view);
-        this.locations.sampler = gl.getUniformLocation(this.shaderProgram, this.gl_uniforms.sampler);
-        this.locations.textureAlpha = gl.getUniformLocation(this.shaderProgram, this.gl_uniforms.factor);
         this.locations.clorMapIdx = gl.getUniformLocation(this.shaderProgram, this.gl_uniforms.colormapIdx);
-        // NEW
-        // if (this.locations.clorMapIdx) {
-        gl.uniform1i(this.locations.clorMapIdx, colorMapIdx);
-        // }
-        // Make sampler explicit: we always use TEXTURE0 in your draw code
-        if (this.locations.sampler) {
-            gl.uniform1i(this.locations.sampler, 0);
+        for (let i = 0; i < 8; i++) {
+            this.locations.samplers[i] = gl.getUniformLocation(this.shaderProgram, `uSampler${i}`);
+            this.locations.textureAlpha[i] = gl.getUniformLocation(this.shaderProgram, `uFactor${i}`);
+            this.locations.textureMode[i] = gl.getUniformLocation(this.shaderProgram, `uTextureMode${i}`);
+            this.locations.dataMin[i] = gl.getUniformLocation(this.shaderProgram, `uDataMin${i}`);
+            this.locations.dataMax[i] = gl.getUniformLocation(this.shaderProgram, `uDataMax${i}`);
+            if (this.locations.samplers[i]) {
+                gl.uniform1i(this.locations.samplers[i], i);
+            }
         }
-        // END NEW
+        gl.uniform1i(this.locations.clorMapIdx, colorMapIdx);
         this.locations.vertexPositionAttribute = gl.getAttribLocation(this.shaderProgram, this.gl_attributes.vertex_pos);
         this.locations.textureCoordAttribute = gl.getAttribLocation(this.shaderProgram, this.gl_attributes.text_coords);
-        if (colorMapIdx >= 2 && this._UBO_colorMapBuffer && this._colorMapBlockIndex !== null) {
+        if (colorMapIdx >= 2 &&
+            this._UBO_colorMapBuffer &&
+            this._colorMapBlockIndex !== null) {
             gl.uniformBlockBinding(this.shaderProgram, this._colorMapBlockIndex, 0);
             gl.bindBuffer(gl.UNIFORM_BUFFER, this._UBO_colorMapBuffer);
             let currentColorMap;
@@ -16624,15 +17327,7 @@ class ShaderManager {
 
     in vec2 vTextureCoord;
 
-    uniform sampler2D uSampler0;
-    uniform sampler2D uSampler1;
-    uniform sampler2D uSampler2;
-    uniform sampler2D uSampler3;
-    uniform sampler2D uSampler4;
-    uniform sampler2D uSampler5;
-    uniform sampler2D uSampler6;
-    uniform sampler2D uSampler7;
-
+    uniform float uLayerOpacity;
     uniform float uFactor0;
     uniform float uFactor1;
     uniform float uFactor2;
@@ -16642,24 +17337,54 @@ class ShaderManager {
     uniform float uFactor6;
     uniform float uFactor7;
 
+    ${ShaderManager.hipsSamplersGLSL()}
+
     out vec4 fragColor;
 
     void main() {
       vec3 finalColor = vec3(0.0);
 
-      if (uFactor0 >= 0.0){
-        vec4 mycolor;
-        #if __VERSION__ > 120
-          vec4 color0 = texture(uSampler0, vTextureCoord);
-        #else
-          vec4 color0 = texture2D(uSampler0, vTextureCoord);
-        #endif
-        mycolor = color0;
-        finalColor += mycolor.rgb * uFactor0;
-      } else if (uFactor7 >= 0.0){
-        finalColor = vec3(1.0, 0.0, 0.0);
+      if (uFactor0 >= 0.0) {
+        finalColor +=
+          sampleHiPSTexture0(vTextureCoord).rgb * uFactor0;
+      }
+
+      if (uFactor1 >= 0.0) {
+        finalColor +=
+          sampleHiPSTexture1(vTextureCoord).rgb * uFactor1;
+      }
+
+      if (uFactor2 >= 0.0) {
+        finalColor +=
+          sampleHiPSTexture2(vTextureCoord).rgb * uFactor2;
+      }
+
+      if (uFactor3 >= 0.0) {
+        finalColor +=
+          sampleHiPSTexture3(vTextureCoord).rgb * uFactor3;
+      }
+
+      if (uFactor4 >= 0.0) {
+        finalColor +=
+          sampleHiPSTexture4(vTextureCoord).rgb * uFactor4;
+      }
+
+      if (uFactor5 >= 0.0) {
+        finalColor +=
+          sampleHiPSTexture5(vTextureCoord).rgb * uFactor5;
+      }
+
+      if (uFactor6 >= 0.0) {
+        finalColor +=
+          sampleHiPSTexture6(vTextureCoord).rgb * uFactor6;
+      }
+
+      if (uFactor7 >= 0.0) {
+        finalColor +=
+          sampleHiPSTexture7(vTextureCoord).rgb * uFactor7;
       }
-      fragColor = vec4(finalColor, 1.0);
+
+      fragColor = vec4(finalColor, uLayerOpacity);
     }`;
     }
     static hipsGrayscaleFS() {
@@ -16668,15 +17393,7 @@ class ShaderManager {
 
     in vec2 vTextureCoord;
 
-    uniform sampler2D uSampler0;
-    uniform sampler2D uSampler1;
-    uniform sampler2D uSampler2;
-    uniform sampler2D uSampler3;
-    uniform sampler2D uSampler4;
-    uniform sampler2D uSampler5;
-    uniform sampler2D uSampler6;
-    uniform sampler2D uSampler7;
-
+    uniform float uLayerOpacity;
     uniform float uFactor0;
     uniform float uFactor1;
     uniform float uFactor2;
@@ -16686,117 +17403,206 @@ class ShaderManager {
     uniform float uFactor6;
     uniform float uFactor7;
 
+    ${ShaderManager.hipsSamplersGLSL()}
+
     out vec4 fragColor;
 
     void main() {
       vec3 finalColor = vec3(0.0);
 
-      if (uFactor0 >= 0.0){
-        #if __VERSION__ > 120
-          vec4 color0 = texture(uSampler0, vTextureCoord);
-        #else
-          vec4 color0 = texture2D(uSampler0, vTextureCoord);
-        #endif
-        float gray = 0.21 * color0.r + 0.71 * color0.g + 0.07 * color0.b;
-        finalColor = color0.rgb * (1.0 - uFactor0) + vec3(gray) * uFactor0;
+      if (uFactor0 >= 0.0) {
+        vec4 color0 = sampleHiPSTexture0(vTextureCoord);
+
+        float gray =
+          0.21 * color0.r +
+          0.71 * color0.g +
+          0.07 * color0.b;
+
+        finalColor =
+          color0.rgb * (1.0 - uFactor0) +
+          vec3(gray) * uFactor0;
       }
-      if (uFactor1 >= 0.0){
-        #if __VERSION__ > 120
-          vec4 color1 = texture(uSampler1, vTextureCoord);
-        #else
-          vec4 color1 = texture2D(uSampler1, vTextureCoord);
-        #endif
+
+      if (uFactor1 >= 0.0) {
+        vec4 color1 = sampleHiPSTexture1(vTextureCoord);
         finalColor += color1.rgb * uFactor1;
       }
-      if (uFactor2 >= 0.0){
-        #if __VERSION__ > 120
-          vec4 color2 = texture(uSampler2, vTextureCoord);
-        #else
-          vec4 color2 = texture2D(uSampler2, vTextureCoord);
-        #endif
+
+      if (uFactor2 >= 0.0) {
+        vec4 color2 = sampleHiPSTexture2(vTextureCoord);
         finalColor += color2.rgb * uFactor2;
       }
-      if (uFactor3 >= 0.0){
-        #if __VERSION__ > 120
-          vec4 color3 = texture(uSampler3, vTextureCoord);
-        #else
-          vec4 color3 = texture2D(uSampler3, vTextureCoord);
-        #endif
+
+      if (uFactor3 >= 0.0) {
+        vec4 color3 = sampleHiPSTexture3(vTextureCoord);
         finalColor += color3.rgb * uFactor3;
       }
-      if (uFactor4 >= 0.0){
-        #if __VERSION__ > 120
-          vec4 color4 = texture(uSampler4, vTextureCoord);
-        #else
-          vec4 color4 = texture2D(uSampler4, vTextureCoord);
-        #endif
+
+      if (uFactor4 >= 0.0) {
+        vec4 color4 = sampleHiPSTexture4(vTextureCoord);
         finalColor += color4.rgb * uFactor4;
       }
-      if (uFactor5 >= 0.0){
-        #if __VERSION__ > 120
-          vec4 color5 = texture(uSampler5, vTextureCoord);
-        #else
-          vec4 color5 = texture2D(uSampler5, vTextureCoord);
-        #endif
+
+      if (uFactor5 >= 0.0) {
+        vec4 color5 = sampleHiPSTexture5(vTextureCoord);
         finalColor += color5.rgb * uFactor5;
       }
-      if (uFactor6 >= 0.0){
-        #if __VERSION__ > 120
-          vec4 color6 = texture(uSampler6, vTextureCoord);
-        #else
-          vec4 color6 = texture2D(uSampler6, vTextureCoord);
-        #endif
+
+      if (uFactor6 >= 0.0) {
+        vec4 color6 = sampleHiPSTexture6(vTextureCoord);
         finalColor += color6.rgb * uFactor6;
       }
-      if (uFactor7 >= 0.0){
-        #if __VERSION__ > 120
-          vec4 color7 = texture(uSampler7, vTextureCoord);
-        #else
-          vec4 color7 = texture2D(uSampler7, vTextureCoord);
-        #endif
+
+      if (uFactor7 >= 0.0) {
+        vec4 color7 = sampleHiPSTexture7(vTextureCoord);
         finalColor += color7.rgb * uFactor7;
       }
-      fragColor = vec4(finalColor, 1.0);
+
+      fragColor = vec4(finalColor, uLayerOpacity);
     }`;
     }
     static hipsColorMapFS() {
         return `#version 300 es
     precision mediump float;
 
+    uniform float uLayerOpacity;
+
     in vec2 vTextureCoord;
 
-    // UBO
     layout (std140) uniform colormap {
       float r_palette[256];
       float g_palette[256];
       float b_palette[256];
     };
 
-    uniform sampler2D uSampler0;
     uniform float uFactor0;
+    uniform float uFactor1;
+    uniform float uFactor2;
+    uniform float uFactor3;
+    uniform float uFactor4;
+    uniform float uFactor5;
+    uniform float uFactor6;
+    uniform float uFactor7;
+
+    ${ShaderManager.hipsSamplersGLSL()}
 
     out vec4 fragColor;
 
-    void main() {
-      #if __VERSION__ > 120
-        vec4 color0 = texture(uSampler0, vTextureCoord);
-      #else
-        vec4 color0 = texture2D(uSampler0, vTextureCoord);
-      #endif
+    vec3 applyColorMap(vec4 color) {
+      int x = int(clamp(color.r, 0.0, 1.0) * 255.0);
+      int y = int(clamp(color.g, 0.0, 1.0) * 255.0);
+      int z = int(clamp(color.b, 0.0, 1.0) * 255.0);
 
-      int x = int(color0.r * 255.0);
       float px = r_palette[x] / 256.0;
-
-      int y = int(color0.g * 255.0);
       float py = g_palette[y] / 256.0;
-
-      int z = int(color0.b * 255.0);
       float pz = b_palette[z] / 256.0;
 
-      // uFactor0 reserved for future blending if needed
-      fragColor = vec4(px, py, pz, 1.0);
+      return vec3(px, py, pz);
+    }
+
+    void main() {
+      vec3 finalColor = vec3(0.0);
+
+      if (uFactor0 >= 0.0) {
+        finalColor +=
+          applyColorMap(
+            sampleHiPSTexture0(vTextureCoord)
+          ) * uFactor0;
+      }
+
+      if (uFactor1 >= 0.0) {
+        finalColor +=
+          applyColorMap(
+            sampleHiPSTexture1(vTextureCoord)
+          ) * uFactor1;
+      }
+
+      if (uFactor2 >= 0.0) {
+        finalColor +=
+          applyColorMap(
+            sampleHiPSTexture2(vTextureCoord)
+          ) * uFactor2;
+      }
+
+      if (uFactor3 >= 0.0) {
+        finalColor +=
+          applyColorMap(
+            sampleHiPSTexture3(vTextureCoord)
+          ) * uFactor3;
+      }
+
+      if (uFactor4 >= 0.0) {
+        finalColor +=
+          applyColorMap(
+            sampleHiPSTexture4(vTextureCoord)
+          ) * uFactor4;
+      }
+
+      if (uFactor5 >= 0.0) {
+        finalColor +=
+          applyColorMap(
+            sampleHiPSTexture5(vTextureCoord)
+          ) * uFactor5;
+      }
+
+      if (uFactor6 >= 0.0) {
+        finalColor +=
+          applyColorMap(
+            sampleHiPSTexture6(vTextureCoord)
+          ) * uFactor6;
+      }
+
+      if (uFactor7 >= 0.0) {
+        finalColor +=
+          applyColorMap(
+            sampleHiPSTexture7(vTextureCoord)
+          ) * uFactor7;
+      }
+
+      fragColor = vec4(finalColor, uLayerOpacity);
     }`;
     }
+    static hipsSamplerGLSL(index) {
+        return `
+    uniform sampler2D uSampler${index};
+    uniform int uTextureMode${index};
+    uniform float uDataMin${index};
+    uniform float uDataMax${index};
+
+    vec4 sampleHiPSTexture${index}(vec2 uv) {
+      vec4 color = texture(uSampler${index}, uv);
+
+      // JPG / PNG
+      if (uTextureMode${index} == 0) {
+        return color;
+      }
+
+      // FITS physical value stored in red channel
+      float value = color.r;
+
+      if (isnan(value)) {
+        discard;
+      }
+
+      float normalized = clamp(
+        (value - uDataMin${index}) /
+        (uDataMax${index} - uDataMin${index}),
+        0.0,
+        1.0
+      );
+
+      return vec4(
+        normalized,
+        normalized,
+        normalized,
+        1.0
+      );
+    }
+  `;
+    }
+    static hipsSamplersGLSL() {
+        return Array.from({ length: 8 }, (_, index) => ShaderManager.hipsSamplerGLSL(index)).join("\n");
+    }
 }
 exports["default"] = ShaderManager;
 
@@ -18469,27 +19275,76 @@ exports["default"] = XYZRayPickingUtils;
 
 /***/ },
 
-/***/ 4851
-(__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) {
+/***/ 8611
+(module) {
 
+module.exports = require("http");
 
-// EXPORTS
-__webpack_require__.d(__webpack_exports__, {
-  Healpix: () => (/* reexport */ Healpix),
-  Pointing: () => (/* reexport */ Pointing),
-  Vec3: () => (/* reexport */ Vec3)
-});
+/***/ },
 
-// UNUSED EXPORTS: Hploc, RangeSet
+/***/ 5692
+(module) {
 
-;// ./node_modules/astrospatial-core/lib-esm/healpix/vec3.js
-class Vec3 {
-    x;
-    y;
-    z;
-    constructor(x, y, z) {
-        if (![x, y, z].every(Number.isFinite)) {
-            throw new RangeError("Vec3 coordinates must be finite numbers.");
+module.exports = require("https");
+
+/***/ },
+
+/***/ 1455
+(module) {
+
+module.exports = require("node:fs/promises");
+
+/***/ },
+
+/***/ 4876
+(module) {
+
+module.exports = require("punycode");
+
+/***/ },
+
+/***/ 2203
+(module) {
+
+module.exports = require("stream");
+
+/***/ },
+
+/***/ 7016
+(module) {
+
+module.exports = require("url");
+
+/***/ },
+
+/***/ 3106
+(module) {
+
+module.exports = require("zlib");
+
+/***/ },
+
+/***/ 4851
+(__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) {
+
+
+// EXPORTS
+__webpack_require__.d(__webpack_exports__, {
+  Healpix: () => (/* reexport */ Healpix),
+  Pointing: () => (/* reexport */ Pointing),
+  Vec3: () => (/* reexport */ Vec3)
+});
+
+// UNUSED EXPORTS: Hploc, RangeSet
+
+;// ./node_modules/astrospatial-core/lib-esm/healpix/vec3.js
+class Vec3 {
+    x;
+    y;
+    z;
+    constructor(x, y, z) {
+        if (![x, y, z].every(Number.isFinite)) {
+            throw new RangeError("Vec3 coordinates must be finite numbers.");
         }
         this.x = x;
         this.y = y;
@@ -19265,6 +20120,1621 @@ function findCircleThroughTwoPoints(points, q1, q2) {
 
 
 
+/***/ },
+
+/***/ 4971
+(__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) {
+
+
+// EXPORTS
+__webpack_require__.d(__webpack_exports__, {
+  BinaryTableHDU: () => (/* reexport */ BinaryTableHDU),
+  FITSHeaderManager: () => (/* reexport */ FITSHeaderManager),
+  FITSParser: () => (/* reexport */ FITSParser)
+});
+
+// UNUSED EXPORTS: AsciiTableHDU, FITSFile, FITSHDU, FITSHeaderItem, FITSWriter, ImageHDU, ParseHeader, ParsePayload, PrimaryHDU
+
+;// ./node_modules/jsfitsio/lib-esm/model/FITSHeaderItem.js
+/**
+ * Summary. (bla bla bla)
+ *
+ * Description. (bla bla bla)
+ *
+ * @link   github https://github.com/fab77/FITSParser
+ * @author Fabrizio Giordano <fabriziogiordano77@gmail.com>
+ */
+class FITSHeaderItem {
+    _key = "";
+    _value = "";
+    _comment = "";
+    constructor(key, value, comment) {
+        this._key = key;
+        this._value = value;
+        this._comment = comment;
+    }
+    get key() {
+        return this._key;
+    }
+    get comment() {
+        return this._comment;
+    }
+    get value() {
+        return this._value;
+    }
+}
+//# sourceMappingURL=FITSHeaderItem.js.map
+;// ./node_modules/jsfitsio/lib-esm/model/FITSHeaderManager.js
+
+class FITSHeaderManager {
+    static SIMPLE = "SIMPLE";
+    static BITPIX = "BITPIX";
+    static BZERO = "BZERO";
+    static BSCALE = "BSCALE";
+    static BLANK = "BLANK";
+    static NAXIS = "NAXIS";
+    static NAXIS1 = "NAXIS1";
+    static NAXIS2 = "NAXIS2";
+    static DATAMIN = "DATAMIN";
+    static DATAMAX = "DATAMAX";
+    static CRVAL1 = "CRVAL1";
+    static CRVAL2 = "CRVAL2";
+    static CTYPE1 = "CTYPE1";
+    static CTYPE2 = "CTYPE2";
+    static CRPIX1 = "CRPIX1";
+    static CRPIX2 = "CRPIX2";
+    static ORIGIN = "ORIGIN";
+    static COMMENT = "COMMENT";
+    static XTENSION = "XTENSION";
+    static PCOUNT = "PCOUNT";
+    static GCOUNT = "GCOUNT";
+    static TFIELDS = "TFIELDS";
+    static TFORM = "TFORM";
+    static TTYPE = "TTYPE";
+    static TUNIT = "TUNIT";
+    static TSCAL = "TSCAL";
+    static TZERO = "TZERO";
+    static TNULL = "TNULL";
+    static TBCOL = "TBCOL";
+    items = [];
+    constructor(initializeDefaults = true) {
+        if (!initializeDefaults) {
+            return;
+        }
+        this.items[0] = new FITSHeaderItem(FITSHeaderManager.SIMPLE, "T", "");
+        this.items[1] = new FITSHeaderItem(FITSHeaderManager.BITPIX, "", "");
+        this.items[2] = new FITSHeaderItem(FITSHeaderManager.NAXIS, 2, "");
+        this.items[3] = new FITSHeaderItem(FITSHeaderManager.NAXIS1, "", "");
+        this.items[4] = new FITSHeaderItem(FITSHeaderManager.NAXIS2, "", "");
+    }
+    // insert(item: FITSHeaderItem, position?: number): void {
+    insert(item) {
+        if (item.key === FITSHeaderManager.SIMPLE) {
+            // this.items.splice(0, 0, item);
+            this.items[0] = item;
+        }
+        else if (item.key === FITSHeaderManager.BITPIX) {
+            // this.items.splice(1, 0, item);
+            this.items[1] = item;
+        }
+        else if (item.key === FITSHeaderManager.NAXIS) {
+            // this.items.splice(2, 0, item);
+            this.items[2] = item;
+        }
+        else if (item.key === FITSHeaderManager.NAXIS1) {
+            // this.items.splice(3, 0, item);
+            this.items[3] = item;
+        }
+        else if (item.key === FITSHeaderManager.NAXIS2) {
+            // this.items.splice(4, 0, item);
+            this.items[4] = item;
+        }
+        else {
+            this.items.push(item);
+        }
+        // if (position !== undefined && position >= 0 && position <= this.items.length) {
+        //     this.items.splice(position, 0, item);
+        // } else {
+        //     this.items.push(item);
+        // }
+    }
+    getItems() {
+        return this.items;
+    }
+    remove(key) {
+        this.items = this.items.filter((item) => item.key !== key);
+    }
+    findById(key) {
+        const item = this.items.find((item) => item.key === key);
+        if (!item) {
+            return null;
+        }
+        return item;
+    }
+    static tableFieldKey(prefix, index) {
+        if (!Number.isInteger(index) || index < 1) {
+            throw new RangeError(`FITS table field index must be >= 1, received ${index}.`);
+        }
+        return `${prefix}${index}`;
+    }
+    static naxisKey(axis) {
+        if (!Number.isInteger(axis) || axis < 1) {
+            throw new RangeError(`FITS axis must be a positive integer, received ${axis}.`);
+        }
+        return `NAXIS${axis}`;
+    }
+    static getFITSItemStringValue(header, key) {
+        const item = header.findById(key);
+        if (!item) {
+            return null;
+        }
+        return String(item.value).trim().replace(/^'/, "").replace(/'$/, "").trim();
+    }
+}
+//# sourceMappingURL=FITSHeaderManager.js.map
+;// external "fs"
+const external_fs_namespaceObject = require("fs");
+;// ./node_modules/jsfitsio/lib-esm/FITSHeaderWriter.js
+class FITSHeaderWriter {
+    static BLOCK_SIZE = 2880;
+    static CARD_SIZE = 80;
+    static INTEGER_KEYWORDS = new Set([
+        "BITPIX",
+        "NAXIS",
+        "PCOUNT",
+        "GCOUNT",
+    ]);
+    static LOGICAL_KEYWORDS = new Set(["SIMPLE", "EXTEND"]);
+    static serialize(header, primary) {
+        const items = header.getItems();
+        const map = new Map(items.map((item) => [item.key.toUpperCase(), item]));
+        const cards = [];
+        FITSHeaderWriter.appendMandatoryCards(cards, map, primary);
+        FITSHeaderWriter.appendRemainingCards(cards, items);
+        cards.push(FITSHeaderWriter.card80("END"));
+        return FITSHeaderWriter.encodeAndPad(cards);
+    }
+    static appendMandatoryCards(cards, map, primary) {
+        if (primary) {
+            const simple = map.get("SIMPLE");
+            if (!simple) {
+                throw new Error("Missing mandatory SIMPLE card in Primary HDU");
+            }
+            cards.push(...FITSHeaderWriter.makeKeywordWithComment("SIMPLE", simple.value, simple.comment));
+        }
+        else {
+            const xtension = map.get("XTENSION");
+            if (!xtension) {
+                throw new Error("Missing mandatory XTENSION card in extension HDU");
+            }
+            cards.push(...FITSHeaderWriter.makeKeywordWithComment("XTENSION", xtension.value, xtension.comment));
+        }
+        const bitpix = map.get("BITPIX");
+        if (!bitpix) {
+            throw new Error("Missing mandatory BITPIX card");
+        }
+        cards.push(...FITSHeaderWriter.makeKeywordWithComment("BITPIX", bitpix.value, bitpix.comment));
+        const naxis = map.get("NAXIS");
+        if (!naxis) {
+            throw new Error("Missing mandatory NAXIS card");
+        }
+        const nAxes = Number(naxis.value);
+        if (!Number.isInteger(nAxes) || nAxes < 0) {
+            throw new Error(`Invalid NAXIS value: ${naxis.value}`);
+        }
+        cards.push(...FITSHeaderWriter.makeKeywordWithComment("NAXIS", nAxes, naxis.comment));
+        for (let axis = 1; axis <= nAxes; axis++) {
+            const key = `NAXIS${axis}`;
+            const item = map.get(key);
+            if (!item) {
+                throw new Error(`Missing mandatory ${key} card`);
+            }
+            cards.push(...FITSHeaderWriter.makeKeywordWithComment(key, item.value, item.comment));
+        }
+        if (!primary) {
+            const pcount = map.get("PCOUNT");
+            const gcount = map.get("GCOUNT");
+            if (!pcount) {
+                throw new Error("Missing mandatory PCOUNT card in extension HDU");
+            }
+            if (!gcount) {
+                throw new Error("Missing mandatory GCOUNT card in extension HDU");
+            }
+            cards.push(...FITSHeaderWriter.makeKeywordWithComment("PCOUNT", pcount.value, pcount.comment));
+            cards.push(...FITSHeaderWriter.makeKeywordWithComment("GCOUNT", gcount.value, gcount.comment));
+        }
+        if (primary) {
+            const extend = map.get("EXTEND");
+            if (extend) {
+                cards.push(...FITSHeaderWriter.makeKeywordWithComment("EXTEND", extend.value, extend.comment));
+            }
+        }
+    }
+    static appendRemainingCards(cards, items) {
+        for (const item of items) {
+            const key = item.key.toUpperCase();
+            if (key === "SIMPLE" ||
+                key === "XTENSION" ||
+                key === "BITPIX" ||
+                key === "NAXIS" ||
+                /^NAXIS\d+$/.test(key) ||
+                key === "PCOUNT" ||
+                key === "GCOUNT" ||
+                key === "EXTEND" ||
+                key === "END") {
+                continue;
+            }
+            cards.push(...FITSHeaderWriter.makeKeywordWithComment(item.key, item.value, item.comment));
+        }
+    }
+    static makeKeywordWithComment(key, value, comment) {
+        const normalized = key.toUpperCase();
+        if (normalized === "END") {
+            return [FITSHeaderWriter.card80("END")];
+        }
+        if (normalized === "COMMENT" || normalized === "HISTORY") {
+            return FITSHeaderWriter.makeCommentCards(normalized, String(value ?? comment ?? ""));
+        }
+        let base = FITSHeaderWriter.keyword(normalized) +
+            FITSHeaderWriter.valueField20(normalized, value);
+        if (!comment || comment.length === 0) {
+            return [FITSHeaderWriter.card80(base)];
+        }
+        const addition = ` / ${comment}`;
+        const spaceLeft = FITSHeaderWriter.CARD_SIZE - base.length;
+        if (spaceLeft <= 0) {
+            return [
+                FITSHeaderWriter.card80(base),
+                ...FITSHeaderWriter.makeCommentCards("COMMENT", comment),
+            ];
+        }
+        base += addition.slice(0, spaceLeft);
+        const overflow = addition.slice(spaceLeft).replace(/^\s*\/\s*/, "");
+        if (overflow.length === 0) {
+            return [FITSHeaderWriter.card80(base)];
+        }
+        return [
+            FITSHeaderWriter.card80(base),
+            ...FITSHeaderWriter.makeCommentCards("COMMENT", overflow),
+        ];
+    }
+    static makeCommentCards(kind, text) {
+        const prefix = FITSHeaderWriter.keyword(kind);
+        const width = FITSHeaderWriter.CARD_SIZE - prefix.length;
+        const value = String(text ?? "");
+        if (value.length === 0) {
+            return [FITSHeaderWriter.card80(prefix)];
+        }
+        const cards = [];
+        for (let offset = 0; offset < value.length; offset += width) {
+            cards.push(FITSHeaderWriter.card80(prefix + value.slice(offset, offset + width)));
+        }
+        return cards;
+    }
+    static valueField20(key, value) {
+        if (FITSHeaderWriter.LOGICAL_KEYWORDS.has(key)) {
+            const logical = value === true || value === "T" || value === "t" ? "T" : "F";
+            return `= ${logical.padStart(20, " ")}`;
+        }
+        if (FITSHeaderWriter.INTEGER_KEYWORDS.has(key) || /^NAXIS\d+$/.test(key)) {
+            const number = Number(value);
+            if (!Number.isFinite(number) || !Number.isInteger(number)) {
+                throw new Error(`FITS header: ${key} must be an integer, got ${value}`);
+            }
+            return `= ${String(number).padStart(20, " ")}`;
+        }
+        if (typeof value === "number") {
+            let encoded = Number.isInteger(value)
+                ? String(value)
+                : value.toExponential(10).replace("e", "E");
+            if (encoded.length > 20) {
+                encoded = value.toExponential(8).replace("e", "E");
+            }
+            return `= ${encoded.padStart(20, " ")}`;
+        }
+        if (typeof value === "string") {
+            return `= ${FITSHeaderWriter.quoteFitsString(value)}`;
+        }
+        return "";
+    }
+    static quoteFitsString(value) {
+        const unquoted = value.replace(/^'+|'+$/g, "");
+        const escaped = unquoted.replace(/'/g, "''");
+        return `'${escaped}'`;
+    }
+    static keyword(value) {
+        return (value ?? "").toUpperCase().padEnd(8, " ").slice(0, 8);
+    }
+    static card80(value) {
+        if (value.length >= FITSHeaderWriter.CARD_SIZE) {
+            return value.slice(0, FITSHeaderWriter.CARD_SIZE);
+        }
+        return value.padEnd(FITSHeaderWriter.CARD_SIZE, " ");
+    }
+    static encodeAndPad(cards) {
+        let header = cards.join("");
+        const remainder = header.length % FITSHeaderWriter.BLOCK_SIZE;
+        if (remainder !== 0) {
+            header += " ".repeat(FITSHeaderWriter.BLOCK_SIZE - remainder);
+        }
+        return new TextEncoder().encode(header);
+    }
+}
+//# sourceMappingURL=FITSHeaderWriter.js.map
+;// ./node_modules/jsfitsio/lib-esm/FITSWriter.js
+/**
+ * FITS serialization and file writing support.
+ *
+ * FITSWriter provides two serialization APIs:
+ *
+ * - The jsfitsio 3.x API serializes the FITSFile/HDU data model,
+ *   including PrimaryHDU, ImageHDU, BinaryTableHDU and AsciiTableHDU.
+ *
+ * - The legacy API serializes the former FITSParsed representation
+ *   and is retained for backward compatibility with jsfitsio 2.x
+ *   consumers.
+ *
+ * FITS headers are serialized according to the FITS 80-character
+ * card format and padded to 2880-byte FITS logical blocks.
+ * HDU payloads are likewise padded to 2880-byte boundaries.
+ *
+ * New code should use FITSFile together with createFITSFile() and
+ * writeFITSFileModel().
+ *
+ * @see https://fits.gsfc.nasa.gov/
+ */
+
+
+class FITSWriter {
+    /**
+     * Serializes the legacy FITSParsed representation.
+     *
+     * @deprecated Use createFITSFile() with the FITSFile/HDU model.
+     * This method is retained for backward compatibility with jsfitsio 2.x.
+     */
+    static createFITS(fitsParsed) {
+        const headerBytes = FITSHeaderWriter.serialize(fitsParsed.header, true);
+        const dataBytes = this.createData(fitsParsed.data, fitsParsed.header);
+        const fitsFile = new Uint8Array(headerBytes.length + dataBytes.length);
+        fitsFile.set(headerBytes, 0);
+        fitsFile.set(dataBytes, headerBytes.length);
+        return fitsFile;
+    }
+    static createHDU(hdu, primary) {
+        const headerBytes = FITSHeaderWriter.serialize(hdu.header, primary);
+        const rawData = hdu.rawData ?? new Uint8Array(0);
+        if (rawData.byteLength !== hdu.dataByteLength) {
+            throw new Error(`HDU payload length mismatch: ` +
+                `rawData contains ${rawData.byteLength} bytes, ` +
+                `but dataByteLength=${hdu.dataByteLength}.`);
+        }
+        const dataBytes = FITSWriter.padData(rawData);
+        const result = new Uint8Array(headerBytes.byteLength + dataBytes.byteLength);
+        result.set(headerBytes, 0);
+        result.set(dataBytes, headerBytes.byteLength);
+        return result;
+    }
+    static padData(data) {
+        const BLOCK = 2880;
+        if (data.byteLength === 0) {
+            return new Uint8Array(0);
+        }
+        const remainder = data.byteLength % BLOCK;
+        if (remainder === 0) {
+            return data.slice();
+        }
+        const padded = new Uint8Array(data.byteLength + (BLOCK - remainder));
+        padded.set(data);
+        return padded;
+    }
+    static createData(data, header) {
+        // concat
+        const totalLength = data.reduce((s, c) => s + c.length, 0);
+        // OPTIONAL: verify size from BITPIX/NAXIS
+        const bitpix = Math.abs(Number(header.findById("BITPIX")?.value ?? 0));
+        const naxis = Number(header.findById("NAXIS")?.value ?? 0);
+        let elems = 1;
+        for (let k = 1; k <= naxis; k++) {
+            elems *= Number(header.findById(`NAXIS${k}`)?.value ?? 0);
+        }
+        const bytesPerElem = bitpix / 8;
+        const expectedUnpadded = naxis > 0 ? elems * bytesPerElem : 0;
+        if (expectedUnpadded && expectedUnpadded !== totalLength) {
+            throw new Error(`Data length ${totalLength} does not match header expectation ${expectedUnpadded} (BITPIX=${bitpix}, NAXIS=${naxis})`);
+        }
+        // build and pad
+        let dataBytes = new Uint8Array(totalLength);
+        let off = 0;
+        for (const chunk of data) {
+            dataBytes.set(chunk, off);
+            off += chunk.length;
+        }
+        return FITSWriter.padData(dataBytes);
+    }
+    /**
+     * Serializes a jsfitsio 3.x FITSFile, including all contained HDUs.
+     */
+    static createFITSFile(fitsFile) {
+        if (fitsFile.length === 0) {
+            throw new Error("Cannot write an empty FITSFile.");
+        }
+        if (fitsFile.primaryHDU === null) {
+            throw new Error("FITSFile must start with a PrimaryHDU.");
+        }
+        const serializedHDUs = fitsFile.hdus.map((hdu, index) => FITSWriter.createHDU(hdu, index === 0));
+        const totalLength = serializedHDUs.reduce((sum, hdu) => sum + hdu.byteLength, 0);
+        const result = new Uint8Array(totalLength);
+        let offset = 0;
+        for (const hdu of serializedHDUs) {
+            result.set(hdu, offset);
+            offset += hdu.byteLength;
+        }
+        return result;
+    }
+    /**
+     * Serializes a jsfitsio 3.x FITSFile and writes it to the local filesystem.
+     */
+    static writeFITSFileModel(fitsFile, filePath) {
+        const data = FITSWriter.createFITSFile(fitsFile);
+        external_fs_namespaceObject.writeFileSync(filePath, data);
+    }
+    /**
+     * Writes the legacy FITSParsed representation to a local file.
+     *
+     * @deprecated Use writeFITSFileModel() with FITSFile instead.
+     * This method is retained for backward compatibility with jsfitsio 2.x.
+     */
+    static writeFITSFile(fitsParsed, filePath) {
+        const fitsFile = FITSWriter.createFITS(fitsParsed);
+        external_fs_namespaceObject.writeFileSync(filePath, fitsFile);
+    }
+}
+//# sourceMappingURL=FITSWriter.js.map
+;// ./node_modules/jsfitsio/lib-esm/ParseHeader.js
+// import { FITSHeader } from "./model/FITSHeader.js";
+
+
+/**
+ * Summary. (bla bla bla)
+ *
+ * Description. (bla bla bla)
+ *
+ * @link   github https://github.com/fab77/FITSParser
+ * @author Fabrizio Giordano <fabriziogiordano77@gmail.com>
+ */
+class ParseHeader {
+    static CARD_SIZE = 80;
+    static BLOCK_SIZE = 2880;
+    static getFITSItemStringValue(header, key) {
+        const item = header.findById(key);
+        if (!item) {
+            return null;
+        }
+        return String(item.value).trim().replace(/^'/, "").replace(/'$/, "").trim();
+    }
+    static getFITSItemValue(header, key) {
+        const item = header.findById(key);
+        if (!item) {
+            return null;
+        }
+        const value = Number(item.value);
+        return Number.isNaN(value) ? null : value;
+    }
+    /**
+     * Returns the complete FITS header size, including padding
+     * up to the next 2880-byte boundary.
+     */
+    static getHeaderByteLength(rawData, startOffset = 0) {
+        const decoder = new TextDecoder("ascii");
+        for (let offset = startOffset; offset + ParseHeader.CARD_SIZE <= rawData.byteLength; offset += ParseHeader.CARD_SIZE) {
+            const key = decoder.decode(rawData.subarray(offset, offset + 8)).trim();
+            if (key === "END") {
+                const consumed = offset + ParseHeader.CARD_SIZE - startOffset;
+                return (Math.ceil(consumed / ParseHeader.BLOCK_SIZE) * ParseHeader.BLOCK_SIZE);
+            }
+        }
+        throw new Error("Invalid FITS header: END card not found.");
+    }
+    static parse(rawData, startOffset = 0) {
+        const decoder = new TextDecoder("ascii");
+        const headerLength = ParseHeader.getHeaderByteLength(rawData, startOffset);
+        const header = new FITSHeaderManager(false);
+        for (let offset = startOffset; offset < startOffset + headerLength; offset += ParseHeader.CARD_SIZE) {
+            const line = decoder.decode(rawData.subarray(offset, offset + ParseHeader.CARD_SIZE));
+            const key = line.slice(0, 8).trim();
+            if (key === "END") {
+                break;
+            }
+            if (!key) {
+                continue;
+            }
+            let value;
+            let comment = "";
+            const rawValue = line.slice(10).trim().split("/")[0].trim();
+            if (Number.isNaN(Number(rawValue))) {
+                value = rawValue;
+            }
+            else {
+                value = Number(rawValue);
+            }
+            if (line.includes("/")) {
+                comment = line.slice(10).trim().split("/")[1]?.trim() ?? "";
+            }
+            header.insert(new FITSHeaderItem(key, value, comment));
+        }
+        return header;
+    }
+}
+//# sourceMappingURL=ParseHeader.js.map
+;// ./node_modules/jsfitsio/lib-esm/FITSImageUtils.js
+
+
+class FITSImageUtils {
+    static getShape(header) {
+        const naxis = ParseHeader.getFITSItemValue(header, FITSHeaderManager.NAXIS);
+        if (naxis === null) {
+            throw new Error("NAXIS not defined.");
+        }
+        if (!Number.isInteger(naxis) || naxis < 0) {
+            throw new Error(`Invalid FITS NAXIS value: ${naxis}`);
+        }
+        const shape = [];
+        for (let axis = 1; axis <= naxis; axis++) {
+            const size = ParseHeader.getFITSItemValue(header, FITSHeaderManager.naxisKey(axis));
+            if (size === null) {
+                throw new Error(`NAXIS${axis} not defined.`);
+            }
+            shape.push(size);
+        }
+        return shape;
+    }
+    static getElementCount(shape) {
+        if (shape.length === 0) {
+            return 0;
+        }
+        return shape.reduce((total, dimension) => total * dimension, 1);
+    }
+}
+//# sourceMappingURL=FITSImageUtils.js.map
+;// ./node_modules/jsfitsio/lib-esm/ParsePayload.js
+// "use strict";
+/**
+ * Summary. (bla bla bla)
+ *
+ * Description. (bla bla bla)
+ *
+ * @link   github https://github.com/fab77/FITSParser
+ * @author Fabrizio Giordano <fabriziogiordano77@gmail.com>
+ */
+
+
+
+
+class ParsePayload {
+    static SUPPORTED_BITPIX = new Set([8, 16, 32, 64, -32, -64]);
+    static assertSupportedBITPIX(bitpix) {
+        if (!ParsePayload.SUPPORTED_BITPIX.has(bitpix)) {
+            throw new Error(`Unsupported FITS BITPIX value: ${bitpix}`);
+        }
+    }
+    static extractPixelFromView(view, offset, bitpix) {
+        switch (bitpix) {
+            case 8:
+                return view.getUint8(offset);
+            case 16:
+                return view.getInt16(offset, false);
+            case 32:
+                return view.getInt32(offset, false);
+            case -32:
+                return view.getFloat32(offset, false);
+            case -64:
+                return view.getFloat64(offset, false);
+            case 64: {
+                const value = view.getBigInt64(offset, false);
+                const numeric = Number(value);
+                if (!Number.isSafeInteger(numeric)) {
+                    throw new RangeError(`BITPIX=64 value ${value} cannot be represented ` +
+                        `exactly as a JavaScript number.`);
+                }
+                return numeric;
+            }
+            default:
+                throw new Error(`Unsupported FITS BITPIX value: ${bitpix}`);
+        }
+    }
+    static computePhysicalMinAndMax(header, payload) {
+        const bitpix = ParseHeader.getFITSItemValue(header, FITSHeaderManager.BITPIX);
+        if (bitpix === null) {
+            return null;
+        }
+        ParsePayload.assertSupportedBITPIX(bitpix);
+        const shape = FITSImageUtils.getShape(header);
+        /*
+         * NAXIS=0 is a valid FITS HDU.
+         */
+        if (shape.length === 0 || payload.byteLength === 0) {
+            return header;
+        }
+        const dataMinItem = header.findById(FITSHeaderManager.DATAMIN);
+        const dataMaxItem = header.findById(FITSHeaderManager.DATAMAX);
+        if (dataMinItem === null || dataMaxItem === null) {
+            try {
+                const [min, max] = ParsePayload.computePhysicalValues(payload, header);
+                if (dataMinItem === null && min !== null) {
+                    header.insert(new FITSHeaderItem(FITSHeaderManager.DATAMIN, min, "computed by jsfitsio"));
+                }
+                if (dataMaxItem === null && max !== null) {
+                    header.insert(new FITSHeaderItem(FITSHeaderManager.DATAMAX, max, "computed by jsfitsio"));
+                }
+            }
+            catch (error) {
+                if (bitpix === 64 && error instanceof RangeError) {
+                    return header;
+                }
+                throw error;
+            }
+        }
+        return header;
+    }
+    static createTypedArray(rawData, bitpix) {
+        ParsePayload.assertSupportedBITPIX(bitpix);
+        const bytesPerElement = Math.abs(bitpix) / 8;
+        if (rawData.byteLength % bytesPerElement !== 0) {
+            throw new Error(`Payload byte length ${rawData.byteLength} ` +
+                `is not aligned with BITPIX=${bitpix}.`);
+        }
+        const count = rawData.byteLength / bytesPerElement;
+        const view = new DataView(rawData.buffer, rawData.byteOffset, rawData.byteLength);
+        switch (bitpix) {
+            case 8: {
+                /*
+                 * For 8-bit FITS, byte order is irrelevant.
+                 *
+                 * Use slice() so typedData has its own correctly
+                 * sized backing store.
+                 */
+                return rawData.slice();
+            }
+            case 16: {
+                const result = new Int16Array(count);
+                for (let i = 0; i < count; i++) {
+                    result[i] = view.getInt16(i * 2, false);
+                }
+                return result;
+            }
+            case 32: {
+                const result = new Int32Array(count);
+                for (let i = 0; i < count; i++) {
+                    result[i] = view.getInt32(i * 4, false);
+                }
+                return result;
+            }
+            case 64: {
+                const result = new BigInt64Array(count);
+                for (let i = 0; i < count; i++) {
+                    result[i] = view.getBigInt64(i * 8, false);
+                }
+                return result;
+            }
+            case -32: {
+                const result = new Float32Array(count);
+                for (let i = 0; i < count; i++) {
+                    result[i] = view.getFloat32(i * 4, false);
+                }
+                return result;
+            }
+            case -64: {
+                const result = new Float64Array(count);
+                for (let i = 0; i < count; i++) {
+                    result[i] = view.getFloat64(i * 8, false);
+                }
+                return result;
+            }
+            default:
+                throw new Error(`Unsupported FITS BITPIX value: ${bitpix}`);
+        }
+    }
+    static computePhysicalValues(rawData, header) {
+        const bitpix = ParseHeader.getFITSItemValue(header, FITSHeaderManager.BITPIX);
+        if (bitpix === null) {
+            return [null, null];
+        }
+        ParsePayload.assertSupportedBITPIX(bitpix);
+        const shape = FITSImageUtils.getShape(header);
+        const pixelCount = FITSImageUtils.getElementCount(shape);
+        if (pixelCount === 0) {
+            return [null, null];
+        }
+        const blank = ParseHeader.getFITSItemValue(header, FITSHeaderManager.BLANK);
+        const bzero = ParseHeader.getFITSItemValue(header, FITSHeaderManager.BZERO) ?? 0;
+        const bscale = ParseHeader.getFITSItemValue(header, FITSHeaderManager.BSCALE) ?? 1;
+        const bytesPerElement = Math.abs(bitpix) / 8;
+        const requiredBytes = pixelCount * bytesPerElement;
+        if (rawData.byteLength < requiredBytes) {
+            throw new Error(`FITS payload is too short: expected ${requiredBytes} bytes, ` +
+                `received ${rawData.byteLength}.`);
+        }
+        const view = new DataView(rawData.buffer, rawData.byteOffset, rawData.byteLength);
+        let min = null;
+        let max = null;
+        for (let i = 0; i < pixelCount; i++) {
+            const rawValue = ParsePayload.extractPixelFromView(view, i * bytesPerElement, bitpix);
+            // BLANK applies to integer FITS image data.
+            if (bitpix > 0 && blank !== null && rawValue === blank) {
+                continue;
+            }
+            const physicalValue = ParsePayload.pixel2physicalValue(rawValue, bscale, bzero);
+            // Floating-point FITS images may contain NaN.
+            if (Number.isNaN(physicalValue)) {
+                continue;
+            }
+            if (min === null || physicalValue < min) {
+                min = physicalValue;
+            }
+            if (max === null || physicalValue > max) {
+                max = physicalValue;
+            }
+        }
+        return [min, max];
+    }
+    static pixel2physicalValue(pxval, BSCALE, BZERO) {
+        if (BZERO === null || BSCALE === null) {
+            throw new Error("Either BZERO or BSCALE is null");
+        }
+        return BZERO + BSCALE * pxval;
+    }
+    static extractPixelValue(rawData, offset, bitpix) {
+        ParsePayload.assertSupportedBITPIX(bitpix);
+        const view = new DataView(rawData.buffer, rawData.byteOffset, rawData.byteLength);
+        return ParsePayload.extractPixelFromView(view, offset, bitpix);
+    }
+}
+//# sourceMappingURL=ParsePayload.js.map
+;// ./node_modules/jsfitsio/lib-esm/model/FITSHDU.js
+class FITSHDU {
+    header;
+    rawData;
+    dataOffset;
+    dataByteLength;
+    constructor(header, rawData, dataOffset, dataByteLength) {
+        this.header = header;
+        this.rawData = rawData;
+        this.dataOffset = dataOffset;
+        this.dataByteLength = dataByteLength;
+    }
+}
+//# sourceMappingURL=FITSHDU.js.map
+;// ./node_modules/jsfitsio/lib-esm/model/ImageHDU.js
+
+class ImageHDU extends FITSHDU {
+    bitpix;
+    shape;
+    typedData;
+    type = "IMAGE";
+    constructor(header, rawData, dataOffset, dataByteLength, bitpix, shape, typedData) {
+        super(header, rawData, dataOffset, dataByteLength);
+        this.bitpix = bitpix;
+        this.shape = shape;
+        this.typedData = typedData;
+    }
+    get naxis() {
+        return this.shape.length;
+    }
+    get elementCount() {
+        if (this.shape.length === 0) {
+            return 0;
+        }
+        return this.shape.reduce((accumulator, dimension) => accumulator * dimension, 1);
+    }
+}
+//# sourceMappingURL=ImageHDU.js.map
+;// ./node_modules/jsfitsio/lib-esm/model/PrimaryHDU.js
+
+class PrimaryHDU extends ImageHDU {
+    type = "PRIMARY";
+    constructor(header, rawData, dataOffset, dataByteLength, bitpix, shape, typedData) {
+        super(header, rawData, dataOffset, dataByteLength, bitpix, shape, typedData);
+    }
+}
+//# sourceMappingURL=PrimaryHDU.js.map
+;// ./node_modules/jsfitsio/lib-esm/model/FITSFile.js
+
+class FITSFile {
+    _hdus;
+    constructor(hdus = []) {
+        this._hdus = [...hdus];
+    }
+    get hdus() {
+        return this._hdus;
+    }
+    get length() {
+        return this._hdus.length;
+    }
+    get primaryHDU() {
+        const hdu = this._hdus[0];
+        if (hdu instanceof PrimaryHDU) {
+            return hdu;
+        }
+        return null;
+    }
+    getHDU(index) {
+        return this._hdus[index] ?? null;
+    }
+    addHDU(hdu) {
+        this._hdus.push(hdu);
+    }
+}
+//# sourceMappingURL=FITSFile.js.map
+;// ./node_modules/jsfitsio/lib-esm/model/BinaryTableHDU.js
+
+class BinaryTableHDU extends FITSHDU {
+    rowByteLength;
+    rowCount;
+    columns;
+    type = "BINTABLE";
+    constructor(header, rawData, dataOffset, dataByteLength, rowByteLength, rowCount, columns) {
+        super(header, rawData, dataOffset, dataByteLength);
+        this.rowByteLength = rowByteLength;
+        this.rowCount = rowCount;
+        this.columns = columns;
+    }
+    get columnCount() {
+        return this.columns.length;
+    }
+    getRowView(rowIndex) {
+        if (rowIndex < 0 || rowIndex >= this.rowCount) {
+            throw new RangeError(`Invalid row index ${rowIndex}.`);
+        }
+        const offset = rowIndex * this.rowByteLength;
+        return new DataView(this.rawData.buffer, this.rawData.byteOffset + offset, this.rowByteLength);
+    }
+    getRow(rowIndex) {
+        return this.columns.map((_, columnIndex) => this.getCell(rowIndex, columnIndex));
+    }
+    getCell(rowIndex, column) {
+        const columnDefinition = this.resolveColumn(column);
+        const row = this.getRowView(rowIndex);
+        const offset = columnDefinition.byteOffset;
+        const repeat = columnDefinition.repeat;
+        switch (columnDefinition.type) {
+            case "CHAR": {
+                const bytes = new Uint8Array(row.buffer, row.byteOffset + offset, columnDefinition.byteWidth);
+                return new TextDecoder("ascii").decode(bytes).replace(/\s+$/, "");
+            }
+            case "LOGICAL": {
+                const values = [];
+                for (let i = 0; i < repeat; i++) {
+                    const value = String.fromCharCode(row.getUint8(offset + i));
+                    values.push(value === "T");
+                }
+                return repeat === 1 ? values[0] : values;
+            }
+            case "UINT8": {
+                const values = [];
+                for (let i = 0; i < repeat; i++) {
+                    const raw = row.getUint8(offset + i);
+                    values.push(this.applyNumericScaling(raw, columnDefinition.scale, columnDefinition.zero));
+                }
+                return repeat === 1 ? values[0] : values;
+            }
+            case "INT16":
+                return this.readNumericColumn(row, offset, repeat, 2, (view, position) => view.getInt16(position, false), columnDefinition.scale, columnDefinition.zero, columnDefinition.nullValue);
+            case "INT32":
+                return this.readNumericColumn(row, offset, repeat, 4, (view, position) => view.getInt32(position, false), columnDefinition.scale, columnDefinition.zero, columnDefinition.nullValue);
+            case "INT64": {
+                const values = [];
+                for (let i = 0; i < repeat; i++) {
+                    const raw = row.getBigInt64(offset + i * 8, false);
+                    /*
+                     * Preserve exact 64-bit integers.
+                     *
+                     * Do not silently convert bigint to number.
+                     */
+                    values.push(raw);
+                }
+                return repeat === 1 ? values[0] : values;
+            }
+            case "FLOAT32":
+                return this.readNumericColumn(row, offset, repeat, 4, (view, position) => view.getFloat32(position, false), columnDefinition.scale, columnDefinition.zero, null);
+            case "FLOAT64":
+                return this.readNumericColumn(row, offset, repeat, 8, (view, position) => view.getFloat64(position, false), columnDefinition.scale, columnDefinition.zero, null);
+            case "COMPLEX64": {
+                const values = [];
+                for (let i = 0; i < repeat; i++) {
+                    const position = offset + i * 8;
+                    values.push({
+                        real: row.getFloat32(position, false),
+                        imaginary: row.getFloat32(position + 4, false),
+                    });
+                }
+                return repeat === 1 ? values[0] : values;
+            }
+            case "COMPLEX128": {
+                const values = [];
+                for (let i = 0; i < repeat; i++) {
+                    const position = offset + i * 16;
+                    values.push({
+                        real: row.getFloat64(position, false),
+                        imaginary: row.getFloat64(position + 8, false),
+                    });
+                }
+                return repeat === 1 ? values[0] : values;
+            }
+            case "BIT":
+                /*
+                 * I'd defer bit-array decoding for the moment.
+                 * The raw bytes remain available.
+                 */
+                return new Uint8Array(row.buffer, row.byteOffset + offset, columnDefinition.byteWidth).slice();
+            default:
+                throw new Error(`Unsupported BINTABLE column type: ${columnDefinition.type}`);
+        }
+    }
+    readNumericColumn(view, offset, repeat, bytesPerElement, reader, scale, zero, nullValue) {
+        const values = [];
+        for (let i = 0; i < repeat; i++) {
+            const raw = reader(view, offset + i * bytesPerElement);
+            if (nullValue !== null && raw === nullValue) {
+                values.push(null);
+                continue;
+            }
+            values.push(this.applyNumericScaling(raw, scale, zero));
+        }
+        if (repeat === 1) {
+            return values[0];
+        }
+        /*
+         * Because repeated integer fields may contain NULL,
+         * we cannot represent every case as number[].
+         *
+         * For now return a generic value array.
+         */
+        return values;
+    }
+    applyNumericScaling(raw, scale, zero) {
+        return zero + scale * raw;
+    }
+    resolveColumn(column) {
+        if (typeof column === "number") {
+            if (!Number.isInteger(column) ||
+                column < 0 ||
+                column >= this.columns.length) {
+                throw new RangeError(`Invalid column index ${column}.`);
+            }
+            return this.columns[column];
+        }
+        const found = this.columns.find((candidate) => candidate.name === column);
+        if (!found) {
+            throw new Error(`BINTABLE column '${column}' not found.`);
+        }
+        return found;
+    }
+}
+//# sourceMappingURL=BinaryTableHDU.js.map
+;// ./node_modules/jsfitsio/lib-esm/FITSBinaryTableUtils.js
+class FITSBinaryTableUtils {
+    static parseTFORM(format) {
+        const normalized = format
+            .trim()
+            .replace(/^'/, "")
+            .replace(/'$/, "")
+            .trim()
+            .toUpperCase();
+        const match = normalized.match(/^(\d*)([LXBIJKAEDCM])$/);
+        if (!match) {
+            throw new Error(`Unsupported FITS TFORM value: ${format}`);
+        }
+        const repeat = match[1] ? Number(match[1]) : 1;
+        const code = match[2];
+        const bytesPerElement = FITSBinaryTableUtils.bytesPerType(code);
+        return {
+            repeat,
+            code,
+            byteWidth: code === "X" ? Math.ceil(repeat / 8) : repeat * bytesPerElement,
+        };
+    }
+    static bytesPerType(code) {
+        switch (code) {
+            case "L":
+            case "B":
+            case "A":
+                return 1;
+            case "I":
+                return 2;
+            case "J":
+            case "E":
+                return 4;
+            case "K":
+            case "D":
+                return 8;
+            case "C":
+                return 8;
+            case "M":
+                return 16;
+            case "X":
+                return 0;
+            default:
+                throw new Error(`Unsupported FITS binary table type: ${code}`);
+        }
+    }
+}
+//# sourceMappingURL=FITSBinaryTableUtils.js.map
+;// ./node_modules/jsfitsio/lib-esm/model/AsciiTableHDU.js
+
+class AsciiTableHDU extends FITSHDU {
+    rowByteLength;
+    rowCount;
+    columns;
+    type = "TABLE";
+    constructor(header, rawData, dataOffset, dataByteLength, rowByteLength, rowCount, columns) {
+        super(header, rawData, dataOffset, dataByteLength);
+        this.rowByteLength = rowByteLength;
+        this.rowCount = rowCount;
+        this.columns = columns;
+    }
+    get columnCount() {
+        return this.columns.length;
+    }
+    getRowView(rowIndex) {
+        if (!Number.isInteger(rowIndex) ||
+            rowIndex < 0 ||
+            rowIndex >= this.rowCount) {
+            throw new RangeError(`Invalid row index ${rowIndex}.`);
+        }
+        const start = rowIndex * this.rowByteLength;
+        return this.rawData.subarray(start, start + this.rowByteLength);
+    }
+    getRowText(rowIndex) {
+        return new TextDecoder("ascii").decode(this.getRowView(rowIndex));
+    }
+    resolveColumn(column) {
+        if (typeof column === "number") {
+            if (!Number.isInteger(column) ||
+                column < 0 ||
+                column >= this.columns.length) {
+                throw new RangeError(`Invalid column index ${column}.`);
+            }
+            return this.columns[column];
+        }
+        const found = this.columns.find((candidate) => candidate.name === column);
+        if (!found) {
+            throw new Error(`ASCII TABLE column '${column}' not found.`);
+        }
+        return found;
+    }
+    getCell(rowIndex, column) {
+        const definition = this.resolveColumn(column);
+        const row = this.getRowView(rowIndex);
+        const bytes = row.subarray(definition.byteOffset, definition.byteOffset + definition.width);
+        const raw = new TextDecoder("ascii").decode(bytes);
+        const trimmed = raw.trim();
+        /*
+         * Blank numeric fields are treated as null.
+         */
+        if (trimmed.length === 0) {
+            return definition.type === "CHAR" ? "" : null;
+        }
+        switch (definition.type) {
+            case "CHAR":
+                return raw.replace(/\s+$/, "");
+            case "INTEGER": {
+                const value = Number.parseInt(trimmed, 10);
+                if (Number.isNaN(value)) {
+                    return null;
+                }
+                return value;
+            }
+            case "FLOAT":
+            case "EXPONENTIAL":
+            case "DOUBLE": {
+                /*
+                 * FITS ASCII tables may use D exponent notation.
+                 * JavaScript expects E.
+                 */
+                const normalized = trimmed.replace(/[dD]/, "E");
+                const value = Number.parseFloat(normalized);
+                if (Number.isNaN(value)) {
+                    return null;
+                }
+                return value;
+            }
+            default:
+                throw new Error(`Unsupported ASCII TABLE column type: ${definition.type}`);
+        }
+    }
+    getRow(rowIndex) {
+        return this.columns.map((_, columnIndex) => this.getCell(rowIndex, columnIndex));
+    }
+}
+//# sourceMappingURL=AsciiTableHDU.js.map
+;// ./node_modules/jsfitsio/lib-esm/FITSAsciiTableUtils.js
+class FITSAsciiTableUtils {
+    static parseTFORM(format) {
+        const normalized = format
+            .trim()
+            .replace(/^'/, "")
+            .replace(/'$/, "")
+            .trim()
+            .toUpperCase();
+        /*
+         * FITS ASCII table formats:
+         *
+         *   Aw
+         *   Iw
+         *   Fw.d
+         *   Ew.d
+         *   Dw.d
+         */
+        const match = normalized.match(/^([AIFED])(\d+)(?:\.(\d+))?$/);
+        if (!match) {
+            throw new Error(`Unsupported FITS ASCII table TFORM value: ${format}`);
+        }
+        const code = match[1];
+        const width = Number(match[2]);
+        const decimals = match[3] !== undefined
+            ? Number(match[3])
+            : null;
+        if (!Number.isInteger(width) ||
+            width <= 0) {
+            throw new Error(`Invalid FITS ASCII table field width: ${width}`);
+        }
+        if (code === "A" ||
+            code === "I") {
+            if (decimals !== null) {
+                throw new Error(`TFORM ${format} must not specify decimal places.`);
+            }
+        }
+        else if (decimals === null) {
+            throw new Error(`TFORM ${format} requires decimal places.`);
+        }
+        return {
+            code,
+            width,
+            decimals,
+        };
+    }
+}
+//# sourceMappingURL=FITSAsciiTableUtils.js.map
+;// ./node_modules/jsfitsio/lib-esm/FITSParser.js
+
+
+
+
+
+
+
+
+
+
+
+
+class FITSParser {
+    /**
+     * @deprecated Use loadFITSFile() instead.
+     *
+     * This legacy API supports only 2-dimensional image FITS files
+     * and returns the former FITSParsed structure.
+     */
+    static async loadFITS(path, options = {}) {
+        const fitsFile = await FITSParser.loadFITSFile(path, options);
+        if (fitsFile === null) {
+            return null;
+        }
+        const primary = fitsFile.primaryHDU;
+        if (primary === null || primary.rawData === null) {
+            return null;
+        }
+        const shape = FITSImageUtils.getShape(primary.header);
+        if (shape.length !== 2) {
+            throw new Error("Legacy loadFITS() supports only 2D FITS images. " +
+                "Use loadFITSFile() for N-dimensional images.");
+        }
+        return {
+            header: primary.header,
+            data: FITSParser.createMatrix(primary.rawData, primary.header),
+        };
+    }
+    static async loadFITSFile(path, options = {}) {
+        const rawData = await FITSParser.getFile(path);
+        if (rawData.byteLength === 0) {
+            return null;
+        }
+        return FITSParser.processFITSFile(rawData, options);
+    }
+    static processFITSFile(rawData, options) {
+        const fitsFile = new FITSFile();
+        let offset = 0;
+        let hduIndex = 0;
+        while (offset < rawData.byteLength) {
+            /*
+             * Ignore trailing zero/space padding.
+             */
+            if (FITSParser.isPaddingOnly(rawData, offset)) {
+                break;
+            }
+            const header = ParseHeader.parse(rawData, offset);
+            const headerByteLength = ParseHeader.getHeaderByteLength(rawData, offset);
+            const dataOffset = offset + headerByteLength;
+            const hduType = FITSParser.getHDUType(header, hduIndex);
+            switch (hduType) {
+                case "PRIMARY":
+                case "IMAGE": {
+                    const dataByteLength = FITSParser.getImagePayloadByteLength(header);
+                    if (dataOffset + dataByteLength > rawData.byteLength) {
+                        throw new Error(`Invalid FITS HDU ${hduIndex}: ` +
+                            `expected ${dataByteLength} payload bytes ` +
+                            `at offset ${dataOffset}, but only ` +
+                            `${rawData.byteLength - dataOffset} remain.`);
+                    }
+                    const rawPayload = rawData.subarray(dataOffset, dataOffset + dataByteLength);
+                    const hdu = FITSParser.createImageHDU(header, rawPayload, dataOffset, dataByteLength, hduIndex === 0, options);
+                    fitsFile.addHDU(hdu);
+                    const paddedPayloadLength = FITSParser.getPaddedByteLength(dataByteLength);
+                    offset = dataOffset + paddedPayloadLength;
+                    break;
+                }
+                case "BINTABLE": {
+                    const dataByteLength = FITSParser.getBinaryTablePayloadByteLength(header);
+                    if (dataOffset + dataByteLength > rawData.byteLength) {
+                        throw new Error(`Invalid BINTABLE HDU ${hduIndex}.`);
+                    }
+                    const rawPayload = rawData.subarray(dataOffset, dataOffset + dataByteLength);
+                    const hdu = FITSParser.createBinaryTableHDU(header, rawPayload, dataOffset, dataByteLength);
+                    fitsFile.addHDU(hdu);
+                    offset = dataOffset + FITSParser.getPaddedByteLength(dataByteLength);
+                    break;
+                }
+                case "TABLE": {
+                    const dataByteLength = FITSParser.getAsciiTablePayloadByteLength(header);
+                    if (dataOffset + dataByteLength > rawData.byteLength) {
+                        throw new Error(`Invalid ASCII TABLE HDU ${hduIndex}: ` +
+                            `expected ${dataByteLength} payload bytes ` +
+                            `at offset ${dataOffset}, but only ` +
+                            `${rawData.byteLength - dataOffset} remain.`);
+                    }
+                    const rawPayload = rawData.subarray(dataOffset, dataOffset + dataByteLength);
+                    const hdu = FITSParser.createAsciiTableHDU(header, rawPayload, dataOffset, dataByteLength);
+                    fitsFile.addHDU(hdu);
+                    offset = dataOffset + FITSParser.getPaddedByteLength(dataByteLength);
+                    break;
+                }
+                default:
+                    throw new Error(`Unsupported FITS HDU type at index ${hduIndex}.`);
+            }
+            hduIndex++;
+        }
+        return fitsFile;
+    }
+    static getPaddedByteLength(byteLength) {
+        if (byteLength === 0) {
+            return 0;
+        }
+        return (Math.ceil(byteLength / ParseHeader.BLOCK_SIZE) * ParseHeader.BLOCK_SIZE);
+    }
+    static isPaddingOnly(rawData, offset) {
+        for (let i = offset; i < rawData.byteLength; i++) {
+            const value = rawData[i];
+            if (value !== 0x00 && value !== 0x20) {
+                return false;
+            }
+        }
+        return true;
+    }
+    static getHDUType(header, index) {
+        if (index === 0) {
+            return "PRIMARY";
+        }
+        const xtension = ParseHeader.getFITSItemStringValue(header, FITSHeaderManager.XTENSION);
+        if (xtension === null) {
+            return "UNKNOWN";
+        }
+        switch (xtension.toUpperCase()) {
+            case "IMAGE":
+                return "IMAGE";
+            case "BINTABLE":
+                return "BINTABLE";
+            case "TABLE":
+                return "TABLE";
+            default:
+                return "UNKNOWN";
+        }
+    }
+    static createImageHDU(header, rawPayload, dataOffset, dataByteLength, primary, options) {
+        const finalHeader = options.computeDataMinMax
+            ? (ParsePayload.computePhysicalMinAndMax(header, rawPayload) ?? header)
+            : header;
+        const bitpix = ParseHeader.getFITSItemValue(finalHeader, FITSHeaderManager.BITPIX);
+        if (bitpix === null) {
+            throw new Error("BITPIX not defined.");
+        }
+        const shape = FITSImageUtils.getShape(finalHeader);
+        const typedData = ParsePayload.createTypedArray(rawPayload, bitpix);
+        if (primary) {
+            return new PrimaryHDU(finalHeader, rawPayload, dataOffset, dataByteLength, bitpix, shape, typedData);
+        }
+        return new ImageHDU(finalHeader, rawPayload, dataOffset, dataByteLength, bitpix, shape, typedData);
+    }
+    static getImagePayloadByteLength(header) {
+        const bitpix = ParseHeader.getFITSItemValue(header, FITSHeaderManager.BITPIX);
+        if (bitpix === null) {
+            throw new Error("BITPIX not defined.");
+        }
+        ParsePayload.assertSupportedBITPIX(bitpix);
+        const shape = FITSImageUtils.getShape(header);
+        if (shape.length === 0) {
+            return 0;
+        }
+        const elementCount = shape.reduce((total, dimension) => total * dimension, 1);
+        const bytesPerElement = Math.abs(bitpix) / 8;
+        return elementCount * bytesPerElement;
+    }
+    static getBinaryTablePayloadByteLength(header) {
+        const rowByteLength = ParseHeader.getFITSItemValue(header, FITSHeaderManager.NAXIS1);
+        const rowCount = ParseHeader.getFITSItemValue(header, FITSHeaderManager.NAXIS2);
+        const pcount = ParseHeader.getFITSItemValue(header, FITSHeaderManager.PCOUNT) ?? 0;
+        if (rowByteLength === null || rowCount === null) {
+            throw new Error("BINTABLE requires NAXIS1 and NAXIS2.");
+        }
+        return rowByteLength * rowCount + pcount;
+    }
+    static getBinaryTableColumns(header) {
+        const fieldCount = ParseHeader.getFITSItemValue(header, FITSHeaderManager.TFIELDS);
+        if (fieldCount === null) {
+            throw new Error("BINTABLE requires TFIELDS.");
+        }
+        const columns = [];
+        let byteOffset = 0;
+        for (let index = 1; index <= fieldCount; index++) {
+            const tform = ParseHeader.getFITSItemStringValue(header, FITSHeaderManager.tableFieldKey("TFORM", index));
+            if (tform === null) {
+                throw new Error(`Missing TFORM${index}.`);
+            }
+            const parsed = FITSBinaryTableUtils.parseTFORM(tform);
+            const name = ParseHeader.getFITSItemStringValue(header, FITSHeaderManager.tableFieldKey("TTYPE", index));
+            const unit = ParseHeader.getFITSItemStringValue(header, FITSHeaderManager.tableFieldKey("TUNIT", index));
+            columns.push({
+                index,
+                name,
+                format: tform,
+                type: FITSParser.mapBinaryType(parsed.code),
+                repeat: parsed.repeat,
+                byteOffset,
+                byteWidth: parsed.byteWidth,
+                unit,
+                scale: ParseHeader.getFITSItemValue(header, FITSHeaderManager.tableFieldKey("TSCAL", index)) ?? 1,
+                zero: ParseHeader.getFITSItemValue(header, FITSHeaderManager.tableFieldKey("TZERO", index)) ?? 0,
+                nullValue: ParseHeader.getFITSItemValue(header, FITSHeaderManager.tableFieldKey("TNULL", index)),
+            });
+            byteOffset += parsed.byteWidth;
+        }
+        return columns;
+    }
+    static mapBinaryType(code) {
+        switch (code.toUpperCase()) {
+            case "L":
+                return "LOGICAL";
+            case "X":
+                return "BIT";
+            case "B":
+                return "UINT8";
+            case "I":
+                return "INT16";
+            case "J":
+                return "INT32";
+            case "K":
+                return "INT64";
+            case "A":
+                return "CHAR";
+            case "E":
+                return "FLOAT32";
+            case "D":
+                return "FLOAT64";
+            case "C":
+                return "COMPLEX64";
+            case "M":
+                return "COMPLEX128";
+            default:
+                return "UNKNOWN";
+        }
+    }
+    static createBinaryTableHDU(header, rawPayload, dataOffset, dataByteLength) {
+        const rowByteLength = ParseHeader.getFITSItemValue(header, FITSHeaderManager.NAXIS1);
+        const rowCount = ParseHeader.getFITSItemValue(header, FITSHeaderManager.NAXIS2);
+        if (rowByteLength === null || rowCount === null) {
+            throw new Error("Invalid BINTABLE header.");
+        }
+        const columns = FITSParser.getBinaryTableColumns(header);
+        const columnsByteWidth = columns.reduce((sum, column) => sum + column.byteWidth, 0);
+        if (columnsByteWidth !== rowByteLength) {
+            throw new Error(`BINTABLE columns occupy ${columnsByteWidth} bytes per row, ` +
+                `but NAXIS1=${rowByteLength}.`);
+        }
+        return new BinaryTableHDU(header, rawPayload, dataOffset, dataByteLength, rowByteLength, rowCount, columns);
+    }
+    static getAsciiTablePayloadByteLength(header) {
+        const rowByteLength = ParseHeader.getFITSItemValue(header, FITSHeaderManager.NAXIS1);
+        const rowCount = ParseHeader.getFITSItemValue(header, FITSHeaderManager.NAXIS2);
+        if (rowByteLength === null || rowCount === null) {
+            throw new Error("ASCII TABLE requires NAXIS1 and NAXIS2.");
+        }
+        if (!Number.isInteger(rowByteLength) || rowByteLength < 0) {
+            throw new Error(`Invalid ASCII TABLE NAXIS1=${rowByteLength}.`);
+        }
+        if (!Number.isInteger(rowCount) || rowCount < 0) {
+            throw new Error(`Invalid ASCII TABLE NAXIS2=${rowCount}.`);
+        }
+        const pcount = ParseHeader.getFITSItemValue(header, FITSHeaderManager.PCOUNT) ?? 0;
+        if (pcount !== 0) {
+            throw new Error(`ASCII TABLE requires PCOUNT=0, received ${pcount}.`);
+        }
+        return rowByteLength * rowCount;
+    }
+    static mapAsciiType(code) {
+        switch (code.toUpperCase()) {
+            case "A":
+                return "CHAR";
+            case "I":
+                return "INTEGER";
+            case "F":
+                return "FLOAT";
+            case "E":
+                return "EXPONENTIAL";
+            case "D":
+                return "DOUBLE";
+            default:
+                return "UNKNOWN";
+        }
+    }
+    static getAsciiTableColumns(header) {
+        const fieldCount = ParseHeader.getFITSItemValue(header, FITSHeaderManager.TFIELDS);
+        if (fieldCount === null) {
+            throw new Error("ASCII TABLE requires TFIELDS.");
+        }
+        if (!Number.isInteger(fieldCount) || fieldCount < 0) {
+            throw new Error(`Invalid ASCII TABLE TFIELDS=${fieldCount}.`);
+        }
+        const columns = [];
+        for (let index = 1; index <= fieldCount; index++) {
+            const tform = ParseHeader.getFITSItemStringValue(header, FITSHeaderManager.tableFieldKey("TFORM", index));
+            if (tform === null) {
+                throw new Error(`Missing TFORM${index}.`);
+            }
+            const tbcol = ParseHeader.getFITSItemValue(header, FITSHeaderManager.tableFieldKey("TBCOL", index));
+            if (tbcol === null) {
+                throw new Error(`Missing TBCOL${index}.`);
+            }
+            if (!Number.isInteger(tbcol) || tbcol < 1) {
+                throw new Error(`Invalid TBCOL${index}=${tbcol}.`);
+            }
+            const parsed = FITSAsciiTableUtils.parseTFORM(tform);
+            const name = ParseHeader.getFITSItemStringValue(header, FITSHeaderManager.tableFieldKey("TTYPE", index));
+            const unit = ParseHeader.getFITSItemStringValue(header, FITSHeaderManager.tableFieldKey("TUNIT", index));
+            columns.push({
+                index,
+                name,
+                format: tform,
+                type: FITSParser.mapAsciiType(parsed.code),
+                startColumn: tbcol,
+                /*
+                 * FITS TBCOL is 1-based.
+                 * JavaScript offsets are 0-based.
+                 */
+                byteOffset: tbcol - 1,
+                width: parsed.width,
+                decimals: parsed.decimals,
+                unit,
+            });
+        }
+        return columns;
+    }
+    static validateAsciiTableColumns(columns, rowByteLength) {
+        for (const column of columns) {
+            const endOffset = column.byteOffset + column.width;
+            if (endOffset > rowByteLength) {
+                throw new Error(`ASCII TABLE column ${column.index} ` +
+                    `extends to byte ${endOffset}, ` +
+                    `but NAXIS1=${rowByteLength}.`);
+            }
+        }
+    }
+    static createAsciiTableHDU(header, rawPayload, dataOffset, dataByteLength) {
+        const rowByteLength = ParseHeader.getFITSItemValue(header, FITSHeaderManager.NAXIS1);
+        const rowCount = ParseHeader.getFITSItemValue(header, FITSHeaderManager.NAXIS2);
+        if (rowByteLength === null || rowCount === null) {
+            throw new Error("Invalid ASCII TABLE header.");
+        }
+        const columns = FITSParser.getAsciiTableColumns(header);
+        FITSParser.validateAsciiTableColumns(columns, rowByteLength);
+        return new AsciiTableHDU(header, rawPayload, dataOffset, dataByteLength, rowByteLength, rowCount, columns);
+    }
+    static createMatrix(payload, header) {
+        const NAXIS1 = ParseHeader.getFITSItemValue(header, FITSHeaderManager.NAXIS1);
+        if (NAXIS1 === null) {
+            throw new Error("NAXIS1 not defined.");
+        }
+        const NAXIS2 = ParseHeader.getFITSItemValue(header, FITSHeaderManager.NAXIS2);
+        if (NAXIS2 === null) {
+            throw new Error("NAXIS2 not defined.");
+        }
+        const BITPIX = ParseHeader.getFITSItemValue(header, FITSHeaderManager.BITPIX);
+        if (BITPIX === null) {
+            throw new Error("BITPIX not defined.");
+        }
+        const bytesXelem = Math.abs(BITPIX / 8);
+        // if (payload.length !== NAXIS1 * NAXIS2 * bytesXelem) {
+        //   throw new Error("Payload size does not match the expected matrix dimensions.");
+        // }
+        // const matrix: Array<Uint8Array> = [];
+        const matrix = [];
+        for (let i = 0; i < NAXIS2; i++) {
+            matrix.push(payload.slice(i * NAXIS1 * bytesXelem, (i + 1) * NAXIS1 * bytesXelem));
+        }
+        return matrix;
+    }
+    /**
+     * @deprecated Legacy FITSParsed writer API.
+     */
+    static saveFITSLocally(fitsParsed, path) {
+        return FITSWriter.writeFITSFile(fitsParsed, path);
+    }
+    static async getFile(uri) {
+        if (!uri.substring(0, 5).toLowerCase().includes("http")) {
+            const p = await __webpack_require__.e(/* import() */ 64).then(__webpack_require__.bind(__webpack_require__, 7064));
+            const rawData = await p.getLocalFile(uri);
+            if (rawData?.length) {
+                const uint8 = new Uint8Array(rawData);
+                return uint8;
+            }
+            return new Uint8Array(0);
+        }
+        else {
+            const p = await __webpack_require__.e(/* import() */ 911).then(__webpack_require__.bind(__webpack_require__, 1911));
+            const rawData = await p.getFile(uri);
+            if (rawData?.byteLength) {
+                const uint8 = new Uint8Array(rawData);
+                return uint8;
+            }
+            return new Uint8Array(0);
+        }
+    }
+}
+// const url = "http://skies.esac.esa.int/Herschel/normalized/PACS_hips160//Norder8/Dir40000/Npix47180.fits"
+// FITSParser.loadFITS(url).then((fits) => {
+//   if (fits == null) {
+//     return null
+//   }
+//   const path = "./fitsTest1.fits"
+//   console.log(fits.header)
+//   FITSParser.saveFITSLocally(fits, path)
+//   console.log("finished")
+// })
+// // const file = "/Users/fabriziogiordano/Desktop/PhD/code/new/FITSParser/tests/inputs/empty.fits"
+// const file = "/Users/fabriziogiordano/Desktop/PhD/code/new/FITSParser/tests/inputs/Npix43348.fits"
+// FITSParser.loadFITS(file).then((fits) => {
+//   if (fits == null) {
+//     return null
+//   }
+//   const path = "./fitsTest2.fits"
+//   console.log(fits.header)
+//   FITSParser.saveFITSLocally(fits, path)
+//   console.log("finished")
+// })
+//# sourceMappingURL=FITSParser.js.map
+;// ./node_modules/jsfitsio/lib-esm/index.js
+
+
+
+
+
+
+
+
+
+
+
+
+//# sourceMappingURL=index.js.map
+
 /***/ }
 
 /******/ 	});
@@ -19293,6 +21763,9 @@ function findCircleThroughTwoPoints(points, q1, q2) {
 /******/ 		return module.exports;
 /******/ 	}
 /******/ 	
+/******/ 	// expose the modules object (__webpack_modules__)
+/******/ 	__webpack_require__.m = __webpack_modules__;
+/******/ 	
 /************************************************************************/
 /******/ 	/* webpack/runtime/define property getters */
 /******/ 	(() => {
@@ -19321,6 +21794,28 @@ function findCircleThroughTwoPoints(points, q1, q2) {
 /******/ 		};
 /******/ 	})();
 /******/ 	
+/******/ 	/* webpack/runtime/ensure chunk */
+/******/ 	(() => {
+/******/ 		__webpack_require__.f = {};
+/******/ 		// This file contains only the entry chunk.
+/******/ 		// The chunk loading function for additional chunks
+/******/ 		__webpack_require__.e = (chunkId) => {
+/******/ 			return Promise.all(Object.keys(__webpack_require__.f).reduce((promises, key) => {
+/******/ 				__webpack_require__.f[key](chunkId, promises);
+/******/ 				return promises;
+/******/ 			}, []));
+/******/ 		};
+/******/ 	})();
+/******/ 	
+/******/ 	/* webpack/runtime/get javascript chunk filename */
+/******/ 	(() => {
+/******/ 		// This function allow to reference async chunks
+/******/ 		__webpack_require__.u = (chunkId) => {
+/******/ 			// return url for filenames based on template
+/******/ 			return "" + chunkId + ".astroviewer.cjs";
+/******/ 		};
+/******/ 	})();
+/******/ 	
 /******/ 	/* webpack/runtime/hasOwnProperty shorthand */
 /******/ 	(() => {
 /******/ 		__webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))
@@ -19337,6 +21832,51 @@ function findCircleThroughTwoPoints(points, q1, q2) {
 /******/ 		};
 /******/ 	})();
 /******/ 	
+/******/ 	/* webpack/runtime/require chunk loading */
+/******/ 	(() => {
+/******/ 		// no baseURI
+/******/ 		
+/******/ 		// object to store loaded chunks
+/******/ 		// "1" means "loaded", otherwise not loaded yet
+/******/ 		const installedChunks = {
+/******/ 			792: 1
+/******/ 		};
+/******/ 		
+/******/ 		// no on chunks loaded
+/******/ 		
+/******/ 		const installChunk = (chunk) => {
+/******/ 			const moreModules = chunk.modules, chunkIds = chunk.ids, runtime = chunk.runtime;
+/******/ 			for(var moduleId in moreModules) {
+/******/ 				if(__webpack_require__.o(moreModules, moduleId)) {
+/******/ 					__webpack_require__.m[moduleId] = moreModules[moduleId];
+/******/ 				}
+/******/ 			}
+/******/ 			if(runtime) runtime(__webpack_require__);
+/******/ 			for(var i = 0; i < chunkIds.length; i++)
+/******/ 				installedChunks[chunkIds[i]] = 1;
+/******/ 		
+/******/ 		};
+/******/ 		
+/******/ 		// require() chunk loading for javascript
+/******/ 		__webpack_require__.f.require = (chunkId, promises) => {
+/******/ 			// "1" is the signal for "already loaded"
+/******/ 			if(!installedChunks[chunkId]) {
+/******/ 				if(true) { // all chunks have JS
+/******/ 					const installedChunk = require("./" + __webpack_require__.u(chunkId));
+/******/ 					if (!installedChunks[chunkId]) {
+/******/ 						installChunk(installedChunk);
+/******/ 					}
+/******/ 				} else installedChunks[chunkId] = 1;
+/******/ 			}
+/******/ 		};
+/******/ 		
+/******/ 		// no external install chunk
+/******/ 		
+/******/ 		// no HMR
+/******/ 		
+/******/ 		// no HMR manifest
+/******/ 	})();
+/******/ 	
 /************************************************************************/
 /******/ 	
 /******/ 	// startup