@niivue/niivue 0.43.2 → 0.43.4

package/build/index.js

@@ -13,7 +13,7 @@ var __publicField = (obj, key, value) => {
 import { mat4 as mat46, vec2, vec3 as vec311, vec4 as vec48 } from "gl-matrix";
 
 // package.json
-var version = "0.43.2";
+var version = "0.43.4";
 
 // src/logger.ts
 var _Log = class _Log {
@@ -170,14 +170,16 @@ var kRenderFunc = `vec3 GetBackPosition(vec3 startPositionTex) {
 	endPosition = endPosition / volScale;
 	return endPosition;
 }
+
 vec4 applyClip (vec3 dir, inout vec4 samplePos, inout float len, inout bool isClip) {
 	float cdot = dot(dir,clipPlane.xyz);
 	isClip = false;
 	if  ((clipPlane.a > 1.0) || (cdot == 0.0)) return samplePos;
 	bool frontface = (cdot > 0.0);
-	float clipThick = 2.0;
 	float dis = (-clipPlane.a - dot(clipPlane.xyz, samplePos.xyz-0.5)) / cdot;
-	float  disBackFace = (-(clipPlane.a-clipThick) - dot(clipPlane.xyz, samplePos.xyz-0.5)) / cdot;
+	float thick = clipThick;
+	if (thick <= 0.0) thick = 2.0;
+	float  disBackFace = (-(clipPlane.a-thick) - dot(clipPlane.xyz, samplePos.xyz-0.5)) / cdot;
 	if (((frontface) && (dis >= len)) || ((!frontface) && (dis <= 0.0))) {
 		samplePos.a = len + 1.0;
 		return samplePos;
@@ -196,6 +198,52 @@ vec4 applyClip (vec3 dir, inout vec4 samplePos, inout float len, inout bool isCl
 	}
 	return samplePos;
 }
+
+void clipVolume(inout vec3 startPos, inout vec3 backPos, int dim, float frac, bool isLo) {
+	vec3 dir = backPos - startPos;
+	float len = length(dir);
+	dir = normalize(dir);
+	// Discard if both startPos and backPos are outside the clipping plane
+	if (isLo && startPos[dim] < frac && backPos[dim] < frac) {
+		discard;
+	}
+	if (!isLo && startPos[dim] > frac && backPos[dim] > frac) {
+		discard;
+	}
+	vec4 plane = vec4(0.0, 0.0, 0.0, 0.5 - frac);
+	plane[dim] = 1.0;
+	float cdot = dot(dir, plane.xyz);
+	float dis = (-plane.w - dot(plane.xyz, startPos - vec3(0.5))) / cdot;
+	// Adjust startPos or backPos based on the intersection with the plane
+	bool isFrontFace = (cdot > 0.0);
+	if (!isLo)
+		isFrontFace = !isFrontFace;
+	if (dis > 0.0) {
+		if (isFrontFace) {
+				if (dis <= len) {
+					startPos = startPos + dir * dis;
+				}
+		} else {
+			if (dis < len) {
+				backPos = startPos + dir * dis;
+			}
+		}
+	}
+}
+
+void clipVolumeStart (inout vec3 startPos, inout vec3 backPos) {
+	// vec3 clipLo = vec3(0.1, 0.2, 0.4);
+	// vec3 clipHi = vec3(0.8, 0.7, 0.7);
+	for (int i = 0; i < 3; i++) {
+		if (clipLo[i] > 0.0)
+			clipVolume(startPos, backPos, i, clipLo[i], true);
+	}
+	for (int i = 0; i < 3; i++) {
+		if (clipHi[i] < 1.0)
+			clipVolume(startPos, backPos, i, clipHi[i], false);
+	}
+}
+
 float frac2ndc(vec3 frac) {
 //https://stackoverflow.com/questions/7777913/how-to-render-depth-linearly-in-modern-opengl-with-gl-fragcoord-z-in-fragment-sh
 	vec4 pos = vec4(frac.xyz, 1.0); //fraction
@@ -207,144 +255,6 @@ float frac2ndc(vec3 frac) {
 	float z_ndc = (mvpMtx * vec4(mm.xyz, 1.0)).z;
 	return (z_ndc + 1.0) / 2.0;
 }` + kDrawFunc;
-var fragRenderShaderMIP = `#version 300 es
-#line 73
-precision highp int;
-precision highp float;
-uniform vec3 rayDir;
-uniform vec3 texVox;
-uniform vec3 volScale;
-uniform vec4 clipPlane;
-uniform highp sampler3D volume, overlay;
-uniform float overlays;
-uniform float backOpacity;
-uniform mat4 mvpMtx;
-uniform mat4 matRAS;
-uniform vec4 clipPlaneColor;
-uniform float renderOverlayBlend;
-uniform highp sampler3D drawing;
-uniform highp sampler2D colormap;
-in vec3 vColor;
-out vec4 fColor;
-` + kRenderFunc + `void main() {
-	fColor = vec4(0.0,0.0,0.0,0.0);
-	//fColor = vec4(vColor.rgb, 1.0); return;
-	vec3 start = vColor;
-	gl_FragDepth = 0.0;
-	vec3 backPosition = GetBackPosition(start);
-	// fColor = vec4(backPosition, 1.0); return;
-	vec3 dir = backPosition - start;
-	float len = length(dir);
-	float lenVox = length((texVox * start) - (texVox * backPosition));
-	if ((lenVox < 0.5) || (len > 3.0)) { //length limit for parallel rays
-		return;
-	}
-	float sliceSize = len / lenVox; //e.g. if ray length is 1.0 and traverses 50 voxels, each voxel is 0.02 in unit cube
-	float stepSize = sliceSize; //quality: larger step is faster traversal, but fewer samples
-	float opacityCorrection = stepSize/sliceSize;
-	dir = normalize(dir);
-	vec4 deltaDir = vec4(dir.xyz * stepSize, stepSize);
-	vec4 samplePos = vec4(start.xyz, 0.0); //ray position
-	float lenNoClip = len;
-	bool isClip = false;
-	vec4 clipPos = applyClip(dir, samplePos, len, isClip);
-	//if ((clipPos.a != samplePos.a) && (len < 3.0)) {
-	//start: OPTIONAL fast pass: rapid traversal until first hit
-	float stepSizeFast = sliceSize * 1.9;
-	vec4 deltaDirFast = vec4(dir.xyz * stepSizeFast, stepSizeFast);
-	while (samplePos.a <= len) {
-		float val = texture(volume, samplePos.xyz).a;
-		if (val > 0.01) break;
-		samplePos += deltaDirFast; //advance ray position
-	}
-	if ((samplePos.a >= len) && (overlays < 1.0)) {
-		if (isClip)
-			fColor += clipPlaneColor;
-		return;
-	}
-	fColor = vec4(1.0, 1.0, 1.0, 1.0);
-	//gl_FragDepth = frac2ndc(samplePos.xyz); //crude due to fast pass resolution
-	samplePos -= deltaDirFast;
-	if (samplePos.a < 0.0)
-		vec4 samplePos = vec4(start.xyz, 0.0); //ray position
-	//end: fast pass
-	vec4 colAcc = vec4(0.0,0.0,0.0,0.0);
-	vec4 firstHit = vec4(0.0,0.0,0.0,2.0 * lenNoClip);
-	const float earlyTermination = 0.95;
-	float backNearest = len; //assume no hit
-	float ran = fract(sin(gl_FragCoord.x * 12.9898 + gl_FragCoord.y * 78.233) * 43758.5453);
-	samplePos += deltaDir * ran; //jitter ray
-	while (samplePos.a <= len) {
-		vec4 colorSample = texture(volume, samplePos.xyz);
-		samplePos += deltaDir; //advance ray position
-		if (colorSample.a >= 0.01) {
-			if (firstHit.a > lenNoClip)
-				firstHit = samplePos;
-			backNearest = min(backNearest, samplePos.a);
-			if (colorSample.a > colAcc.a) //ties generate errors for TT_desai_dd_mpm
-				colAcc = vec4(colorSample.rgb, colorSample.a+0.00001);
-		}
-	}
-	if (firstHit.a < len)
-		gl_FragDepth = frac2ndc(firstHit.xyz);
-	colAcc.a *= backOpacity;
-	fColor = colAcc;
-	if (isClip) //CR
-		fColor.rgb = mix(fColor.rgb, clipPlaneColor.rgb, clipPlaneColor.a * 0.15);
-	if (overlays < 1.0) return;
-	//overlay pass
-	len = lenNoClip;
-	samplePos = vec4(start.xyz, 0.0); //ray position
-	//start: OPTIONAL fast pass: rapid traversal until first hit
-	stepSizeFast = sliceSize * 1.9;
-	deltaDirFast = vec4(dir.xyz * stepSizeFast, stepSizeFast);
-	while (samplePos.a <= len) {
-		float val = texture(overlay, samplePos.xyz).a;
-		if (val > 0.01) break;
-		samplePos += deltaDirFast; //advance ray position
-	}
-	if (samplePos.a >= len) {
-		if (isClip && (fColor.a == 0.0))
-			fColor += clipPlaneColor;
-		return;
-	}
-	samplePos -= deltaDirFast;
-	if (samplePos.a < 0.0)
-		vec4 samplePos = vec4(start.xyz, 0.0); //ray position
-	//end: fast pass
-	float overFarthest = len;
-	colAcc = vec4(0.0, 0.0, 0.0, 0.0);
-	samplePos += deltaDir * ran; //jitter ray
-	vec4 overFirstHit = vec4(0.0,0.0,0.0,2.0 * len);
-	while (samplePos.a <= len) {
-		vec4 colorSample = texture(overlay, samplePos.xyz);
-		samplePos += deltaDir; //advance ray position
-		if (colorSample.a >= 0.01) {
-			if (overFirstHit.a > len)
-				overFirstHit = samplePos;
-			colorSample.a = 1.0-pow((1.0 - colorSample.a), opacityCorrection);
-			colorSample.rgb *= colorSample.a;
-			colAcc= (1.0 - colAcc.a) * colorSample + colAcc;
-			overFarthest = samplePos.a;
-			if ( colAcc.a > earlyTermination )
-				break;
-		}
-	}
-	if (overFirstHit.a < firstHit.a)
-	//if (overFirstHit.a < len)
-		gl_FragDepth = frac2ndc(overFirstHit.xyz);
-	float overMix = colAcc.a;
-	float overlayDepth = 0.3;
-	if (fColor.a <= 0.0)
-			overMix = 1.0;
-	else if (((overFarthest) > backNearest)) {
-		float dx = (overFarthest - backNearest)/1.73;
-		dx = fColor.a * pow(dx, overlayDepth);
-		overMix *= 1.0 - dx;
-	}
-	fColor.rgb = mix(fColor.rgb, colAcc.rgb, overMix);
-	fColor.a = max(fColor.a, colAcc.a);
-}`;
 var kRenderInit = `void main() {
 	if (fColor.x > 2.0) {
 		fColor = vec4(1.0, 0.0, 0.0, 0.5);
@@ -364,8 +274,10 @@ var kRenderInit = `void main() {
 	gl_FragDepth = 0.0;
 	vec3 backPosition = GetBackPosition(start);
 	// fColor = vec4(backPosition, 1.0); return;
-	vec3 dir = backPosition - start;
-	float len = length(dir);
+	vec3 dir = normalize(backPosition - start);
+	clipVolumeStart(start, backPosition);
+	dir = normalize(dir);
+	float len = length(backPosition - start);
 	float lenVox = length((texVox * start) - (texVox * backPosition));
 	if ((lenVox < 0.5) || (len > 3.0)) { //length limit for parallel rays
 		return;
@@ -373,7 +285,6 @@ var kRenderInit = `void main() {
 	float sliceSize = len / lenVox; //e.g. if ray length is 1.0 and traverses 50 voxels, each voxel is 0.02 in unit cube
 	float stepSize = sliceSize; //quality: larger step is faster traversal, but fewer samples
 	float opacityCorrection = stepSize/sliceSize;
-	dir = normalize(dir);
 	vec4 deltaDir = vec4(dir.xyz * stepSize, stepSize);
 	vec4 samplePos = vec4(start.xyz, 0.0); //ray position
 	float lenNoClip = len;
@@ -545,6 +456,9 @@ uniform vec3 volScale;
 uniform vec4 clipPlane;
 uniform highp sampler3D volume, overlay;
 uniform float overlays;
+uniform float clipThick;
+uniform vec3 clipLo;
+uniform vec3 clipHi;
 uniform float backOpacity;
 uniform mat4 mvpMtx;
 uniform mat4 matRAS;
@@ -560,8 +474,9 @@ out vec4 fColor;
 	vec3 start = vColor;
 	gl_FragDepth = 0.0;
 	vec3 backPosition = GetBackPosition(start);
-	vec3 dir = backPosition - start;
-	float len = length(dir);
+	vec3 dir = normalize(backPosition - start);
+	clipVolumeStart(start, backPosition);
+	float len = length(backPosition - start);
 	float lenVox = length((texVox * start) - (texVox * backPosition));
 	if ((lenVox < 0.5) || (len > 3.0)) { //length limit for parallel rays
 		fColor = vec4(0.0,0.0,0.0,0.0);
@@ -570,7 +485,6 @@ out vec4 fColor;
 	float sliceSize = len / lenVox; //e.g. if ray length is 1.0 and traverses 50 voxels, each voxel is 0.02 in unit cube
 	float stepSize = sliceSize; //quality: larger step is faster traversal, but fewer samples
 	float opacityCorrection = stepSize/sliceSize;
-	dir = normalize(dir);
 	vec4 deltaDir = vec4(dir.xyz * stepSize, stepSize);
 	vec4 samplePos = vec4(start.xyz, 0.0); //ray position
 	vec4 colAcc = vec4(0.0,0.0,0.0,0.0);
@@ -624,6 +538,9 @@ uniform vec3 volScale;
 uniform vec4 clipPlane;
 uniform highp sampler3D volume, overlay;
 uniform float overlays;
+uniform float clipThick;
+uniform vec3 clipLo;
+uniform vec3 clipHi;
 uniform float backOpacity;
 uniform mat4 mvpMtx;
 uniform mat4 matRAS;
@@ -660,6 +577,9 @@ uniform vec3 volScale;
 uniform vec4 clipPlane;
 uniform highp sampler3D volume, overlay;
 uniform float overlays;
+uniform float clipThick;
+uniform vec3 clipLo;
+uniform vec3 clipHi;
 uniform float backOpacity;
 uniform mat4 mvpMtx;
 uniform mat4 normMtx;
@@ -1495,6 +1415,28 @@ void main() {
 	float lightNormDot = max(dot(normalize(vN), l), 0.0);
 	color = vec4(lightNormDot * vClr.rgb * diffuse, opacity);
 }`;
+var fragMeshSpecularEdgeShader = `#version 300 es
+precision highp int;
+precision highp float;
+uniform float opacity;
+in vec4 vClr;
+in vec3 vN;
+out vec4 color;
+void main() {
+	float specularRGB = 0.7;
+	float specularWhite = 0.3;
+	float shininess = 10.0;
+	float diffuse = 1.0;
+	vec3 r = vec3(0.0, 0.0, 1.0); //rayDir: for orthographic projections moving in Z direction (no need for normal matrix)
+	vec3 n = normalize(vN);
+	vec3 l = vec3(0.0, 0.0, -1.0);
+	float lightNormDot = max(dot(n, l), 0.0);
+	vec3 d3 = lightNormDot * vClr.rgb * diffuse;
+	float s = pow(max(dot(reflect(l, n), r), 0.0), shininess);
+	vec3 s3 = specularRGB * s * vClr.rgb;
+	s *= specularWhite;
+	color = vec4(d3 + s3 + s, opacity);
+}`;
 var fragMeshShader = `#version 300 es
 precision highp int;
 precision highp float;
@@ -1679,6 +1621,9 @@ uniform vec3 texVox;
 uniform vec4 clipPlane;
 uniform highp sampler3D volume, overlay;
 uniform float overlays;
+uniform float clipThick;
+uniform vec3 clipLo;
+uniform vec3 clipHi;
 uniform mat4 matRAS;
 uniform mat4 mvpMtx;
 uniform float drawOpacity, renderOverlayBlend;
@@ -1695,8 +1640,9 @@ void main() {
 	fColor = vec4(0.0, 0.0, 0.0, 0.0); //assume no hit: ID = 0
 	float fid = float(id & 255)/ 255.0;
 	vec3 backPosition = GetBackPosition(start);
-	vec3 dir = backPosition - start;
-	float len = length(dir);
+	vec3 dir = normalize(backPosition - start);
+	clipVolumeStart(start, backPosition);
+	float len = length(backPosition - start);
 	float lenVox = length((texVox * start) - (texVox * backPosition));
 	if ((lenVox < 0.5) || (len > 3.0)) return;//discard; //length limit for parallel rays
 	float sliceSize = len / lenVox; //e.g. if ray length is 1.0 and traverses 50 voxels, each voxel is 0.02 in unit cube
@@ -3292,7 +3238,7 @@ __publicField(_NiivueObject3D, "makeColoredSphere", function(vertices, indices,
 var NiivueObject3D = _NiivueObject3D;
 
 // src/nvmesh.ts
-import { vec3 as vec34, vec4 as vec43 } from "gl-matrix";
+import { vec3 as vec35, vec4 as vec44 } from "gl-matrix";
 import { v4 as uuidv4 } from "@lukeed/uuid";
 
 // src/cmaps/index.js
@@ -11450,8 +11396,257 @@ var NVMeshUtilities = class {
 };
 
 // src/nvmesh-loaders.ts
-import { mat4 as mat42, vec4 as vec42, vec3 as vec33 } from "gl-matrix";
-import { decompressSync, unzipSync } from "fflate/browser";
+import { mat4 as mat43, vec4 as vec43, vec3 as vec34 } from "gl-matrix";
+import { decompressSync as decompressSync2, unzipSync } from "fflate/browser";
+
+// src/nvutilities.ts
+import arrayEqual from "array-equal";
+import { compress, decompress, decompressSync, strFromU8, strToU8 } from "fflate/browser";
+import { mat4 as mat42, vec3 as vec33, vec4 as vec42 } from "gl-matrix";
+var NVUtilities = class _NVUtilities {
+  static arrayBufferToBase64(arrayBuffer) {
+    const bytes = new Uint8Array(arrayBuffer);
+    return _NVUtilities.uint8tob64(bytes);
+  }
+  static readMatV4(buffer) {
+    let len = buffer.byteLength;
+    if (len < 40) {
+      throw new Error("File too small to be MAT v4: bytes = " + buffer.byteLength);
+    }
+    let reader = new DataView(buffer);
+    let magic = reader.getUint16(0, true);
+    let _buffer = buffer;
+    if (magic === 35615 || magic === 8075) {
+      const raw = decompressSync(new Uint8Array(buffer));
+      reader = new DataView(raw.buffer);
+      magic = reader.getUint16(0, true);
+      _buffer = raw.buffer;
+      len = _buffer.byteLength;
+    }
+    const textDecoder = new TextDecoder("utf-8");
+    const bytes = new Uint8Array(_buffer);
+    let pos = 0;
+    const mat = {};
+    function getTensDigit(v) {
+      return Math.floor(v / 10) % 10;
+    }
+    function readArray(tagDataType, tagBytesStart, tagBytesEnd) {
+      const byteArray = new Uint8Array(bytes.subarray(tagBytesStart, tagBytesEnd));
+      if (tagDataType === 1) {
+        return new Float32Array(byteArray.buffer);
+      }
+      if (tagDataType === 2) {
+        return new Int32Array(byteArray.buffer);
+      }
+      if (tagDataType === 3) {
+        return new Int16Array(byteArray.buffer);
+      }
+      if (tagDataType === 4) {
+        return new Uint16Array(byteArray.buffer);
+      }
+      if (tagDataType === 5) {
+        return new Uint8Array(byteArray.buffer);
+      }
+      return new Float64Array(byteArray.buffer);
+    }
+    function readTag() {
+      const mtype = reader.getUint32(pos, true);
+      const mrows = reader.getUint32(pos + 4, true);
+      const ncols = reader.getUint32(pos + 8, true);
+      const imagf = reader.getUint32(pos + 12, true);
+      const namlen = reader.getUint32(pos + 16, true);
+      pos += 20;
+      if (imagf !== 0) {
+        throw new Error("Matlab V4 reader does not support imaginary numbers");
+      }
+      const tagArrayItems = mrows * ncols;
+      if (tagArrayItems < 1) {
+        throw new Error("mrows * ncols must be greater than one");
+      }
+      const byteArray = new Uint8Array(bytes.subarray(pos, pos + namlen));
+      const tagName = textDecoder.decode(byteArray).trim().replaceAll("\0", "");
+      const tagDataType = getTensDigit(mtype);
+      let tagBytesPerItem = 8;
+      if (tagDataType >= 1 && tagDataType <= 2) {
+        tagBytesPerItem = 4;
+      } else if (tagDataType >= 3 && tagDataType <= 4) {
+        tagBytesPerItem = 2;
+      } else if (tagDataType === 5) {
+        tagBytesPerItem = 1;
+      } else if (tagDataType !== 0) {
+        throw new Error("impossible Matlab v4 datatype");
+      }
+      pos += namlen;
+      if (mtype > 50) {
+        throw new Error("Does not appear to be little-endian V4 Matlab file");
+      }
+      const posEnd = pos + tagArrayItems * tagBytesPerItem;
+      mat[tagName] = readArray(tagDataType, pos, posEnd);
+      pos = posEnd;
+    }
+    while (pos + 20 < len) {
+      readTag();
+    }
+    return mat;
+  }
+  // readMatV4()
+  /*
+  https://gist.github.com/jonleighton/958841
+  MIT LICENSE
+  Copyright 2011 Jon Leighton
+  Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+  The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+  */
+  static uint8tob64(bytes) {
+    let base64 = "";
+    const encodings = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+    const byteLength = bytes.byteLength;
+    const byteRemainder = byteLength % 3;
+    const mainLength = byteLength - byteRemainder;
+    let a, b, c, d;
+    let chunk;
+    for (let i = 0; i < mainLength; i = i + 3) {
+      chunk = bytes[i] << 16 | bytes[i + 1] << 8 | bytes[i + 2];
+      a = (chunk & 16515072) >> 18;
+      b = (chunk & 258048) >> 12;
+      c = (chunk & 4032) >> 6;
+      d = chunk & 63;
+      base64 += encodings[a] + encodings[b] + encodings[c] + encodings[d];
+    }
+    if (byteRemainder === 1) {
+      chunk = bytes[mainLength];
+      a = (chunk & 252) >> 2;
+      b = (chunk & 3) << 4;
+      base64 += encodings[a] + encodings[b] + "==";
+    } else if (byteRemainder === 2) {
+      chunk = bytes[mainLength] << 8 | bytes[mainLength + 1];
+      a = (chunk & 64512) >> 10;
+      b = (chunk & 1008) >> 4;
+      c = (chunk & 15) << 2;
+      base64 += encodings[a] + encodings[b] + encodings[c] + "=";
+    }
+    return base64;
+  }
+  // https://stackoverflow.com/questions/34156282/how-do-i-save-json-to-local-text-file
+  static download(content, fileName, contentType) {
+    const a = document.createElement("a");
+    const contentArray = Array.isArray(content) ? content : [content];
+    const file = new Blob(contentArray, { type: contentType });
+    a.href = URL.createObjectURL(file);
+    a.download = fileName;
+    a.click();
+  }
+  static readFileAsync(file) {
+    return new Promise((resolve, reject) => {
+      const reader = new FileReader();
+      reader.onload = () => {
+        resolve(reader.result);
+      };
+      reader.onerror = reject;
+      reader.readAsArrayBuffer(file);
+    });
+  }
+  static blobToBase64(blob) {
+    return new Promise((resolve) => {
+      const reader = new FileReader();
+      reader.onloadend = () => resolve(reader.result);
+      reader.readAsDataURL(blob);
+    });
+  }
+  static async decompressBase64String(base64) {
+    const compressed = atob(base64);
+    const compressedBuffer = new ArrayBuffer(compressed.length);
+    const compressedView = new Uint8Array(compressedBuffer);
+    for (let i = 0; i < compressed.length; i++) {
+      compressedView[i] = compressed.charCodeAt(i);
+    }
+    return _NVUtilities.decompressArrayBuffer(compressedView);
+  }
+  static async compressToBase64String(string) {
+    const buf = await _NVUtilities.compressStringToArrayBuffer(string);
+    return _NVUtilities.uint8tob64(new Uint8Array(buf));
+  }
+  static async compressStringToArrayBuffer(input) {
+    return new Promise((resolve, reject) => {
+      const uint8Array = strToU8(input);
+      compress(uint8Array, (err, compressed) => {
+        if (err) {
+          reject(err);
+        } else {
+          resolve(compressed.buffer);
+        }
+      });
+    });
+  }
+  static isArrayBufferCompressed(buffer) {
+    if (buffer && buffer.byteLength) {
+      const arr = new Uint8Array(buffer);
+      const magicNumber = arr[0] << 8 | arr[1];
+      return magicNumber === 8075;
+    } else {
+      return false;
+    }
+  }
+  static async decompressArrayBuffer(buffer) {
+    return new Promise((resolve, reject) => {
+      const uint8Array = new Uint8Array(buffer);
+      decompress(uint8Array, (err, decompressed) => {
+        if (err) {
+          reject(err);
+        } else {
+          const result = strFromU8(decompressed);
+          resolve(result);
+        }
+      });
+    });
+  }
+  static arraysAreEqual(a, b) {
+    return arrayEqual(a, b);
+  }
+  /**
+   * Generate a pre-filled number array.
+   *
+   * @param start - start value
+   * @param stop - stop value
+   * @param step - step value
+   * @returns filled number array
+   */
+  static range(start, stop, step) {
+    return Array.from({ length: (stop - start) / step + 1 }, (_, i) => start + i * step);
+  }
+  /**
+   * convert spherical AZIMUTH, ELEVATION to Cartesian
+   * @param azimuth - azimuth number
+   * @param elevation - elevation number
+   * @returns the converted [x, y, z] coordinates
+   * @example
+   * xyz = NVUtilities.sph2cartDeg(42, 42)
+   */
+  static sph2cartDeg(azimuth, elevation) {
+    const Phi = -elevation * (Math.PI / 180);
+    const Theta = (azimuth - 90) % 360 * (Math.PI / 180);
+    const ret = [Math.cos(Phi) * Math.cos(Theta), Math.cos(Phi) * Math.sin(Theta), Math.sin(Phi)];
+    const len = Math.sqrt(ret[0] * ret[0] + ret[1] * ret[1] + ret[2] * ret[2]);
+    if (len <= 0) {
+      return ret;
+    }
+    ret[0] /= len;
+    ret[1] /= len;
+    ret[2] /= len;
+    return ret;
+  }
+  static vox2mm(XYZ, mtx) {
+    const sform = mat42.clone(mtx);
+    mat42.transpose(sform, sform);
+    const pos = vec42.fromValues(XYZ[0], XYZ[1], XYZ[2], 1);
+    vec42.transformMat4(pos, pos, sform);
+    const pos3 = vec33.fromValues(pos[0], pos[1], pos[2]);
+    return pos3;
+  }
+};
+
+// src/nvmesh-loaders.ts
 var utiltiesLogger = log;
 var NVMeshLoaders = class _NVMeshLoaders {
   // read undocumented AFNI tract.niml format streamlines
@@ -11535,90 +11730,9 @@ var NVMeshLoaders = class _NVMeshLoaders {
   // https://dsi-studio.labsolver.org/doc/cli_data.html
   // https://brain.labsolver.org/hcp_trk_atlas.html
   static readTT(buffer) {
-    function readMatV4(buffer2) {
-      let len = buffer2.byteLength;
-      if (len < 40) {
-        throw new Error("File too small to be MAT v4: bytes = " + buffer2.byteLength);
-      }
-      let reader = new DataView(buffer2);
-      let magic = reader.getUint16(0, true);
-      let _buffer = buffer2;
-      if (magic === 35615 || magic === 8075) {
-        const raw = decompressSync(new Uint8Array(buffer2));
-        reader = new DataView(raw.buffer);
-        magic = reader.getUint16(0, true);
-        _buffer = raw.buffer;
-        len = _buffer.byteLength;
-      }
-      const textDecoder = new TextDecoder("utf-8");
-      const bytes = new Uint8Array(_buffer);
-      let pos = 0;
-      const mat2 = {};
-      function getTensDigit(v) {
-        return Math.floor(v / 10) % 10;
-      }
-      function readArray(tagDataType, tagBytesStart, tagBytesEnd) {
-        const byteArray = new Uint8Array(bytes.subarray(tagBytesStart, tagBytesEnd));
-        if (tagDataType === 1) {
-          return new Float32Array(byteArray.buffer);
-        }
-        if (tagDataType === 2) {
-          return new Int32Array(byteArray.buffer);
-        }
-        if (tagDataType === 3) {
-          return new Int16Array(byteArray.buffer);
-        }
-        if (tagDataType === 4) {
-          return new Uint16Array(byteArray.buffer);
-        }
-        if (tagDataType === 5) {
-          return new Uint8Array(byteArray.buffer);
-        }
-        return new Float64Array(byteArray.buffer);
-      }
-      function readTag() {
-        const mtype = reader.getUint32(pos, true);
-        const mrows = reader.getUint32(pos + 4, true);
-        const ncols = reader.getUint32(pos + 8, true);
-        const imagf = reader.getUint32(pos + 12, true);
-        const namlen = reader.getUint32(pos + 16, true);
-        pos += 20;
-        if (imagf !== 0) {
-          throw new Error("Matlab V4 reader does not support imaginary numbers");
-        }
-        const tagArrayItems = mrows * ncols;
-        if (tagArrayItems < 1) {
-          throw new Error("mrows * ncols must be greater than one");
-        }
-        const byteArray = new Uint8Array(bytes.subarray(pos, pos + namlen));
-        const tagName = textDecoder.decode(byteArray).trim().replaceAll("\0", "");
-        const tagDataType = getTensDigit(mtype);
-        let tagBytesPerItem = 8;
-        if (tagDataType >= 1 && tagDataType <= 2) {
-          tagBytesPerItem = 4;
-        } else if (tagDataType >= 3 && tagDataType <= 4) {
-          tagBytesPerItem = 2;
-        } else if (tagDataType === 5) {
-          tagBytesPerItem = 1;
-        } else if (tagDataType !== 0) {
-          throw new Error("impossible Matlab v4 datatype");
-        }
-        pos += namlen;
-        if (mtype > 50) {
-          throw new Error("Does not appear to be little-endian V4 Matlab file");
-        }
-        const posEnd = pos + tagArrayItems * tagBytesPerItem;
-        mat2[tagName] = readArray(tagDataType, pos, posEnd);
-        pos = posEnd;
-      }
-      while (pos + 20 < len) {
-        readTag();
-      }
-      return mat2;
-    }
     let offsetPt0 = new Uint32Array(0);
     let pts = new Float32Array(0);
-    const mat = readMatV4(buffer);
+    const mat = NVUtilities.readMatV4(buffer);
     if (!("trans_to_mni" in mat)) {
       throw new Error("TT format file must have 'trans_to_mni'");
     }
@@ -11628,9 +11742,9 @@ var NVMeshLoaders = class _NVMeshLoaders {
     if (!("track" in mat)) {
       throw new Error("TT format file must have 'track'");
     }
-    let trans_to_mni = mat42.create();
+    let trans_to_mni = mat43.create();
     const m = mat.trans_to_mni;
-    trans_to_mni = mat42.fromValues(
+    trans_to_mni = mat43.fromValues(
       m[0],
       m[1],
       m[2],
@@ -11648,7 +11762,7 @@ var NVMeshLoaders = class _NVMeshLoaders {
       m[14],
       m[15]
     );
-    mat42.transpose(trans_to_mni, trans_to_mni);
+    mat43.transpose(trans_to_mni, trans_to_mni);
     function parse_tt(track) {
       const dv = new DataView(track.buffer);
       const pos = [];
@@ -11688,8 +11802,8 @@ var NVMeshLoaders = class _NVMeshLoaders {
       }
       let v = 0;
       for (let i2 = 0; i2 < npt / 3; i2++) {
-        const pos2 = vec42.fromValues(pts[v], pts[v + 1], pts[v + 2], 1);
-        vec42.transformMat4(pos2, pos2, trans_to_mni);
+        const pos2 = vec43.fromValues(pts[v], pts[v + 1], pts[v + 2], 1);
+        vec43.transformMat4(pos2, pos2, trans_to_mni);
         pts[v++] = pos2[0];
         pts[v++] = pos2[1];
         pts[v++] = pos2[2];
@@ -11975,7 +12089,7 @@ var NVMeshLoaders = class _NVMeshLoaders {
       if (magic === 4247762216) {
         throw new Error("zstd TRK decompression is not supported");
       } else {
-        raw = decompressSync(new Uint8Array(buffer));
+        raw = decompressSync2(new Uint8Array(buffer));
       }
       buffer = raw.buffer;
       reader = new DataView(buffer);
@@ -12000,7 +12114,7 @@ var NVMeshLoaders = class _NVMeshLoaders {
     const voxel_sizeX = reader.getFloat32(12, true);
     const voxel_sizeY = reader.getFloat32(16, true);
     const voxel_sizeZ = reader.getFloat32(20, true);
-    const zoomMat = mat42.fromValues(
+    const zoomMat = mat43.fromValues(
       1 / voxel_sizeX,
       0,
       0,
@@ -12029,16 +12143,16 @@ var NVMeshLoaders = class _NVMeshLoaders {
         vals: []
       });
     }
-    const mat = mat42.create();
+    const mat = mat43.create();
     for (let i2 = 0; i2 < 16; i2++) {
       mat[i2] = reader.getFloat32(440 + i2 * 4, true);
     }
     if (mat[15] === 0) {
       log.warn("TRK vox_to_ras not set");
-      mat42.identity(mat);
+      mat43.identity(mat);
     }
-    const vox2mmMat = mat42.create();
-    mat42.mul(vox2mmMat, zoomMat, mat);
+    const vox2mmMat = mat43.create();
+    mat43.mul(vox2mmMat, zoomMat, mat);
     let i32 = null;
     let f32 = null;
     i32 = new Int32Array(buffer.slice(hdr_sz));
@@ -12180,7 +12294,7 @@ var NVMeshLoaders = class _NVMeshLoaders {
         }
         pts = Array.from(positions);
       } else {
-        let lineToInts2 = function() {
+        let lineToInts = function() {
           str = lines[pos].trim();
           const items2 = str.trim().split(/\s+/);
           asciiInts = [];
@@ -12190,22 +12304,21 @@ var NVMeshLoaders = class _NVMeshLoaders {
           asciiIntsPos = 0;
           pos++;
         };
-        var lineToInts = lineToInts2;
         let npt = 0;
         offsetPt0[0] = 0;
         let asciiInts = [];
         let asciiIntsPos = 0;
-        lineToInts2();
+        lineToInts();
         for (let c = 0; c < n_count; c++) {
           if (asciiIntsPos >= asciiInts.length) {
-            lineToInts2();
+            lineToInts();
           }
           const numPoints = asciiInts[asciiIntsPos++];
           npt += numPoints;
           offsetPt0[c + 1] = npt;
           for (let i = 0; i < numPoints; i++) {
             if (asciiIntsPos >= asciiInts.length) {
-              lineToInts2();
+              lineToInts();
             }
             const idx = asciiInts[asciiIntsPos++] * 3;
             pts.push(positions[idx + 0]);
@@ -12400,7 +12513,7 @@ var NVMeshLoaders = class _NVMeshLoaders {
     let reader = new DataView(buffer);
     let vers = reader.getUint16(0, true);
     if (vers > 5) {
-      const raw = decompressSync(new Uint8Array(buffer));
+      const raw = decompressSync2(new Uint8Array(buffer));
       reader = new DataView(raw.buffer);
       vers = reader.getUint16(0, true);
       buffer = raw.buffer;
@@ -13007,7 +13120,7 @@ var NVMeshLoaders = class _NVMeshLoaders {
     let magic = reader.getUint16(0, true);
     let _buffer = buffer;
     if (magic === 35615 || magic === 8075) {
-      const raw = decompressSync(new Uint8Array(buffer));
+      const raw = decompressSync2(new Uint8Array(buffer));
       reader = new DataView(raw.buffer);
       magic = reader.getUint16(0, true);
       _buffer = raw.buffer;
@@ -13670,7 +13783,7 @@ var NVMeshLoaders = class _NVMeshLoaders {
       return _NVMeshLoaders.readASC(buffer);
     }
     if (bytes[0] === 31 && bytes[1] === 139) {
-      const raw = decompressSync(new Uint8Array(buffer));
+      const raw = decompressSync2(new Uint8Array(buffer));
       buffer = raw.buffer;
     }
     const reader = new DataView(buffer);
@@ -13855,7 +13968,7 @@ var NVMeshLoaders = class _NVMeshLoaders {
       nvert *= dim[i];
     }
     if (intent_code >= 3e3 && intent_code <= 3099 && voxoffset > 580) {
-      let readStrX2 = function() {
+      let readStrX = function() {
         while (pos < len && bytes[pos] === 10) {
           pos++;
         }
@@ -13868,16 +13981,16 @@ var NVMeshLoaders = class _NVMeshLoaders {
           return "";
         }
         return new TextDecoder().decode(buffer.slice(startPos, pos - 1)).trim();
-      }, readStr2 = function() {
-        let line2 = readStrX2();
+      }, readStr = function() {
+        let line2 = readStrX();
         if (!line2.startsWith("<") || line2.endsWith(">")) {
           return line2;
         }
         while (pos < len && !line2.endsWith(">")) {
-          line2 += readStrX2();
+          line2 += readStrX();
         }
         return line2;
-      }, readNumericTag2 = function(TagName, asString = false) {
+      }, readNumericTag = function(TagName, asString = false) {
         const tpos = line.indexOf(TagName);
         if (tpos < 0) {
           return 1;
@@ -13890,7 +14003,6 @@ var NVMeshLoaders = class _NVMeshLoaders {
         }
         return parseInt(str);
       };
-      var readStrX = readStrX2, readStr = readStr2, readNumericTag = readNumericTag2;
       let indexOffset = 0;
       let indexCount = 0;
       let surfaceNumberOfVertices = 0;
@@ -13902,13 +14014,13 @@ var NVMeshLoaders = class _NVMeshLoaders {
       const nFrame4D = dim[5];
       const scalars2 = new Float32Array(n_vert * nFrame4D);
       while (pos < len) {
-        line = readStr2();
+        line = readStr();
         if (line.includes("</CIFTI>")) {
           break;
         }
         if (line.includes("<BrainModel")) {
-          const nv = readNumericTag2("SurfaceNumberOfVertices=");
-          const bStruct = readNumericTag2("BrainStructure=", true).toUpperCase();
+          const nv = readNumericTag("SurfaceNumberOfVertices=");
+          const bStruct = readNumericTag("BrainStructure=", true).toUpperCase();
           if (nv % n_vert !== 0) {
             continue;
           }
@@ -13930,11 +14042,11 @@ var NVMeshLoaders = class _NVMeshLoaders {
             continue;
           }
           surfaceNumberOfVertices = nv;
-          indexOffset = readNumericTag2("IndexOffset=");
-          indexCount = readNumericTag2("IndexCount=");
+          indexOffset = readNumericTag("IndexOffset=");
+          indexCount = readNumericTag("IndexCount=");
           brainStructure = bStruct;
           if (!line.includes("<VertexIndices>")) {
-            line = readStr2();
+            line = readStr();
           }
           if (!line.startsWith("<VertexIndices>") || !line.endsWith("</VertexIndices>")) {
             log.warn("Unable to find CIfTI <VertexIndices>");
@@ -14032,7 +14144,7 @@ var NVMeshLoaders = class _NVMeshLoaders {
       magic = reader.getUint16(0, isLittleEndian);
     }
     if (magic !== 348) {
-      const raw = decompressSync(new Uint8Array(buffer));
+      const raw = decompressSync2(new Uint8Array(buffer));
       reader = new DataView(raw.buffer);
       buffer = raw.buffer;
       magic = reader.getUint16(0, isLittleEndian);
@@ -14103,7 +14215,7 @@ var NVMeshLoaders = class _NVMeshLoaders {
     let reader = new DataView(buffer);
     let raw = buffer;
     if (reader.getUint8(0) === 31 && reader.getUint8(1) === 139) {
-      const decompressed = decompressSync(new Uint8Array(buffer));
+      const decompressed = decompressSync2(new Uint8Array(buffer));
       raw = new ArrayBuffer(decompressed.byteLength);
       new Uint8Array(raw).set(new Uint8Array(decompressed));
       reader = new DataView(decompressed.buffer);
@@ -14461,16 +14573,16 @@ var NVMeshLoaders = class _NVMeshLoaders {
         } else if (height < 0) {
           NiivueObject3D.makeColoredSphere(positions, indices, rgba255, radius, translation, rgba);
         } else {
-          const r = mat42.create();
-          mat42.fromRotation(r, rotation[3], [rotation[0], rotation[1], rotation[2]]);
-          const pti = vec42.fromValues(0, -height * 0.5, 0, 1);
-          const ptj = vec42.fromValues(0, +height * 0.5, 0, 1);
-          vec42.transformMat4(pti, pti, r);
-          vec42.transformMat4(ptj, ptj, r);
-          vec42.add(pti, pti, translation);
-          vec42.add(ptj, ptj, translation);
-          const pti3 = vec33.fromValues(pti[0], pti[1], pti[2]);
-          const ptj3 = vec33.fromValues(ptj[0], ptj[1], ptj[2]);
+          const r = mat43.create();
+          mat43.fromRotation(r, rotation[3], [rotation[0], rotation[1], rotation[2]]);
+          const pti = vec43.fromValues(0, -height * 0.5, 0, 1);
+          const ptj = vec43.fromValues(0, +height * 0.5, 0, 1);
+          vec43.transformMat4(pti, pti, r);
+          vec43.transformMat4(ptj, ptj, r);
+          vec43.add(pti, pti, translation);
+          vec43.add(ptj, ptj, translation);
+          const pti3 = vec34.fromValues(pti[0], pti[1], pti[2]);
+          const ptj3 = vec34.fromValues(ptj[0], ptj[1], ptj[2]);
           NiivueObject3D.makeColoredCylinder(positions, indices, rgba255, pti3, ptj3, radius, rgba);
         }
       }
@@ -14491,7 +14603,7 @@ var NVMeshLoaders = class _NVMeshLoaders {
     }
     let chars = new TextDecoder("ascii").decode(buffer);
     if (chars[0].charCodeAt(0) === 31) {
-      const raw = decompressSync(new Uint8Array(buffer));
+      const raw = decompressSync2(new Uint8Array(buffer));
       buffer = raw.buffer;
       chars = new TextDecoder("ascii").decode(raw.buffer);
     }
@@ -14629,7 +14741,7 @@ var NVMeshLoaders = class _NVMeshLoaders {
             }
           }
         } else if (typeof Buffer === "undefined") {
-          let base64ToUint82 = function(base64) {
+          let base64ToUint8 = function(base64) {
             const binary_string = atob(base64);
             const len2 = binary_string.length;
             const bytes = new Uint8Array(len2);
@@ -14638,17 +14750,16 @@ var NVMeshLoaders = class _NVMeshLoaders {
             }
             return bytes;
           };
-          var base64ToUint8 = base64ToUint82;
           if (isGzip) {
-            const datZ = base64ToUint82(line.slice());
-            datBin = decompressSync(new Uint8Array(datZ));
+            const datZ = base64ToUint8(line.slice());
+            datBin = decompressSync2(new Uint8Array(datZ));
           } else {
-            datBin = base64ToUint82(line.slice());
+            datBin = base64ToUint8(line.slice());
           }
         } else {
           if (isGzip) {
             const datZ = Buffer.from(line.slice(), "base64");
-            datBin = decompressSync(new Uint8Array(datZ));
+            datBin = decompressSync2(new Uint8Array(datZ));
           } else {
             datBin = Buffer.from(line.slice(), "base64");
           }
@@ -14686,14 +14797,13 @@ var NVMeshLoaders = class _NVMeshLoaders {
             }
           }
         } else {
-          let Float32Concat2 = function(first, second) {
+          let Float32Concat = function(first, second) {
             const firstLength = first.length;
             const result = new Float32Array(firstLength + second.length);
             result.set(first);
             result.set(second, firstLength);
             return result;
           };
-          var Float32Concat = Float32Concat2;
           nvert = Dims[0] * Dims[1] * Dims[2];
           if (n_vert !== 0) {
             if (nvert % n_vert !== 0) {
@@ -14715,7 +14825,7 @@ var NVMeshLoaders = class _NVMeshLoaders {
           } else {
             throw new Error(`Invalid dataType: ${dataType}`);
           }
-          scalars = Float32Concat2(scalars, scalarsNew);
+          scalars = Float32Concat(scalars, scalarsNew);
         }
         continue;
       }
@@ -14879,6 +14989,7 @@ var NVMesh2 = class _NVMesh {
     __publicField(this, "rgba255");
     __publicField(this, "fiberLength");
     __publicField(this, "fiberLengths");
+    __publicField(this, "fiberDensity");
     __publicField(this, "fiberDither", 0.1);
     __publicField(this, "fiberColor", "Global");
     __publicField(this, "fiberDecimationStride", 1);
@@ -14887,6 +14998,8 @@ var NVMesh2 = class _NVMesh {
     // 1=streamline, 2=imposter, >2=mesh(cylinder with fiberSides sides)
     __publicField(this, "fiberRadius", 0);
     // in mm, e.g. 3 means 6mm diameter fibers, ignored if fiberSides < 3
+    __publicField(this, "fiberOcclusion", 0);
+    // value 0..1 to simulate ambient occlusion
     __publicField(this, "f32PerVertex", 5);
     // MUST be 5 or 7: number of float32s per vertex DEPRECATED, future releases will ALWAYS be 5
     __publicField(this, "fiberMask");
@@ -14974,7 +15087,8 @@ var NVMesh2 = class _NVMesh {
       if (dpv) {
         this.initValuesArray(dpv);
       }
-      this.offsetPt0 = tris;
+      this.offsetPt0 = new Uint32Array(tris);
+      this.tris = new Uint32Array(0);
       this.updateFibers(gl);
       gl.bindVertexArray(this.vaoFiber);
       gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, this.indexBuffer);
@@ -15011,7 +15125,7 @@ var NVMesh2 = class _NVMesh {
   // given streamlines (which webGL renders as a single pixel), extrude to cylinders
   linesToCylinders(gl, posClrF32, indices) {
     function v4ToV3(v4) {
-      return vec34.fromValues(v4[0], v4[1], v4[2]);
+      return vec35.fromValues(v4[0], v4[1], v4[2]);
     }
     const primitiveRestart = Math.pow(2, 32) - 1;
     const n_count = indices.length;
@@ -15033,11 +15147,11 @@ var NVMesh2 = class _NVMesh {
     const f32 = new Float32Array(npt * f32PerVertex);
     const u8 = new Uint8Array(f32.buffer);
     let vtx = 0;
-    let prevV4 = vec43.create();
-    let currV4 = vec43.create();
-    let nextV4 = vec43.create();
-    const v1 = vec34.create();
-    let prevV2 = vec34.create();
+    let prevV4 = vec44.create();
+    let currV4 = vec44.create();
+    let nextV4 = vec44.create();
+    const v1 = vec35.create();
+    let prevV2 = vec35.create();
     let node = 0;
     const radius = this.fiberRadius;
     for (let i = 0; i < n_count; i++) {
@@ -15048,47 +15162,47 @@ var NVMesh2 = class _NVMesh {
       let idx2 = indices[i] * 4;
       node++;
       if (node <= 1) {
-        prevV4 = vec43.fromValues(posClrF32[idx2 + 0], posClrF32[idx2 + 1], posClrF32[idx2 + 2], posClrF32[idx2 + 3]);
-        currV4 = vec43.clone(prevV4);
+        prevV4 = vec44.fromValues(posClrF32[idx2 + 0], posClrF32[idx2 + 1], posClrF32[idx2 + 2], posClrF32[idx2 + 3]);
+        currV4 = vec44.clone(prevV4);
         if (i + 1 < n_count && indices[i + 1] !== primitiveRestart) {
           idx2 = indices[i + 1] * 4;
-          nextV4 = vec43.fromValues(posClrF32[idx2 + 0], posClrF32[idx2 + 1], posClrF32[idx2 + 2], posClrF32[idx2 + 3]);
-          vec34.subtract(v1, v4ToV3(prevV4), v4ToV3(nextV4));
-          vec34.normalize(v1, v1);
+          nextV4 = vec44.fromValues(posClrF32[idx2 + 0], posClrF32[idx2 + 1], posClrF32[idx2 + 2], posClrF32[idx2 + 3]);
+          vec35.subtract(v1, v4ToV3(prevV4), v4ToV3(nextV4));
+          vec35.normalize(v1, v1);
           prevV2 = NiivueObject3D.getFirstPerpVector(v1);
         }
         continue;
       }
       if (isLineEnd) {
-        nextV4 = vec43.clone(currV4);
+        nextV4 = vec44.clone(currV4);
       } else {
-        nextV4 = vec43.fromValues(posClrF32[idx2 + 0], posClrF32[idx2 + 1], posClrF32[idx2 + 2], posClrF32[idx2 + 3]);
-      }
-      vec34.subtract(v1, v4ToV3(prevV4), v4ToV3(nextV4));
-      vec34.normalize(v1, v1);
-      const D = vec34.create();
-      vec34.cross(D, prevV2, v1);
-      const v2 = vec34.create();
-      vec34.cross(v2, v1, D);
-      prevV2 = vec34.clone(prevV2);
-      const v3 = vec34.create();
-      vec34.cross(v3, v1, v2);
-      vec34.normalize(v3, v3);
-      const vtxXYZ = vec34.create();
+        nextV4 = vec44.fromValues(posClrF32[idx2 + 0], posClrF32[idx2 + 1], posClrF32[idx2 + 2], posClrF32[idx2 + 3]);
+      }
+      vec35.subtract(v1, v4ToV3(prevV4), v4ToV3(nextV4));
+      vec35.normalize(v1, v1);
+      const D = vec35.create();
+      vec35.cross(D, prevV2, v1);
+      const v2 = vec35.create();
+      vec35.cross(v2, v1, D);
+      prevV2 = vec35.clone(prevV2);
+      const v3 = vec35.create();
+      vec35.cross(v3, v1, v2);
+      vec35.normalize(v3, v3);
+      const vtxXYZ = vec35.create();
       for (let j = 0; j < cyl_sides; j++) {
         const c = Math.cos(j / cyl_sides * 2 * Math.PI);
         const s = Math.sin(j / cyl_sides * 2 * Math.PI);
         vtxXYZ[0] = radius * (c * v2[0] + s * v3[0]);
         vtxXYZ[1] = radius * (c * v2[1] + s * v3[1]);
         vtxXYZ[2] = radius * (c * v2[2] + s * v3[2]);
-        vec34.add(vtxXYZ, v4ToV3(currV4), vtxXYZ);
+        vec35.add(vtxXYZ, v4ToV3(currV4), vtxXYZ);
         const fidx = vtx * f32PerVertex;
         f32[fidx + 0] = vtxXYZ[0];
         f32[fidx + 1] = vtxXYZ[1];
         f32[fidx + 2] = vtxXYZ[2];
-        const n3 = vec34.create();
-        vec34.subtract(n3, vtxXYZ, v4ToV3(currV4));
-        vec34.normalize(n3, n3);
+        const n3 = vec35.create();
+        vec35.subtract(n3, vtxXYZ, v4ToV3(currV4));
+        vec35.normalize(n3, n3);
         const fidxU8 = (fidx + 3) * 4;
         u8[fidxU8 + 0] = n3[0] * 127;
         u8[fidxU8 + 1] = n3[1] * 127;
@@ -15096,8 +15210,8 @@ var NVMesh2 = class _NVMesh {
         f32[fidx + 4] = currV4[3];
         vtx++;
       }
-      prevV4 = vec43.clone(currV4);
-      currV4 = vec43.clone(nextV4);
+      prevV4 = vec44.clone(currV4);
+      currV4 = vec44.clone(nextV4);
       if (isLineEnd) {
         node = 0;
       }
@@ -15141,6 +15255,113 @@ var NVMesh2 = class _NVMesh {
     this.indexCount = nidx;
   }
   // linesToCylinders
+  createFiberDensityMap() {
+    if (this.fiberDensity) {
+      return;
+    }
+    const pts = this.pts;
+    const npt = pts.length / 3;
+    let maxExtentsRange = 0;
+    for (let i = 0; i < 3; i++) {
+      const range = this.extentsMax[i] - this.extentsMin[i];
+      maxExtentsRange = Math.max(maxExtentsRange, range);
+    }
+    this.fiberDensity = new Float32Array(npt);
+    if (maxExtentsRange === 0) {
+      return;
+    }
+    const bins = 64;
+    const binWidth = maxExtentsRange / (bins - 1);
+    const half = binWidth / 2;
+    const scale = (bins - 1) / maxExtentsRange;
+    let densityMap = new Float32Array(bins * bins * bins);
+    const mn = [this.extentsMin[0] - half, this.extentsMin[1] - half, this.extentsMin[2] - half];
+    const xyz = [0, 0, 0];
+    const prevVx = -1;
+    const binsXbins = bins * bins;
+    let j = 0;
+    for (let i = 0; i < npt; i++) {
+      xyz[0] = Math.round((pts[j++] - mn[0]) * scale);
+      xyz[1] = Math.round((pts[j++] - mn[1]) * scale);
+      xyz[2] = Math.round((pts[j++] - mn[2]) * scale);
+      const vx = xyz[0] + xyz[1] * bins + xyz[2] * binsXbins;
+      if (vx === prevVx) {
+        continue;
+      }
+      densityMap[vx]++;
+    }
+    function blur3D(vol, dim) {
+      let raw = vol.slice();
+      let v = -1;
+      const dim1 = dim - 1;
+      for (let z = 0; z < dim; z++) {
+        for (let y = 0; y < dim; y++) {
+          for (let x = 0; x < dim; x++) {
+            v++;
+            if (x < 1 || x >= dim1) {
+              continue;
+            }
+            vol[v] = raw[v - 1] + raw[v] + raw[v] + raw[v + 1];
+          }
+        }
+      }
+      v = -1;
+      raw = vol.slice();
+      for (let z = 0; z < dim; z++) {
+        for (let y = 0; y < dim; y++) {
+          for (let x = 0; x < dim; x++) {
+            v++;
+            if (y < 1 || y >= dim1) {
+              continue;
+            }
+            vol[v] = raw[v - dim] + raw[v] + raw[v] + raw[v + dim];
+          }
+        }
+      }
+      const dimXdim = dim * dim;
+      v = -1;
+      raw = vol.slice();
+      for (let z = 0; z < dim; z++) {
+        for (let y = 0; y < dim; y++) {
+          for (let x = 0; x < dim; x++) {
+            v++;
+            if (z < 1 || z >= dim1) {
+              continue;
+            }
+            vol[v] = raw[v - dimXdim] + raw[v] + raw[v] + raw[dimXdim];
+          }
+        }
+      }
+      return vol;
+    }
+    densityMap = blur3D(densityMap, bins);
+    densityMap = blur3D(densityMap, bins);
+    let mx = 0;
+    let mn0 = Infinity;
+    const binsXbinsXbins = bins * bins * bins;
+    for (let i = 0; i < binsXbinsXbins; i++) {
+      if (densityMap[i] <= 0) {
+        continue;
+      }
+      mx = Math.max(mx, densityMap[i]);
+      mn0 = Math.min(mn0, densityMap[i]);
+    }
+    if (mx <= 1 || mx <= mn0) {
+      return;
+    }
+    j = 0;
+    for (let i = 0; i < binsXbinsXbins; i++) {
+      densityMap[i] = Math.max(0, densityMap[i] - mn0);
+    }
+    mx -= mn0;
+    for (let i = 0; i < npt; i++) {
+      xyz[0] = Math.round((pts[j++] - mn[0]) * scale);
+      xyz[1] = Math.round((pts[j++] - mn[1]) * scale);
+      xyz[2] = Math.round((pts[j++] - mn[2]) * scale);
+      const vx = xyz[0] + xyz[1] * bins + xyz[2] * binsXbins;
+      this.fiberDensity[i] = densityMap[vx] / mx;
+    }
+  }
   // not included in public docs
   // internal function filters tractogram to identify which color and visibility of streamlines
   updateFibers(gl) {
@@ -15158,8 +15379,8 @@ var NVMesh2 = class _NVMesh {
         const vEnd3 = (offsetPt0[i + 1] - 1) * 3;
         let len = 0;
         for (let j = vStart3; j < vEnd3; j += 3) {
-          const v = vec34.fromValues(pts[j + 0] - pts[j + 3], pts[j + 1] - pts[j + 4], pts[j + 2] - pts[j + 5]);
-          len += vec34.len(v);
+          const v = vec35.fromValues(pts[j + 0] - pts[j + 3], pts[j + 1] - pts[j + 4], pts[j + 2] - pts[j + 5]);
+          len += vec35.len(v);
         }
         this.fiberLengths[i] = len;
       }
@@ -15186,8 +15407,8 @@ var NVMesh2 = class _NVMesh {
       return r + (g << 8) + (b << 16);
     }
     function direction2rgb(x1, y1, z1, x2, y2, z2, ditherFrac) {
-      const v = vec34.fromValues(Math.abs(x1 - x2), Math.abs(y1 - y2), Math.abs(z1 - z2));
-      vec34.normalize(v, v);
+      const v = vec35.fromValues(Math.abs(x1 - x2), Math.abs(y1 - y2), Math.abs(z1 - z2));
+      vec35.normalize(v, v);
       const r = ditherFrac - ditherHalf;
       for (let j = 0; j < 3; j++) {
         v[j] = 255 * Math.max(Math.min(Math.abs(v[j]) + r, 1), 0);
@@ -15349,6 +15570,34 @@ var NVMesh2 = class _NVMesh {
         }
       }
     }
+    if (this.fiberOcclusion > 0) {
+      let shadeRGBA = function(rgba, frac) {
+        const r = frac * (rgba & 255);
+        const g = frac * (rgba >> 8 & 255);
+        const b = frac * (rgba >> 16 & 255);
+        return r + (g << 8) + (b << 16);
+      };
+      this.createFiberDensityMap();
+      for (let i = 0; i < n_count; i++) {
+        const vStart = offsetPt0[i];
+        const vEnd = offsetPt0[i + 1] - 1;
+        const vStart4 = vStart * 4 + 3;
+        const vEnd4 = vEnd * 4 + 3;
+        let vtx = vStart;
+        const bias = Math.min(this.fiberOcclusion, 0.99);
+        for (let j = vStart4; j <= vEnd4; j += 4) {
+          let shade = this.fiberDensity[vtx++];
+          if (shade <= 0) {
+            continue;
+          }
+          shade = shade / ((1 / bias - 2) * (1 - shade) + 1);
+          const frac = 1 - Math.min(shade, 0.9);
+          let RGBA = posClrU32[j];
+          RGBA = shadeRGBA(RGBA, frac);
+          posClrU32[j] = RGBA;
+        }
+      }
+    }
     const min_mm = this.fiberLength;
     const primitiveRestart = Math.pow(2, 32) - 1;
     const indices = [];
@@ -15657,10 +15906,9 @@ var NVMesh2 = class _NVMesh {
     }
     if (maxAdditiveBlend > 0) {
       for (let j = 0; j < nvtx; j++) {
-        let modulate2 = function(x, y) {
+        let modulate = function(x, y) {
           return Math.min(x * y * (1 / 255), 255);
         };
-        var modulate = modulate2;
         let vtx = j * 28 + 24;
         if (this.f32PerVertex !== 7) {
           vtx = j * 20 + 16;
@@ -15670,9 +15918,9 @@ var NVMesh2 = class _NVMesh {
         if (opacity <= 0) {
           continue;
         }
-        u8[vtx + 0] = modulate2(u8[vtx + 0], additiveRGBA[v + 0]);
-        u8[vtx + 1] = modulate2(u8[vtx + 1], additiveRGBA[v + 1]);
-        u8[vtx + 2] = modulate2(u8[vtx + 2], additiveRGBA[v + 2]);
+        u8[vtx + 0] = modulate(u8[vtx + 0], additiveRGBA[v + 0]);
+        u8[vtx + 1] = modulate(u8[vtx + 1], additiveRGBA[v + 1]);
+        u8[vtx + 2] = modulate(u8[vtx + 2], additiveRGBA[v + 2]);
         u8[vtx + 0] = lerp(u8[vtx + 0], additiveRGBA[v + 0], opacity);
         u8[vtx + 1] = lerp(u8[vtx + 1], additiveRGBA[v + 1], opacity);
         u8[vtx + 2] = lerp(u8[vtx + 2], additiveRGBA[v + 2], opacity);
@@ -17753,140 +18001,6 @@ var Roboto_Regular_default2 = {
 import { serialize, deserialize } from "@ungap/structured-clone";
 import { vec3 as vec38, vec4 as vec46 } from "gl-matrix";
 
-// src/nvutilities.ts
-import arrayEqual from "array-equal";
-import { compressSync, decompressSync as decompressSync2, strToU8 } from "fflate/browser";
-import { mat4 as mat43, vec3 as vec35, vec4 as vec44 } from "gl-matrix";
-var NVUtilities = class _NVUtilities {
-  static arrayBufferToBase64(arrayBuffer) {
-    const bytes = new Uint8Array(arrayBuffer);
-    return _NVUtilities.uint8tob64(bytes);
-  }
-  /*
-  https://gist.github.com/jonleighton/958841
-  MIT LICENSE
-  Copyright 2011 Jon Leighton
-  Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
-  The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
-  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-  */
-  static uint8tob64(bytes) {
-    let base64 = "";
-    const encodings = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
-    const byteLength = bytes.byteLength;
-    const byteRemainder = byteLength % 3;
-    const mainLength = byteLength - byteRemainder;
-    let a, b, c, d;
-    let chunk;
-    for (let i = 0; i < mainLength; i = i + 3) {
-      chunk = bytes[i] << 16 | bytes[i + 1] << 8 | bytes[i + 2];
-      a = (chunk & 16515072) >> 18;
-      b = (chunk & 258048) >> 12;
-      c = (chunk & 4032) >> 6;
-      d = chunk & 63;
-      base64 += encodings[a] + encodings[b] + encodings[c] + encodings[d];
-    }
-    if (byteRemainder === 1) {
-      chunk = bytes[mainLength];
-      a = (chunk & 252) >> 2;
-      b = (chunk & 3) << 4;
-      base64 += encodings[a] + encodings[b] + "==";
-    } else if (byteRemainder === 2) {
-      chunk = bytes[mainLength] << 8 | bytes[mainLength + 1];
-      a = (chunk & 64512) >> 10;
-      b = (chunk & 1008) >> 4;
-      c = (chunk & 15) << 2;
-      base64 += encodings[a] + encodings[b] + encodings[c] + "=";
-    }
-    return base64;
-  }
-  // https://stackoverflow.com/questions/34156282/how-do-i-save-json-to-local-text-file
-  static download(content, fileName, contentType) {
-    const a = document.createElement("a");
-    const file = new Blob([content], { type: contentType });
-    a.href = URL.createObjectURL(file);
-    a.download = fileName;
-    a.click();
-  }
-  static readFileAsync(file) {
-    return new Promise((resolve, reject) => {
-      const reader = new FileReader();
-      reader.onload = () => {
-        resolve(reader.result);
-      };
-      reader.onerror = reject;
-      reader.readAsArrayBuffer(file);
-    });
-  }
-  static blobToBase64(blob) {
-    return new Promise((resolve) => {
-      const reader = new FileReader();
-      reader.onloadend = () => resolve(reader.result);
-      reader.readAsDataURL(blob);
-    });
-  }
-  static decompressBase64String(base64) {
-    const compressed = atob(base64);
-    const compressedBuffer = new ArrayBuffer(compressed.length);
-    const compressedView = new Uint8Array(compressedBuffer);
-    for (let i = 0; i < compressed.length; i++) {
-      compressedView[i] = compressed.charCodeAt(i);
-    }
-    const decompressedBuffer = decompressSync2(compressedView);
-    const decompressed = new TextDecoder("utf-8").decode(decompressedBuffer);
-    return decompressed;
-  }
-  static compressToBase64String(string) {
-    const buf = strToU8(string);
-    const compressed = compressSync(buf);
-    const base64 = _NVUtilities.uint8tob64(compressed);
-    return base64;
-  }
-  static arraysAreEqual(a, b) {
-    return arrayEqual(a, b);
-  }
-  /**
-   * Generate a pre-filled number array.
-   *
-   * @param start - start value
-   * @param stop - stop value
-   * @param step - step value
-   * @returns filled number array
-   */
-  static range(start, stop, step) {
-    return Array.from({ length: (stop - start) / step + 1 }, (_, i) => start + i * step);
-  }
-  /**
-   * convert spherical AZIMUTH, ELEVATION to Cartesian
-   * @param azimuth - azimuth number
-   * @param elevation - elevation number
-   * @returns the converted [x, y, z] coordinates
-   * @example
-   * xyz = NVUtilities.sph2cartDeg(42, 42)
-   */
-  static sph2cartDeg(azimuth, elevation) {
-    const Phi = -elevation * (Math.PI / 180);
-    const Theta = (azimuth - 90) % 360 * (Math.PI / 180);
-    const ret = [Math.cos(Phi) * Math.cos(Theta), Math.cos(Phi) * Math.sin(Theta), Math.sin(Phi)];
-    const len = Math.sqrt(ret[0] * ret[0] + ret[1] * ret[1] + ret[2] * ret[2]);
-    if (len <= 0) {
-      return ret;
-    }
-    ret[0] /= len;
-    ret[1] /= len;
-    ret[2] /= len;
-    return ret;
-  }
-  static vox2mm(XYZ, mtx) {
-    const sform = mat43.clone(mtx);
-    mat43.transpose(sform, sform);
-    const pos = vec44.fromValues(XYZ[0], XYZ[1], XYZ[2], 1);
-    vec44.transformMat4(pos, pos, sform);
-    const pos3 = vec35.fromValues(pos[0], pos[1], pos[2]);
-    return pos3;
-  }
-};
-
 // src/nvimage/index.ts
 import * as nifti from "nifti-reader-js";
 import daikon from "daikon";
@@ -17919,6 +18033,8 @@ var ImageType = /* @__PURE__ */ ((ImageType3) => {
   ImageType3[ImageType3["VMR"] = 14] = "VMR";
   ImageType3[ImageType3["HEAD"] = 15] = "HEAD";
   ImageType3[ImageType3["DCM_FOLDER"] = 16] = "DCM_FOLDER";
+  ImageType3[ImageType3["SRC"] = 17] = "SRC";
+  ImageType3[ImageType3["FIB"] = 18] = "FIB";
   return ImageType3;
 })(ImageType || {});
 var NVIMAGE_TYPE = Object.freeze({
@@ -17933,6 +18049,9 @@ var NVIMAGE_TYPE = Object.freeze({
       case "TXT":
         imageType = 3 /* DCM_MANIFEST */;
         break;
+      case "FIB":
+        imageType = 18 /* FIB */;
+        break;
       case "NII":
         imageType = 1 /* NII */;
         break;
@@ -17960,6 +18079,9 @@ var NVIMAGE_TYPE = Object.freeze({
       case "MGZ":
         imageType = 11 /* MGZ */;
         break;
+      case "SRC":
+        imageType = 17 /* SRC */;
+        break;
       case "V":
         imageType = 12 /* V */;
         break;
@@ -18256,6 +18378,9 @@ var NVImage = class _NVImage {
     __publicField(this, "imageType");
     __publicField(this, "img");
     __publicField(this, "imaginary");
+    // only for complex data
+    __publicField(this, "v1");
+    // only for FIB files
     __publicField(this, "fileObject");
     __publicField(this, "dims");
     __publicField(this, "onColormapChange", () => {
@@ -18311,6 +18436,10 @@ var NVImage = class _NVImage {
       case NVIMAGE_TYPE.DCM:
         imgRaw = this.readDICOM(dataBuffer);
         break;
+      case NVIMAGE_TYPE.FIB:
+        ;
+        [imgRaw, this.v1] = this.readFIB(dataBuffer);
+        break;
       case NVIMAGE_TYPE.MIH:
       case NVIMAGE_TYPE.MIF:
         imgRaw = this.readMIF(dataBuffer, pairedImgData);
@@ -18327,6 +18456,9 @@ var NVImage = class _NVImage {
       case NVIMAGE_TYPE.MGZ:
         imgRaw = this.readMGH(dataBuffer);
         break;
+      case NVIMAGE_TYPE.SRC:
+        imgRaw = this.readSRC(dataBuffer);
+        break;
       case NVIMAGE_TYPE.V:
         imgRaw = this.readECAT(dataBuffer);
         break;
@@ -18383,40 +18515,7 @@ var NVImage = class _NVImage {
       this.nFrame4D = nVol4D;
     }
     if ((this.hdr.intent_code === 1007 /* NIFTI_INTENT_VECTOR */ || this.hdr.intent_code === 2003 /* NIFTI_INTENT_RGB_VECTOR */) && this.nFrame4D === 3 && this.hdr.datatypeCode === 16 /* DT_FLOAT32 */) {
-      const tmp = new Float32Array(imgRaw);
-      const f32 = tmp.slice();
-      this.hdr.datatypeCode = 2304 /* DT_RGBA32 */;
-      this.nFrame4D = 1;
-      for (let i = 4; i < 7; i++) {
-        this.hdr.dims[i] = 1;
-      }
-      this.hdr.dims[0] = 3;
-      imgRaw = new Uint8Array(this.nVox3D * 4);
-      let mx = 1;
-      for (let i = 0; i < this.nVox3D * 3; i++) {
-        mx = Math.max(mx, Math.abs(f32[i]));
-      }
-      const slope = 255 / mx;
-      const nVox3D2 = this.nVox3D * 2;
-      let j = 0;
-      for (let i = 0; i < this.nVox3D; i++) {
-        const x = f32[i];
-        const y = f32[i + this.nVox3D];
-        const z = f32[i + nVox3D2];
-        imgRaw[j] = Math.abs(x * slope);
-        imgRaw[j + 1] = Math.abs(y * slope);
-        imgRaw[j + 2] = Math.abs(z * slope);
-        const xNeg = Number(x > 0) * 1;
-        const yNeg = Number(y > 0) * 2;
-        const zNeg = Number(z > 0) * 4;
-        let alpha = 248 + xNeg + yNeg + zNeg;
-        if (Math.abs(x) + Math.abs(y) + Math.abs(z) < 0.1) {
-          alpha = 0;
-        }
-        ;
-        imgRaw[j + 3] = alpha;
-        j += 4;
-      }
+      imgRaw = this.float32V1asRGBA(new Float32Array(imgRaw));
     }
     if (this.hdr.pixDims[1] === 0 || this.hdr.pixDims[2] === 0 || this.hdr.pixDims[3] === 0) {
       log.error("pixDims not plausible", this.hdr);
@@ -18639,6 +18738,75 @@ var NVImage = class _NVImage {
     }
     return oblique_angle;
   }
+  float32V1asRGBA(inImg) {
+    if (inImg.length !== this.nVox3D * 3) {
+      log.warn("float32V1asRGBA() expects " + this.nVox3D * 3 + "voxels, got ", +inImg.length);
+    }
+    const f32 = inImg.slice();
+    this.hdr.datatypeCode = 2304 /* DT_RGBA32 */;
+    this.nFrame4D = 1;
+    for (let i = 4; i < 7; i++) {
+      this.hdr.dims[i] = 1;
+    }
+    this.hdr.dims[0] = 3;
+    const imgRaw = new Uint8Array(this.nVox3D * 4);
+    let mx = 1;
+    for (let i = 0; i < this.nVox3D * 3; i++) {
+      if (isNaN(f32[i])) {
+        continue;
+      }
+      mx = Math.max(mx, Math.abs(f32[i]));
+    }
+    const slope = 255 / mx;
+    const nVox3D2 = this.nVox3D * 2;
+    let j = 0;
+    for (let i = 0; i < this.nVox3D; i++) {
+      const x = f32[i];
+      const y = f32[i + this.nVox3D];
+      const z = f32[i + nVox3D2];
+      imgRaw[j] = Math.abs(x * slope);
+      imgRaw[j + 1] = Math.abs(y * slope);
+      imgRaw[j + 2] = Math.abs(z * slope);
+      const xNeg = Number(x > 0) * 1;
+      const yNeg = Number(y > 0) * 2;
+      const zNeg = Number(z > 0) * 4;
+      let alpha = 248 + xNeg + yNeg + zNeg;
+      if (Math.abs(x) + Math.abs(y) + Math.abs(z) < 0.1) {
+        alpha = 0;
+      }
+      ;
+      imgRaw[j + 3] = alpha;
+      j += 4;
+    }
+    return imgRaw;
+  }
+  loadImgV1(isFlipX = false, isFlipY = false, isFlipZ = false) {
+    let v1 = this.v1;
+    if (!v1 && this.nFrame4D === 3 && this.img.constructor === Float32Array) {
+      v1 = this.img.slice();
+    }
+    if (!v1) {
+      log.warn("Image does not have V1 data");
+      return false;
+    }
+    if (isFlipX) {
+      for (let i = 0; i < this.nVox3D; i++) {
+        v1[i] = -v1[i];
+      }
+    }
+    if (isFlipY) {
+      for (let i = this.nVox3D; i < 2 * this.nVox3D; i++) {
+        v1[i] = -v1[i];
+      }
+    }
+    if (isFlipZ) {
+      for (let i = 2 * this.nVox3D; i < 3 * this.nVox3D; i++) {
+        v1[i] = -v1[i];
+      }
+    }
+    this.img = this.float32V1asRGBA(v1);
+    return true;
+  }
   // not included in public docs
   // detect difference between voxel grid and world space
   calculateOblique() {
@@ -19213,6 +19381,142 @@ var NVImage = class _NVImage {
   }
   // readMGH()
   // not included in public docs
+  // read DSI-Studio FIB format image
+  // https://dsi-studio.labsolver.org/doc/cli_data.html
+  readFIB(buffer) {
+    this.hdr = new nifti.NIFTI1();
+    const hdr = this.hdr;
+    hdr.littleEndian = false;
+    hdr.dims = [3, 1, 1, 1, 0, 0, 0, 0];
+    hdr.pixDims = [1, 1, 1, 1, 1, 0, 0, 0];
+    const mat = NVUtilities.readMatV4(buffer);
+    if (!("dimension" in mat) || !("dti_fa" in mat)) {
+      throw new Error("Not a valid DSIstudio FIB file");
+    }
+    const hasV1 = "index0" in mat && "index1" in mat && "index2" in mat;
+    hdr.numBitsPerVoxel = 32;
+    hdr.datatypeCode = 16 /* DT_FLOAT32 */;
+    hdr.dims[1] = mat.dimension[0];
+    hdr.dims[2] = mat.dimension[1];
+    hdr.dims[3] = mat.dimension[2];
+    hdr.dims[4] = 1;
+    hdr.pixDims[1] = mat.voxel_size[0];
+    hdr.pixDims[2] = mat.voxel_size[1];
+    hdr.pixDims[3] = mat.voxel_size[2];
+    hdr.sform_code = 1;
+    const xmm = (hdr.dims[1] - 1) * 0.5 * hdr.pixDims[1];
+    const ymm = (hdr.dims[2] - 1) * 0.5 * hdr.pixDims[2];
+    const zmm = (hdr.dims[3] - 1) * 0.5 * hdr.pixDims[3];
+    hdr.affine = [
+      [hdr.pixDims[1], 0, 0, -xmm],
+      [0, -hdr.pixDims[2], 0, ymm],
+      [0, 0, hdr.pixDims[2], -zmm],
+      [0, 0, 0, 1]
+    ];
+    hdr.littleEndian = true;
+    const nVox3D = hdr.dims[1] * hdr.dims[2] * hdr.dims[3];
+    const nBytes3D = nVox3D * Math.ceil(hdr.numBitsPerVoxel / 8);
+    const nBytes = nBytes3D * hdr.dims[4];
+    const buff8v1 = new Uint8Array(new ArrayBuffer(nVox3D * 4 * 3));
+    if (hasV1) {
+      const nvox = hdr.dims[1] * hdr.dims[2] * hdr.dims[3];
+      const dir0 = new Float32Array(nvox);
+      const dir1 = new Float32Array(nvox);
+      const dir2 = new Float32Array(nvox);
+      const idxs = mat.index0;
+      const dirs = mat.odf_vertices;
+      for (let i = 0; i < nvox; i++) {
+        const idx = idxs[i] * 3;
+        dir0[i] = dirs[idx + 0];
+        dir1[i] = dirs[idx + 1];
+        dir2[i] = -dirs[idx + 2];
+      }
+      buff8v1.set(new Uint8Array(dir0.buffer, dir0.byteOffset, dir0.byteLength), 0 * nBytes3D);
+      buff8v1.set(new Uint8Array(dir1.buffer, dir1.byteOffset, dir1.byteLength), 1 * nBytes3D);
+      buff8v1.set(new Uint8Array(dir2.buffer, dir2.byteOffset, dir2.byteLength), 2 * nBytes3D);
+    }
+    const buff8 = new Uint8Array(new ArrayBuffer(nBytes));
+    const arrFA = Float32Array.from(mat.dti_fa);
+    const imgFA = new Uint8Array(arrFA.buffer, arrFA.byteOffset, arrFA.byteLength);
+    buff8.set(imgFA, 0);
+    if ("report" in mat) {
+      hdr.description = new TextDecoder().decode(mat.report.subarray(0, Math.min(79, mat.report.byteLength)));
+    }
+    return [buff8.buffer, new Float32Array(buff8v1.buffer)];
+  }
+  // readFIB()
+  // not included in public docs
+  // read DSI-Studio SRC format image
+  // https://dsi-studio.labsolver.org/doc/cli_data.html
+  readSRC(buffer) {
+    this.hdr = new nifti.NIFTI1();
+    const hdr = this.hdr;
+    hdr.littleEndian = false;
+    hdr.dims = [3, 1, 1, 1, 0, 0, 0, 0];
+    hdr.pixDims = [1, 1, 1, 1, 1, 0, 0, 0];
+    const mat = NVUtilities.readMatV4(buffer);
+    if (!("dimension" in mat) || !("image0" in mat)) {
+      throw new Error("Not a valid DSIstudio SRC file");
+    }
+    let n = 0;
+    let len = 0;
+    for (const [key, value] of Object.entries(mat)) {
+      if (!key.startsWith("image")) {
+        continue;
+      }
+      if (n === 0) {
+        len = value.length;
+      } else if (len !== value.length) {
+        len = -1;
+      }
+      if (value.constructor !== Uint16Array) {
+        throw new Error("DSIstudio SRC files always use Uint16 datatype");
+      }
+      n++;
+    }
+    if (len < 1 || n < 1) {
+      throw new Error("SRC file not valid DSI Studio data. The image(s) should have the same length");
+    }
+    hdr.numBitsPerVoxel = 16;
+    hdr.datatypeCode = 512 /* DT_UINT16 */;
+    hdr.dims[1] = mat.dimension[0];
+    hdr.dims[2] = mat.dimension[1];
+    hdr.dims[3] = mat.dimension[2];
+    hdr.dims[4] = n;
+    if (hdr.dims[4] > 1) {
+      hdr.dims[0] = 4;
+    }
+    hdr.pixDims[1] = mat.voxel_size[0];
+    hdr.pixDims[2] = mat.voxel_size[1];
+    hdr.pixDims[3] = mat.voxel_size[2];
+    hdr.sform_code = 1;
+    const xmm = (hdr.dims[1] - 1) * 0.5 * hdr.pixDims[1];
+    const ymm = (hdr.dims[2] - 1) * 0.5 * hdr.pixDims[2];
+    const zmm = (hdr.dims[3] - 1) * 0.5 * hdr.pixDims[3];
+    hdr.affine = [
+      [hdr.pixDims[1], 0, 0, -xmm],
+      [0, -hdr.pixDims[2], 0, ymm],
+      [0, 0, hdr.pixDims[2], -zmm],
+      [0, 0, 0, 1]
+    ];
+    hdr.littleEndian = true;
+    const nBytes3D = hdr.dims[1] * hdr.dims[2] * hdr.dims[3] * (hdr.numBitsPerVoxel / 8);
+    const nBytes = nBytes3D * hdr.dims[4];
+    const buff8 = new Uint8Array(new ArrayBuffer(nBytes));
+    let offset = 0;
+    for (let i = 0; i < n; i++) {
+      const arr = mat[`image${i}`];
+      const img8 = new Uint8Array(arr.buffer, arr.byteOffset, arr.byteLength);
+      buff8.set(img8, offset);
+      offset += nBytes3D;
+    }
+    if ("report" in mat) {
+      hdr.description = new TextDecoder().decode(mat.report.subarray(0, Math.min(79, mat.report.byteLength)));
+    }
+    return buff8.buffer;
+  }
+  // readSRC()
+  // not included in public docs
   // read AFNI head/brik format image
   readHEAD(dataBuffer, pairedImgData) {
     this.hdr = new nifti.NIFTI1();
@@ -19531,6 +19835,7 @@ var NVImage = class _NVImage {
       throw new Error("Not a valid MIF file");
     }
     const layout = [];
+    let isBit = false;
     let nTransform = 0;
     let TR = 0;
     let isDetached = false;
@@ -19569,7 +19874,10 @@ var NVImage = class _NVImage {
         case "datatype":
           {
             const dt = items[0];
-            if (dt.startsWith("Int8")) {
+            if (dt.startsWith("Bit")) {
+              isBit = true;
+              hdr.datatypeCode = 2 /* DT_UINT8 */;
+            } else if (dt.startsWith("Int8")) {
               hdr.datatypeCode = 256 /* DT_INT8 */;
             } else if (dt.startsWith("UInt8")) {
               hdr.datatypeCode = 2 /* DT_UINT8 */;
@@ -19616,6 +19924,9 @@ var NVImage = class _NVImage {
           hdr.affine[nTransform][3] = parseFloat(items[3]);
           nTransform++;
           break;
+        case "comments":
+          hdr.description = items[0].substring(0, Math.min(79, items[0].length));
+          break;
         case "RepetitionTime":
           TR = parseFloat(items[0]);
           break;
@@ -19636,7 +19947,6 @@ var NVImage = class _NVImage {
     for (let i = 0; i < ndim; i++) {
       nvox *= Math.max(hdr.dims[i + 1], 1);
     }
-    log.debug(nvox);
     for (let i = 0; i < 3; i++) {
       for (let j2 = 0; j2 < 3; j2++) {
         hdr.affine[i][j2] *= hdr.pixDims[j2 + 1];
@@ -19652,6 +19962,20 @@ var NVImage = class _NVImage {
     let rawImg;
     if (pairedImgData && isDetached) {
       rawImg = pairedImgData.slice(0);
+    } else if (isBit) {
+      hdr.numBitsPerVoxel = 8;
+      const img8 = new Uint8Array(nvox);
+      const buffer1 = buffer.slice(hdr.vox_offset, hdr.vox_offset + Math.ceil(nvox / 8));
+      const img1 = new Uint8Array(buffer1);
+      let j2 = 0;
+      for (let i = 0; i < nvox; i++) {
+        const bit = i % 8;
+        img8[i] = img1[j2] >> 7 - bit & 1;
+        if (bit === 7) {
+          j2++;
+        }
+      }
+      rawImg = img8.buffer;
     } else {
       rawImg = buffer.slice(hdr.vox_offset, hdr.vox_offset + nvox * (hdr.numBitsPerVoxel / 8));
     }
@@ -19712,25 +20036,41 @@ var NVImage = class _NVImage {
     let j = 0;
     let inVs;
     let outVs;
-    switch (hdr.numBitsPerVoxel) {
-      case 8:
+    switch (hdr.datatypeCode) {
+      case 256 /* DT_INT8 */:
+        inVs = new Int8Array(rawImg);
+        outVs = new Int8Array(nvox);
+        break;
+      case 2 /* DT_UINT8 */:
         inVs = new Uint8Array(rawImg);
         outVs = new Uint8Array(nvox);
         break;
-      case 16:
+      case 4 /* DT_INT16 */:
+        inVs = new Int16Array(rawImg);
+        outVs = new Int16Array(nvox);
+        break;
+      case 512 /* DT_UINT16 */:
         inVs = new Uint16Array(rawImg);
         outVs = new Uint16Array(nvox);
         break;
-      case 32:
+      case 8 /* DT_INT32 */:
+        inVs = new Int32Array(rawImg);
+        outVs = new Int32Array(nvox);
+        break;
+      case 768 /* DT_UINT32 */:
         inVs = new Uint32Array(rawImg);
         outVs = new Uint32Array(nvox);
         break;
-      case 64:
-        inVs = new BigUint64Array(rawImg);
-        outVs = new BigUint64Array(nvox);
+      case 16 /* DT_FLOAT32 */:
+        inVs = new Float32Array(rawImg);
+        outVs = new Float32Array(nvox);
+        break;
+      case 64 /* DT_FLOAT64 */:
+        inVs = new Float64Array(rawImg);
+        outVs = new Float64Array(nvox);
         break;
       default:
-        throw new Error("unknown numBitsPerVoxel");
+        throw new Error("unknown datatypeCode");
     }
     for (let d = 0; d < hdr.dims[5]; d++) {
       for (let t = 0; t < hdr.dims[4]; t++) {
@@ -19917,7 +20257,7 @@ var NVImage = class _NVImage {
           }
           break;
         case "space":
-          if (value.includes("right-anterior-superior") || value.includes("RAS")) {
+          if (value.includes("right-anterior-superior") || value.includes("ras")) {
             rot33 = mat3.fromValues(
               1,
               0,
@@ -19929,7 +20269,7 @@ var NVImage = class _NVImage {
               0,
               1
             );
-          } else if (value.includes("left-anterior-superior") || value.includes("LAS")) {
+          } else if (value.includes("left-anterior-superior") || value.includes("las")) {
             rot33 = mat3.fromValues(
               -1,
               0,
@@ -19941,7 +20281,7 @@ var NVImage = class _NVImage {
               0,
               1
             );
-          } else if (value.includes("left-posterior-superior") || value.includes("LPS")) {
+          } else if (value.includes("left-posterior-superior") || value.includes("lps")) {
             rot33 = mat3.fromValues(
               -1,
               0,
@@ -20349,6 +20689,9 @@ var NVImage = class _NVImage {
         mx = Math.max(this.img[i], mx);
       }
     }
+    if (this.ignoreZeroVoxels && mn === mx && nZero > 0) {
+      mn = 0;
+    }
     const mnScale = this.intensityRaw2Scaled(mn);
     const mxScale = this.intensityRaw2Scaled(mx);
     const cmap = cmapper.colormapFromKey(this._colormap);
@@ -20519,8 +20862,8 @@ var NVImage = class _NVImage {
     odata.set(opad, hdrBytes.length);
     odata.set(img8, hdrBytes.length + opad.length);
     let saveData = null;
-    const compress = fnm.endsWith(".gz");
-    if (compress) {
+    const compress2 = fnm.endsWith(".gz");
+    if (compress2) {
       saveData = gzipSync(odata, {
         // GZIP-specific: the filename to use when decompressed
         filename: fnm,
@@ -21428,7 +21771,7 @@ var NVImage = class _NVImage {
    */
   toUint8Array(drawingBytes = null) {
     const isDrawing = drawingBytes !== null;
-    const hdrBytes = hdrToArrayBuffer(this.hdr, isDrawing);
+    const hdrBytes = hdrToArrayBuffer({ ...this.hdr, vox_offset: 352 }, isDrawing);
     let drawingBytesToBeConverted = drawingBytes;
     if (isDrawing) {
       const perm = this.permRAS;
@@ -21603,6 +21946,9 @@ var DEFAULT_OPTIONS = {
   fontColor: [0.5, 0.5, 0.5, 1],
   selectionBoxColor: [1, 1, 1, 0.5],
   clipPlaneColor: [0.7, 0, 0.7, 0.5],
+  clipThick: 2,
+  clipVolumeLow: [0, 0, 0],
+  clipVolumeHigh: [1, 1, 1],
   rulerColor: [1, 0, 0, 0.8],
   colorbarMargin: 0.05,
   trustCalMinMax: true,
@@ -21658,7 +22004,10 @@ var INITIAL_SCENE_DATA = {
   clipPlane: [0, 0, 0, 0],
   clipPlaneDepthAziElev: [2, 0, 0],
   volScaleMultiplier: 1,
-  pan2Dxyzmm: vec46.fromValues(0, 0, 0, 1)
+  pan2Dxyzmm: vec46.fromValues(0, 0, 0, 1),
+  clipThick: 2,
+  clipVolumeLow: [0, 0, 0],
+  clipVolumeHigh: [1, 1, 1]
 };
 var NVDocument = class _NVDocument {
   constructor() {
@@ -21684,7 +22033,7 @@ var NVDocument = class _NVDocument {
       },
       onZoom3DChange: () => {
       },
-      sceneData: INITIAL_SCENE_DATA,
+      sceneData: { ...INITIAL_SCENE_DATA },
       get renderAzimuth() {
         return this.sceneData.azimuth;
       },
@@ -21805,6 +22154,12 @@ var NVDocument = class _NVDocument {
   set labels(labels) {
     this.data.labels = labels;
   }
+  get customData() {
+    return this.data.customData;
+  }
+  set customData(data) {
+    this.data.customData = data;
+  }
   /**
    * Checks if document has an image by id
    */
@@ -21877,6 +22232,7 @@ var NVDocument = class _NVDocument {
       data.opts.meshThicknessOn2D = "infinity";
     }
     data.labels = [...this.data.labels];
+    data.customData = this.customData;
     if (this.volumes.length) {
       let imageOptions = this.imageOptionsArray[0];
       if (!imageOptions) {
@@ -22008,7 +22364,6 @@ var NVDocument = class _NVDocument {
         edges: mesh.edges && Array.isArray(mesh.edges) ? [...mesh.edges] : [],
         extentsMax: mesh.extentsMax,
         extentsMin: mesh.extentsMin,
-        fiberGroupColormap: mesh.fiberGroupColormap,
         furthestVertexFromOrigin: mesh.furthestVertexFromOrigin,
         nodeColormap: mesh.nodeColormap,
         nodeColormapNegative: mesh.nodeColormapNegative,
@@ -22019,6 +22374,14 @@ var NVDocument = class _NVDocument {
         offsetPt0: mesh.offsetPt0,
         nodes: mesh.nodes
       };
+      if (mesh.offsetPt0 && mesh.offsetPt0.length > 0) {
+        copyMesh.offsetPt0 = mesh.offsetPt0;
+        copyMesh.fiberGroupColormap = mesh.fiberGroupColormap;
+        copyMesh.fiberColor = mesh.fiberColor;
+        copyMesh.fiberDither = mesh.fiberDither;
+        copyMesh.fiberRadius = mesh.fiberRadius;
+        copyMesh.colormap = mesh.colormap;
+      }
       meshes.push(copyMesh);
     }
     data.meshesString = JSON.stringify(serialize(meshes));
@@ -22027,9 +22390,17 @@ var NVDocument = class _NVDocument {
   /**
    * Downloads a JSON file with options, scene, images, meshes and drawing of {@link Niivue} instance
    */
-  download(fileName) {
+  async download(fileName, compress2) {
     const data = this.json();
-    NVUtilities.download(JSON.stringify(data), fileName, "application/json");
+    const dataText = JSON.stringify(data);
+    const contentType = compress2 ? "application/gzip" : "application/json";
+    let content;
+    if (compress2) {
+      content = await NVUtilities.compressStringToArrayBuffer(dataText);
+    } else {
+      content = JSON.stringify(data);
+    }
+    NVUtilities.download(content, fileName, contentType);
   }
   /**
    * Deserialize mesh data objects
@@ -22056,17 +22427,30 @@ var NVDocument = class _NVDocument {
    */
   static async loadFromUrl(url) {
     const response = await fetch(url);
-    const data = await response.json();
-    return _NVDocument.loadFromJSON(data);
+    const buffer = await response.arrayBuffer();
+    let documentData;
+    if (NVUtilities.isArrayBufferCompressed(buffer)) {
+      const documentText = await NVUtilities.decompressArrayBuffer(buffer);
+      documentData = JSON.parse(documentText);
+    } else {
+      const utf8decoder = new TextDecoder();
+      documentData = JSON.parse(utf8decoder.decode(buffer));
+    }
+    return _NVDocument.loadFromJSON(documentData);
   }
   /**
    * Factory method to return an instance of NVDocument from a File object
    */
   static async loadFromFile(file) {
     const arrayBuffer = await NVUtilities.readFileAsync(file);
+    let dataString;
     const document2 = new _NVDocument();
-    const utf8decoder = new TextDecoder();
-    const dataString = utf8decoder.decode(arrayBuffer);
+    if (NVUtilities.isArrayBufferCompressed(arrayBuffer)) {
+      dataString = await NVUtilities.decompressArrayBuffer(arrayBuffer);
+    } else {
+      const utf8decoder = new TextDecoder();
+      dataString = utf8decoder.decode(arrayBuffer);
+    }
     document2.data = JSON.parse(dataString);
     if (document2.data.opts.meshThicknessOn2D === "infinity") {
       document2.data.opts.meshThicknessOn2D = Infinity;
@@ -23472,6 +23856,10 @@ var Niivue = class _Niivue {
         Name: "Outline",
         Frag: fragMeshOutlineShader
       },
+      {
+        Name: "Specular",
+        Frag: fragMeshSpecularEdgeShader
+      },
       {
         Name: "Toon",
         Frag: fragMeshToonShader
@@ -25905,6 +26293,8 @@ var Niivue = class _Niivue {
       this.scene.pan2Dxyzmm[1] += zoomChange * mm[1];
       this.scene.pan2Dxyzmm[2] += zoomChange * mm[2];
       this.drawScene();
+      this.canvas.focus();
+      this.sync();
       return;
     }
     this.mouseClick(x, y, posChange, isDelta);
@@ -25963,6 +26353,34 @@ var Niivue = class _Niivue {
     this.gl.uniform4fv(this.renderShader.uniforms.clipPlaneColor, this.opts.clipPlaneColor);
     this.drawScene();
   }
+  /**
+   * adjust thickness of the 3D clip plane
+   * @param thick - thickness of slab. Value 0..1.73 (cube opposite corner length is sqrt(3)).
+   * @example
+   * niivue.setClipPlaneThick(0.3) // thin slab
+   * @see {@link https://niivue.github.io/niivue/features/clipplanes.html | live demo usage}
+   */
+  setClipPlaneThick(thick) {
+    this.opts.clipThick = thick;
+    this.renderShader.use(this.gl);
+    this.gl.uniform1f(this.renderShader.uniforms.clipThick, this.opts.clipThick);
+    this.drawScene();
+  }
+  /**
+   * set the clipping region for volume rendering
+   * @param color - the new color. expects an array of RGBA values. values can range from 0 to 1
+   * @example
+   * niivue.setClipPlaneColor([0.0, 0.0, 0.2], [1.0, 1.0, 0.7]) // remove inferior 20% and superior 30%
+   * @see {@link https://niivue.github.io/niivue/features/clipplanes.html | live demo usage}
+   */
+  setClipVolume(low, high) {
+    this.opts.clipVolumeLow = [Math.min(low[0], high[0]), Math.min(low[1], high[1]), Math.min(low[2], high[2])];
+    this.opts.clipVolumeHigh = [Math.max(low[0], high[0]), Math.max(low[1], high[1]), Math.max(low[2], high[2])];
+    this.renderShader.use(this.gl);
+    this.gl.uniform3fv(this.renderShader.uniforms.clipLo, this.opts.clipVolumeLow);
+    this.gl.uniform3fv(this.renderShader.uniforms.clipHi, this.opts.clipVolumeHigh);
+    this.drawScene();
+  }
   /**
    * set proportion of volume rendering influenced by selected matcap.
    * @param gradientAmount - amount of matcap (0..1), default 0 (matte, surface normal does not influence color)
@@ -26066,6 +26484,14 @@ var Niivue = class _Niivue {
         }
         const image = NVImage.loadFromBase64({ base64: base642, ...imageOptions });
         if (image) {
+          if (image.colormapLabel) {
+            const length = Object.keys(image.colormapLabel.lut).length;
+            const uint8ClampedArray = new Uint8ClampedArray(length);
+            for (const key in image.colormapLabel.lut) {
+              uint8ClampedArray[key] = image.colormapLabel.lut[key];
+            }
+            image.colormapLabel.lut = uint8ClampedArray;
+          }
           this.addVolume(image);
         }
       }
@@ -26083,6 +26509,10 @@ var Niivue = class _Niivue {
     }
     for (const meshDataObject of document2.meshDataObjects ?? []) {
       const meshInit = { gl: this.gl, ...meshDataObject };
+      if (meshDataObject.offsetPt0) {
+        meshInit.rgba255[3] = 0;
+        meshInit.tris = new Uint32Array(meshDataObject.offsetPt0);
+      }
       log.debug(meshInit);
       const meshToAdd = new NVMesh2(
         meshInit.pts,
@@ -26097,6 +26527,13 @@ var Niivue = class _Niivue {
         meshInit.dps,
         meshInit.dpv
       );
+      if (meshDataObject.offsetPt0) {
+        meshToAdd.fiberGroupColormap = meshDataObject.fiberGroupColormap;
+        meshToAdd.fiberColor = meshDataObject.fiberColor;
+        meshToAdd.fiberDither = meshDataObject.fiberDither;
+        meshToAdd.fiberRadius = meshDataObject.fiberRadius;
+        meshToAdd.colormap = meshDataObject.colormap;
+      }
       meshToAdd.meshShaderIndex = meshInit.meshShaderIndex;
       meshToAdd.layers = meshInit.layers;
       meshToAdd.updateMesh(this.gl);
@@ -26125,29 +26562,31 @@ var Niivue = class _Niivue {
   * const html = `<html><body><canvas id="gl1"></canvas><script type="module" async>        
          ${javascript}</script></body></html>`;
   */
-  generateLoadDocumentJavaScript(canvasId, esm) {
+  async generateLoadDocumentJavaScript(canvasId, esm) {
     const json = this.json();
-    const base64 = NVUtilities.compressToBase64String(JSON.stringify(json));
+    const base64 = await NVUtilities.compressToBase64String(JSON.stringify(json));
     const javascript = `
         ${esm}
         
-        function saveNiivueAsHtml(pageName) {    
+        async function saveNiivueAsHtml(pageName) {    
           //get new docstring
           const docString = nv1.json();
           const html = 
           document.getElementsByTagName("html")[0]
-              .innerHTML.replace(base64, NVUtilities.compressToBase64String(JSON.stringify(docString)));
+              .innerHTML.replace(base64, await NVUtilities.compressToBase64String(JSON.stringify(docString)));
           NVUtilities.download(html, pageName, "application/html");
         }
         
         var nv1 = new Niivue();
         nv1.attachTo("${canvasId}");  
         var base64 = "${base64}";
-        var jsonText = NVUtilities.decompressBase64String(base64);
-        var json = JSON.parse(jsonText); // string -> JSON
-        var doc = NVDocument.loadFromJSON(json);                
-        nv1.loadDocument(doc);
-        nv1.updateGLVolume();
+        NVUtilities.decompressBase64String(base64).then((jsonText) => {
+          var json = JSON.parse(jsonText); // string -> JSON
+          var doc = NVDocument.loadFromJSON(json);                
+          nv1.loadDocument(doc);
+          nv1.updateGLVolume();
+        });
+        
       `;
     return javascript;
   }
@@ -26161,8 +26600,8 @@ var Niivue = class _Niivue {
    *       %%javascript%%</script></body></html>`;
    * nv1.generateHTML("page.html", esm);
    */
-  generateHTML(canvasId = "gl1", esm) {
-    const javascript = this.generateLoadDocumentJavaScript(canvasId, esm);
+  async generateHTML(canvasId = "gl1", esm) {
+    const javascript = await this.generateLoadDocumentJavaScript(canvasId, esm);
     const html = `<!DOCTYPE html>
         <html lang="en">
           <head>
@@ -26240,9 +26679,9 @@ var Niivue = class _Niivue {
    * @param canvasId - id of canvas NiiVue will be attached to
    * @param esm - bundled version of NiiVue
    */
-  saveHTML(fileName = "untitled.html", canvasId = "gl1", esm) {
-    const html = this.generateHTML(canvasId, esm);
-    NVUtilities.download(html, fileName, "application/html");
+  async saveHTML(fileName = "untitled.html", canvasId = "gl1", esm) {
+    const html = await this.generateHTML(canvasId, esm);
+    return NVUtilities.download(html, fileName, "application/html");
   }
   /**
    * Converts NiiVue scene to JSON
@@ -26260,18 +26699,19 @@ var Niivue = class _Niivue {
   /**
    * save the entire scene (objects and settings) as a document
    * @param fileName - the name of the document storing the scene
+   * @param compress - whether the file should be compressed
    * @example
    * niivue.saveDocument("niivue.basic.nvd")
    * @see {@link https://niivue.github.io/niivue/features/document.3d.html | live demo usage}
    */
-  async saveDocument(fileName = "untitled.nvd") {
+  async saveDocument(fileName = "untitled.nvd", compress2 = true) {
     this.document.title = fileName;
     log.debug("saveDocument", this.volumes[0]);
     this.drawScene();
     this.document.previewImageDataURL = this.canvas.toDataURL();
     this.document.volumes = this.volumes;
     this.document.meshes = this.meshes;
-    this.document.download(fileName);
+    return this.document.download(fileName, compress2);
   }
   /**
    * load an array of volume objects
@@ -26739,7 +27179,7 @@ var Niivue = class _Niivue {
     Q.push(seedVx);
     img[seedVx] = 2;
     while (Q.length > 0) {
-      let testNeighbor2 = function(offset) {
+      let testNeighbor = function(offset) {
         const xyzN = xyz.slice();
         xyzN[0] += offset[0];
         xyzN[1] += offset[1];
@@ -26757,42 +27197,41 @@ var Niivue = class _Niivue {
         img[vxT] = 2;
         Q.push(vxT);
       };
-      var testNeighbor = testNeighbor2;
       const vx = Q[0];
       Q.shift();
       const xyz = vx2xyz(vx);
-      testNeighbor2([0, 0, -1]);
-      testNeighbor2([0, 0, 1]);
-      testNeighbor2([0, -1, 0]);
-      testNeighbor2([0, 1, 0]);
-      testNeighbor2([-1, 0, 0]);
-      testNeighbor2([1, 0, 0]);
+      testNeighbor([0, 0, -1]);
+      testNeighbor([0, 0, 1]);
+      testNeighbor([0, -1, 0]);
+      testNeighbor([0, 1, 0]);
+      testNeighbor([-1, 0, 0]);
+      testNeighbor([1, 0, 0]);
       if (neighbors <= 6) {
         continue;
       }
-      testNeighbor2([-1, -1, 0]);
-      testNeighbor2([1, 1, 0]);
-      testNeighbor2([-1, 1, 0]);
-      testNeighbor2([1, 1, 0]);
-      testNeighbor2([0, -1, -1]);
-      testNeighbor2([0, 1, -1]);
-      testNeighbor2([-1, 0, -1]);
-      testNeighbor2([1, 0, -1]);
-      testNeighbor2([0, -1, 1]);
-      testNeighbor2([0, 1, 1]);
-      testNeighbor2([-1, 0, 1]);
-      testNeighbor2([1, 0, 1]);
+      testNeighbor([-1, -1, 0]);
+      testNeighbor([1, 1, 0]);
+      testNeighbor([-1, 1, 0]);
+      testNeighbor([1, 1, 0]);
+      testNeighbor([0, -1, -1]);
+      testNeighbor([0, 1, -1]);
+      testNeighbor([-1, 0, -1]);
+      testNeighbor([1, 0, -1]);
+      testNeighbor([0, -1, 1]);
+      testNeighbor([0, 1, 1]);
+      testNeighbor([-1, 0, 1]);
+      testNeighbor([1, 0, 1]);
       if (neighbors <= 18) {
         continue;
       }
-      testNeighbor2([-1, -1, -1]);
-      testNeighbor2([1, -1, -1]);
-      testNeighbor2([-1, 1, -1]);
-      testNeighbor2([1, 1, -1]);
-      testNeighbor2([-1, -1, 1]);
-      testNeighbor2([1, -1, 1]);
-      testNeighbor2([-1, 1, 1]);
-      testNeighbor2([1, 1, 1]);
+      testNeighbor([-1, -1, -1]);
+      testNeighbor([1, -1, -1]);
+      testNeighbor([-1, 1, -1]);
+      testNeighbor([1, 1, -1]);
+      testNeighbor([-1, -1, 1]);
+      testNeighbor([1, -1, 1]);
+      testNeighbor([-1, 1, 1]);
+      testNeighbor([1, 1, 1]);
     }
   }
   // not included in public docs
@@ -28198,6 +28637,9 @@ var Niivue = class _Niivue {
     const volScale = slicescl.volScale;
     this.gl.uniform1f(this.renderShader.uniforms.overlays, this.overlays);
     this.gl.uniform4fv(this.renderShader.uniforms.clipPlaneColor, this.opts.clipPlaneColor);
+    this.gl.uniform1f(this.renderShader.uniforms.clipThick, this.opts.clipThick);
+    this.gl.uniform3fv(this.renderShader.uniforms.clipLo, this.opts.clipVolumeLow);
+    this.gl.uniform3fv(this.renderShader.uniforms.clipHi, this.opts.clipVolumeHigh);
     this.gl.uniform1f(this.renderShader.uniforms.backOpacity, this.volumes[0].opacity);
     this.gl.uniform1f(this.renderShader.uniforms.renderOverlayBlend, this.opts.renderOverlayBlend);
     this.gl.uniform4fv(this.renderShader.uniforms.clipPlane, this.scene.clipPlane);
@@ -29408,6 +29850,7 @@ var Niivue = class _Niivue {
     this.scene.pan2Dxyzmm[0] = this.uiData.pan2DxyzmmAtMouseDown[0] + zoom * v[0];
     this.scene.pan2Dxyzmm[1] = this.uiData.pan2DxyzmmAtMouseDown[1] + zoom * v[1];
     this.scene.pan2Dxyzmm[2] = this.uiData.pan2DxyzmmAtMouseDown[2] + zoom * v[2];
+    this.canvas.focus();
   }
   dragForCenterButton(startXYendXY) {
     this.dragForPanZoom(startXYendXY);