@playcanvas/splat-transform 0.1.2 → 0.2.0

package/dist/index.mjs

@@ -1,7 +1,2311 @@
 import { open } from 'node:fs/promises';
-import { Buffer } from 'node:buffer';
+import { resolve, dirname } from 'node:path';
+import { exit } from 'node:process';
+import { parseArgs } from 'node:util';
+import { Buffer as Buffer$1 } from 'node:buffer';
+import sharp from 'sharp';
 
-var version = "0.1.2";
+const math = {
+		DEG_TO_RAD: Math.PI / 180,
+		RAD_TO_DEG: 180 / Math.PI};
+
+class Vec3 {
+		constructor(x = 0, y = 0, z = 0){
+				if (x.length === 3) {
+						this.x = x[0];
+						this.y = x[1];
+						this.z = x[2];
+				} else {
+						this.x = x;
+						this.y = y;
+						this.z = z;
+				}
+		}
+		add(rhs) {
+				this.x += rhs.x;
+				this.y += rhs.y;
+				this.z += rhs.z;
+				return this;
+		}
+		add2(lhs, rhs) {
+				this.x = lhs.x + rhs.x;
+				this.y = lhs.y + rhs.y;
+				this.z = lhs.z + rhs.z;
+				return this;
+		}
+		addScalar(scalar) {
+				this.x += scalar;
+				this.y += scalar;
+				this.z += scalar;
+				return this;
+		}
+		addScaled(rhs, scalar) {
+				this.x += rhs.x * scalar;
+				this.y += rhs.y * scalar;
+				this.z += rhs.z * scalar;
+				return this;
+		}
+		clone() {
+				const cstr = this.constructor;
+				return new cstr(this.x, this.y, this.z);
+		}
+		copy(rhs) {
+				this.x = rhs.x;
+				this.y = rhs.y;
+				this.z = rhs.z;
+				return this;
+		}
+		cross(lhs, rhs) {
+				const lx = lhs.x;
+				const ly = lhs.y;
+				const lz = lhs.z;
+				const rx = rhs.x;
+				const ry = rhs.y;
+				const rz = rhs.z;
+				this.x = ly * rz - ry * lz;
+				this.y = lz * rx - rz * lx;
+				this.z = lx * ry - rx * ly;
+				return this;
+		}
+		distance(rhs) {
+				const x = this.x - rhs.x;
+				const y = this.y - rhs.y;
+				const z = this.z - rhs.z;
+				return Math.sqrt(x * x + y * y + z * z);
+		}
+		div(rhs) {
+				this.x /= rhs.x;
+				this.y /= rhs.y;
+				this.z /= rhs.z;
+				return this;
+		}
+		div2(lhs, rhs) {
+				this.x = lhs.x / rhs.x;
+				this.y = lhs.y / rhs.y;
+				this.z = lhs.z / rhs.z;
+				return this;
+		}
+		divScalar(scalar) {
+				this.x /= scalar;
+				this.y /= scalar;
+				this.z /= scalar;
+				return this;
+		}
+		dot(rhs) {
+				return this.x * rhs.x + this.y * rhs.y + this.z * rhs.z;
+		}
+		equals(rhs) {
+				return this.x === rhs.x && this.y === rhs.y && this.z === rhs.z;
+		}
+		equalsApprox(rhs, epsilon = 1e-6) {
+				return Math.abs(this.x - rhs.x) < epsilon && Math.abs(this.y - rhs.y) < epsilon && Math.abs(this.z - rhs.z) < epsilon;
+		}
+		length() {
+				return Math.sqrt(this.x * this.x + this.y * this.y + this.z * this.z);
+		}
+		lengthSq() {
+				return this.x * this.x + this.y * this.y + this.z * this.z;
+		}
+		lerp(lhs, rhs, alpha) {
+				this.x = lhs.x + alpha * (rhs.x - lhs.x);
+				this.y = lhs.y + alpha * (rhs.y - lhs.y);
+				this.z = lhs.z + alpha * (rhs.z - lhs.z);
+				return this;
+		}
+		mul(rhs) {
+				this.x *= rhs.x;
+				this.y *= rhs.y;
+				this.z *= rhs.z;
+				return this;
+		}
+		mul2(lhs, rhs) {
+				this.x = lhs.x * rhs.x;
+				this.y = lhs.y * rhs.y;
+				this.z = lhs.z * rhs.z;
+				return this;
+		}
+		mulScalar(scalar) {
+				this.x *= scalar;
+				this.y *= scalar;
+				this.z *= scalar;
+				return this;
+		}
+		normalize(src = this) {
+				const lengthSq = src.x * src.x + src.y * src.y + src.z * src.z;
+				if (lengthSq > 0) {
+						const invLength = 1 / Math.sqrt(lengthSq);
+						this.x = src.x * invLength;
+						this.y = src.y * invLength;
+						this.z = src.z * invLength;
+				}
+				return this;
+		}
+		floor(src = this) {
+				this.x = Math.floor(src.x);
+				this.y = Math.floor(src.y);
+				this.z = Math.floor(src.z);
+				return this;
+		}
+		ceil(src = this) {
+				this.x = Math.ceil(src.x);
+				this.y = Math.ceil(src.y);
+				this.z = Math.ceil(src.z);
+				return this;
+		}
+		round(src = this) {
+				this.x = Math.round(src.x);
+				this.y = Math.round(src.y);
+				this.z = Math.round(src.z);
+				return this;
+		}
+		min(rhs) {
+				if (rhs.x < this.x) this.x = rhs.x;
+				if (rhs.y < this.y) this.y = rhs.y;
+				if (rhs.z < this.z) this.z = rhs.z;
+				return this;
+		}
+		max(rhs) {
+				if (rhs.x > this.x) this.x = rhs.x;
+				if (rhs.y > this.y) this.y = rhs.y;
+				if (rhs.z > this.z) this.z = rhs.z;
+				return this;
+		}
+		project(rhs) {
+				const a_dot_b = this.x * rhs.x + this.y * rhs.y + this.z * rhs.z;
+				const b_dot_b = rhs.x * rhs.x + rhs.y * rhs.y + rhs.z * rhs.z;
+				const s = a_dot_b / b_dot_b;
+				this.x = rhs.x * s;
+				this.y = rhs.y * s;
+				this.z = rhs.z * s;
+				return this;
+		}
+		set(x, y, z) {
+				this.x = x;
+				this.y = y;
+				this.z = z;
+				return this;
+		}
+		sub(rhs) {
+				this.x -= rhs.x;
+				this.y -= rhs.y;
+				this.z -= rhs.z;
+				return this;
+		}
+		sub2(lhs, rhs) {
+				this.x = lhs.x - rhs.x;
+				this.y = lhs.y - rhs.y;
+				this.z = lhs.z - rhs.z;
+				return this;
+		}
+		subScalar(scalar) {
+				this.x -= scalar;
+				this.y -= scalar;
+				this.z -= scalar;
+				return this;
+		}
+		fromArray(arr, offset = 0) {
+				this.x = arr[offset] ?? this.x;
+				this.y = arr[offset + 1] ?? this.y;
+				this.z = arr[offset + 2] ?? this.z;
+				return this;
+		}
+		toString() {
+				return `[${this.x}, ${this.y}, ${this.z}]`;
+		}
+		toArray(arr = [], offset = 0) {
+				arr[offset] = this.x;
+				arr[offset + 1] = this.y;
+				arr[offset + 2] = this.z;
+				return arr;
+		}
+		static{
+				this.ZERO = Object.freeze(new Vec3(0, 0, 0));
+		}
+		static{
+				this.HALF = Object.freeze(new Vec3(0.5, 0.5, 0.5));
+		}
+		static{
+				this.ONE = Object.freeze(new Vec3(1, 1, 1));
+		}
+		static{
+				this.UP = Object.freeze(new Vec3(0, 1, 0));
+		}
+		static{
+				this.DOWN = Object.freeze(new Vec3(0, -1, 0));
+		}
+		static{
+				this.RIGHT = Object.freeze(new Vec3(1, 0, 0));
+		}
+		static{
+				this.LEFT = Object.freeze(new Vec3(-1, 0, 0));
+		}
+		static{
+				this.FORWARD = Object.freeze(new Vec3(0, 0, -1));
+		}
+		static{
+				this.BACK = Object.freeze(new Vec3(0, 0, 1));
+		}
+}
+
+class Mat3 {
+		constructor(){
+				this.data = new Float32Array(9);
+				this.data[0] = this.data[4] = this.data[8] = 1;
+		}
+		clone() {
+				const cstr = this.constructor;
+				return new cstr().copy(this);
+		}
+		copy(rhs) {
+				const src = rhs.data;
+				const dst = this.data;
+				dst[0] = src[0];
+				dst[1] = src[1];
+				dst[2] = src[2];
+				dst[3] = src[3];
+				dst[4] = src[4];
+				dst[5] = src[5];
+				dst[6] = src[6];
+				dst[7] = src[7];
+				dst[8] = src[8];
+				return this;
+		}
+		set(src) {
+				const dst = this.data;
+				dst[0] = src[0];
+				dst[1] = src[1];
+				dst[2] = src[2];
+				dst[3] = src[3];
+				dst[4] = src[4];
+				dst[5] = src[5];
+				dst[6] = src[6];
+				dst[7] = src[7];
+				dst[8] = src[8];
+				return this;
+		}
+		getX(x = new Vec3()) {
+				return x.set(this.data[0], this.data[1], this.data[2]);
+		}
+		getY(y = new Vec3()) {
+				return y.set(this.data[3], this.data[4], this.data[5]);
+		}
+		getZ(z = new Vec3()) {
+				return z.set(this.data[6], this.data[7], this.data[8]);
+		}
+		equals(rhs) {
+				const l = this.data;
+				const r = rhs.data;
+				return l[0] === r[0] && l[1] === r[1] && l[2] === r[2] && l[3] === r[3] && l[4] === r[4] && l[5] === r[5] && l[6] === r[6] && l[7] === r[7] && l[8] === r[8];
+		}
+		isIdentity() {
+				const m = this.data;
+				return m[0] === 1 && m[1] === 0 && m[2] === 0 && m[3] === 0 && m[4] === 1 && m[5] === 0 && m[6] === 0 && m[7] === 0 && m[8] === 1;
+		}
+		setIdentity() {
+				const m = this.data;
+				m[0] = 1;
+				m[1] = 0;
+				m[2] = 0;
+				m[3] = 0;
+				m[4] = 1;
+				m[5] = 0;
+				m[6] = 0;
+				m[7] = 0;
+				m[8] = 1;
+				return this;
+		}
+		toString() {
+				return `[${this.data.join(', ')}]`;
+		}
+		transpose(src = this) {
+				const s = src.data;
+				const t = this.data;
+				if (s === t) {
+						let tmp;
+						tmp = s[1];
+						t[1] = s[3];
+						t[3] = tmp;
+						tmp = s[2];
+						t[2] = s[6];
+						t[6] = tmp;
+						tmp = s[5];
+						t[5] = s[7];
+						t[7] = tmp;
+				} else {
+						t[0] = s[0];
+						t[1] = s[3];
+						t[2] = s[6];
+						t[3] = s[1];
+						t[4] = s[4];
+						t[5] = s[7];
+						t[6] = s[2];
+						t[7] = s[5];
+						t[8] = s[8];
+				}
+				return this;
+		}
+		setFromMat4(m) {
+				const src = m.data;
+				const dst = this.data;
+				dst[0] = src[0];
+				dst[1] = src[1];
+				dst[2] = src[2];
+				dst[3] = src[4];
+				dst[4] = src[5];
+				dst[5] = src[6];
+				dst[6] = src[8];
+				dst[7] = src[9];
+				dst[8] = src[10];
+				return this;
+		}
+		setFromQuat(r) {
+				const qx = r.x;
+				const qy = r.y;
+				const qz = r.z;
+				const qw = r.w;
+				const x2 = qx + qx;
+				const y2 = qy + qy;
+				const z2 = qz + qz;
+				const xx = qx * x2;
+				const xy = qx * y2;
+				const xz = qx * z2;
+				const yy = qy * y2;
+				const yz = qy * z2;
+				const zz = qz * z2;
+				const wx = qw * x2;
+				const wy = qw * y2;
+				const wz = qw * z2;
+				const m = this.data;
+				m[0] = 1 - (yy + zz);
+				m[1] = xy + wz;
+				m[2] = xz - wy;
+				m[3] = xy - wz;
+				m[4] = 1 - (xx + zz);
+				m[5] = yz + wx;
+				m[6] = xz + wy;
+				m[7] = yz - wx;
+				m[8] = 1 - (xx + yy);
+				return this;
+		}
+		invertMat4(src) {
+				const s = src.data;
+				const a0 = s[0];
+				const a1 = s[1];
+				const a2 = s[2];
+				const a4 = s[4];
+				const a5 = s[5];
+				const a6 = s[6];
+				const a8 = s[8];
+				const a9 = s[9];
+				const a10 = s[10];
+				const b11 = a10 * a5 - a6 * a9;
+				const b21 = -a10 * a1 + a2 * a9;
+				const b31 = a6 * a1 - a2 * a5;
+				const b12 = -a10 * a4 + a6 * a8;
+				const b22 = a10 * a0 - a2 * a8;
+				const b32 = -a6 * a0 + a2 * a4;
+				const b13 = a9 * a4 - a5 * a8;
+				const b23 = -a9 * a0 + a1 * a8;
+				const b33 = a5 * a0 - a1 * a4;
+				const det = a0 * b11 + a1 * b12 + a2 * b13;
+				if (det === 0) {
+						this.setIdentity();
+				} else {
+						const invDet = 1 / det;
+						const t = this.data;
+						t[0] = b11 * invDet;
+						t[1] = b21 * invDet;
+						t[2] = b31 * invDet;
+						t[3] = b12 * invDet;
+						t[4] = b22 * invDet;
+						t[5] = b32 * invDet;
+						t[6] = b13 * invDet;
+						t[7] = b23 * invDet;
+						t[8] = b33 * invDet;
+				}
+				return this;
+		}
+		transformVector(vec, res = new Vec3()) {
+				const m = this.data;
+				const { x, y, z } = vec;
+				res.x = x * m[0] + y * m[3] + z * m[6];
+				res.y = x * m[1] + y * m[4] + z * m[7];
+				res.z = x * m[2] + y * m[5] + z * m[8];
+				return res;
+		}
+		static{
+				this.IDENTITY = Object.freeze(new Mat3());
+		}
+		static{
+				this.ZERO = Object.freeze(new Mat3().set([
+						0,
+						0,
+						0,
+						0,
+						0,
+						0,
+						0,
+						0,
+						0
+				]));
+		}
+}
+
+class Vec2 {
+		constructor(x = 0, y = 0){
+				if (x.length === 2) {
+						this.x = x[0];
+						this.y = x[1];
+				} else {
+						this.x = x;
+						this.y = y;
+				}
+		}
+		add(rhs) {
+				this.x += rhs.x;
+				this.y += rhs.y;
+				return this;
+		}
+		add2(lhs, rhs) {
+				this.x = lhs.x + rhs.x;
+				this.y = lhs.y + rhs.y;
+				return this;
+		}
+		addScalar(scalar) {
+				this.x += scalar;
+				this.y += scalar;
+				return this;
+		}
+		addScaled(rhs, scalar) {
+				this.x += rhs.x * scalar;
+				this.y += rhs.y * scalar;
+				return this;
+		}
+		clone() {
+				const cstr = this.constructor;
+				return new cstr(this.x, this.y);
+		}
+		copy(rhs) {
+				this.x = rhs.x;
+				this.y = rhs.y;
+				return this;
+		}
+		cross(rhs) {
+				return this.x * rhs.y - this.y * rhs.x;
+		}
+		distance(rhs) {
+				const x = this.x - rhs.x;
+				const y = this.y - rhs.y;
+				return Math.sqrt(x * x + y * y);
+		}
+		div(rhs) {
+				this.x /= rhs.x;
+				this.y /= rhs.y;
+				return this;
+		}
+		div2(lhs, rhs) {
+				this.x = lhs.x / rhs.x;
+				this.y = lhs.y / rhs.y;
+				return this;
+		}
+		divScalar(scalar) {
+				this.x /= scalar;
+				this.y /= scalar;
+				return this;
+		}
+		dot(rhs) {
+				return this.x * rhs.x + this.y * rhs.y;
+		}
+		equals(rhs) {
+				return this.x === rhs.x && this.y === rhs.y;
+		}
+		equalsApprox(rhs, epsilon = 1e-6) {
+				return Math.abs(this.x - rhs.x) < epsilon && Math.abs(this.y - rhs.y) < epsilon;
+		}
+		length() {
+				return Math.sqrt(this.x * this.x + this.y * this.y);
+		}
+		lengthSq() {
+				return this.x * this.x + this.y * this.y;
+		}
+		lerp(lhs, rhs, alpha) {
+				this.x = lhs.x + alpha * (rhs.x - lhs.x);
+				this.y = lhs.y + alpha * (rhs.y - lhs.y);
+				return this;
+		}
+		mul(rhs) {
+				this.x *= rhs.x;
+				this.y *= rhs.y;
+				return this;
+		}
+		mul2(lhs, rhs) {
+				this.x = lhs.x * rhs.x;
+				this.y = lhs.y * rhs.y;
+				return this;
+		}
+		mulScalar(scalar) {
+				this.x *= scalar;
+				this.y *= scalar;
+				return this;
+		}
+		normalize(src = this) {
+				const lengthSq = src.x * src.x + src.y * src.y;
+				if (lengthSq > 0) {
+						const invLength = 1 / Math.sqrt(lengthSq);
+						this.x = src.x * invLength;
+						this.y = src.y * invLength;
+				}
+				return this;
+		}
+		rotate(degrees) {
+				const angle = Math.atan2(this.x, this.y) + degrees * math.DEG_TO_RAD;
+				const len = Math.sqrt(this.x * this.x + this.y * this.y);
+				this.x = Math.sin(angle) * len;
+				this.y = Math.cos(angle) * len;
+				return this;
+		}
+		angle() {
+				return Math.atan2(this.x, this.y) * math.RAD_TO_DEG;
+		}
+		angleTo(rhs) {
+				return Math.atan2(this.x * rhs.y + this.y * rhs.x, this.x * rhs.x + this.y * rhs.y) * math.RAD_TO_DEG;
+		}
+		floor(src = this) {
+				this.x = Math.floor(src.x);
+				this.y = Math.floor(src.y);
+				return this;
+		}
+		ceil(src = this) {
+				this.x = Math.ceil(src.x);
+				this.y = Math.ceil(src.y);
+				return this;
+		}
+		round(src = this) {
+				this.x = Math.round(src.x);
+				this.y = Math.round(src.y);
+				return this;
+		}
+		min(rhs) {
+				if (rhs.x < this.x) this.x = rhs.x;
+				if (rhs.y < this.y) this.y = rhs.y;
+				return this;
+		}
+		max(rhs) {
+				if (rhs.x > this.x) this.x = rhs.x;
+				if (rhs.y > this.y) this.y = rhs.y;
+				return this;
+		}
+		set(x, y) {
+				this.x = x;
+				this.y = y;
+				return this;
+		}
+		sub(rhs) {
+				this.x -= rhs.x;
+				this.y -= rhs.y;
+				return this;
+		}
+		sub2(lhs, rhs) {
+				this.x = lhs.x - rhs.x;
+				this.y = lhs.y - rhs.y;
+				return this;
+		}
+		subScalar(scalar) {
+				this.x -= scalar;
+				this.y -= scalar;
+				return this;
+		}
+		fromArray(arr, offset = 0) {
+				this.x = arr[offset] ?? this.x;
+				this.y = arr[offset + 1] ?? this.y;
+				return this;
+		}
+		toString() {
+				return `[${this.x}, ${this.y}]`;
+		}
+		toArray(arr = [], offset = 0) {
+				arr[offset] = this.x;
+				arr[offset + 1] = this.y;
+				return arr;
+		}
+		static angleRad(lhs, rhs) {
+				return Math.atan2(lhs.x * rhs.y - lhs.y * rhs.x, lhs.x * rhs.x + lhs.y * rhs.y);
+		}
+		static{
+				this.ZERO = Object.freeze(new Vec2(0, 0));
+		}
+		static{
+				this.HALF = Object.freeze(new Vec2(0.5, 0.5));
+		}
+		static{
+				this.ONE = Object.freeze(new Vec2(1, 1));
+		}
+		static{
+				this.UP = Object.freeze(new Vec2(0, 1));
+		}
+		static{
+				this.DOWN = Object.freeze(new Vec2(0, -1));
+		}
+		static{
+				this.RIGHT = Object.freeze(new Vec2(1, 0));
+		}
+		static{
+				this.LEFT = Object.freeze(new Vec2(-1, 0));
+		}
+}
+
+class Vec4 {
+		constructor(x = 0, y = 0, z = 0, w = 0){
+				if (x.length === 4) {
+						this.x = x[0];
+						this.y = x[1];
+						this.z = x[2];
+						this.w = x[3];
+				} else {
+						this.x = x;
+						this.y = y;
+						this.z = z;
+						this.w = w;
+				}
+		}
+		add(rhs) {
+				this.x += rhs.x;
+				this.y += rhs.y;
+				this.z += rhs.z;
+				this.w += rhs.w;
+				return this;
+		}
+		add2(lhs, rhs) {
+				this.x = lhs.x + rhs.x;
+				this.y = lhs.y + rhs.y;
+				this.z = lhs.z + rhs.z;
+				this.w = lhs.w + rhs.w;
+				return this;
+		}
+		addScalar(scalar) {
+				this.x += scalar;
+				this.y += scalar;
+				this.z += scalar;
+				this.w += scalar;
+				return this;
+		}
+		addScaled(rhs, scalar) {
+				this.x += rhs.x * scalar;
+				this.y += rhs.y * scalar;
+				this.z += rhs.z * scalar;
+				this.w += rhs.w * scalar;
+				return this;
+		}
+		clone() {
+				const cstr = this.constructor;
+				return new cstr(this.x, this.y, this.z, this.w);
+		}
+		copy(rhs) {
+				this.x = rhs.x;
+				this.y = rhs.y;
+				this.z = rhs.z;
+				this.w = rhs.w;
+				return this;
+		}
+		div(rhs) {
+				this.x /= rhs.x;
+				this.y /= rhs.y;
+				this.z /= rhs.z;
+				this.w /= rhs.w;
+				return this;
+		}
+		div2(lhs, rhs) {
+				this.x = lhs.x / rhs.x;
+				this.y = lhs.y / rhs.y;
+				this.z = lhs.z / rhs.z;
+				this.w = lhs.w / rhs.w;
+				return this;
+		}
+		divScalar(scalar) {
+				this.x /= scalar;
+				this.y /= scalar;
+				this.z /= scalar;
+				this.w /= scalar;
+				return this;
+		}
+		dot(rhs) {
+				return this.x * rhs.x + this.y * rhs.y + this.z * rhs.z + this.w * rhs.w;
+		}
+		equals(rhs) {
+				return this.x === rhs.x && this.y === rhs.y && this.z === rhs.z && this.w === rhs.w;
+		}
+		equalsApprox(rhs, epsilon = 1e-6) {
+				return Math.abs(this.x - rhs.x) < epsilon && Math.abs(this.y - rhs.y) < epsilon && Math.abs(this.z - rhs.z) < epsilon && Math.abs(this.w - rhs.w) < epsilon;
+		}
+		length() {
+				return Math.sqrt(this.x * this.x + this.y * this.y + this.z * this.z + this.w * this.w);
+		}
+		lengthSq() {
+				return this.x * this.x + this.y * this.y + this.z * this.z + this.w * this.w;
+		}
+		lerp(lhs, rhs, alpha) {
+				this.x = lhs.x + alpha * (rhs.x - lhs.x);
+				this.y = lhs.y + alpha * (rhs.y - lhs.y);
+				this.z = lhs.z + alpha * (rhs.z - lhs.z);
+				this.w = lhs.w + alpha * (rhs.w - lhs.w);
+				return this;
+		}
+		mul(rhs) {
+				this.x *= rhs.x;
+				this.y *= rhs.y;
+				this.z *= rhs.z;
+				this.w *= rhs.w;
+				return this;
+		}
+		mul2(lhs, rhs) {
+				this.x = lhs.x * rhs.x;
+				this.y = lhs.y * rhs.y;
+				this.z = lhs.z * rhs.z;
+				this.w = lhs.w * rhs.w;
+				return this;
+		}
+		mulScalar(scalar) {
+				this.x *= scalar;
+				this.y *= scalar;
+				this.z *= scalar;
+				this.w *= scalar;
+				return this;
+		}
+		normalize(src = this) {
+				const lengthSq = src.x * src.x + src.y * src.y + src.z * src.z + src.w * src.w;
+				if (lengthSq > 0) {
+						const invLength = 1 / Math.sqrt(lengthSq);
+						this.x = src.x * invLength;
+						this.y = src.y * invLength;
+						this.z = src.z * invLength;
+						this.w = src.w * invLength;
+				}
+				return this;
+		}
+		floor(src = this) {
+				this.x = Math.floor(src.x);
+				this.y = Math.floor(src.y);
+				this.z = Math.floor(src.z);
+				this.w = Math.floor(src.w);
+				return this;
+		}
+		ceil(src = this) {
+				this.x = Math.ceil(src.x);
+				this.y = Math.ceil(src.y);
+				this.z = Math.ceil(src.z);
+				this.w = Math.ceil(src.w);
+				return this;
+		}
+		round(src = this) {
+				this.x = Math.round(src.x);
+				this.y = Math.round(src.y);
+				this.z = Math.round(src.z);
+				this.w = Math.round(src.w);
+				return this;
+		}
+		min(rhs) {
+				if (rhs.x < this.x) this.x = rhs.x;
+				if (rhs.y < this.y) this.y = rhs.y;
+				if (rhs.z < this.z) this.z = rhs.z;
+				if (rhs.w < this.w) this.w = rhs.w;
+				return this;
+		}
+		max(rhs) {
+				if (rhs.x > this.x) this.x = rhs.x;
+				if (rhs.y > this.y) this.y = rhs.y;
+				if (rhs.z > this.z) this.z = rhs.z;
+				if (rhs.w > this.w) this.w = rhs.w;
+				return this;
+		}
+		set(x, y, z, w) {
+				this.x = x;
+				this.y = y;
+				this.z = z;
+				this.w = w;
+				return this;
+		}
+		sub(rhs) {
+				this.x -= rhs.x;
+				this.y -= rhs.y;
+				this.z -= rhs.z;
+				this.w -= rhs.w;
+				return this;
+		}
+		sub2(lhs, rhs) {
+				this.x = lhs.x - rhs.x;
+				this.y = lhs.y - rhs.y;
+				this.z = lhs.z - rhs.z;
+				this.w = lhs.w - rhs.w;
+				return this;
+		}
+		subScalar(scalar) {
+				this.x -= scalar;
+				this.y -= scalar;
+				this.z -= scalar;
+				this.w -= scalar;
+				return this;
+		}
+		fromArray(arr, offset = 0) {
+				this.x = arr[offset] ?? this.x;
+				this.y = arr[offset + 1] ?? this.y;
+				this.z = arr[offset + 2] ?? this.z;
+				this.w = arr[offset + 3] ?? this.w;
+				return this;
+		}
+		toString() {
+				return `[${this.x}, ${this.y}, ${this.z}, ${this.w}]`;
+		}
+		toArray(arr = [], offset = 0) {
+				arr[offset] = this.x;
+				arr[offset + 1] = this.y;
+				arr[offset + 2] = this.z;
+				arr[offset + 3] = this.w;
+				return arr;
+		}
+		static{
+				this.ZERO = Object.freeze(new Vec4(0, 0, 0, 0));
+		}
+		static{
+				this.HALF = Object.freeze(new Vec4(0.5, 0.5, 0.5, 0.5));
+		}
+		static{
+				this.ONE = Object.freeze(new Vec4(1, 1, 1, 1));
+		}
+}
+
+const _halfSize = new Vec2();
+const x = new Vec3();
+const y = new Vec3();
+const z = new Vec3();
+const scale = new Vec3();
+class Mat4 {
+		constructor(){
+				this.data = new Float32Array(16);
+				this.data[0] = this.data[5] = this.data[10] = this.data[15] = 1;
+		}
+		static _getPerspectiveHalfSize(halfSize, fov, aspect, znear, fovIsHorizontal) {
+				if (fovIsHorizontal) {
+						halfSize.x = znear * Math.tan(fov * Math.PI / 360);
+						halfSize.y = halfSize.x / aspect;
+				} else {
+						halfSize.y = znear * Math.tan(fov * Math.PI / 360);
+						halfSize.x = halfSize.y * aspect;
+				}
+		}
+		add2(lhs, rhs) {
+				const a = lhs.data, b = rhs.data, r = this.data;
+				r[0] = a[0] + b[0];
+				r[1] = a[1] + b[1];
+				r[2] = a[2] + b[2];
+				r[3] = a[3] + b[3];
+				r[4] = a[4] + b[4];
+				r[5] = a[5] + b[5];
+				r[6] = a[6] + b[6];
+				r[7] = a[7] + b[7];
+				r[8] = a[8] + b[8];
+				r[9] = a[9] + b[9];
+				r[10] = a[10] + b[10];
+				r[11] = a[11] + b[11];
+				r[12] = a[12] + b[12];
+				r[13] = a[13] + b[13];
+				r[14] = a[14] + b[14];
+				r[15] = a[15] + b[15];
+				return this;
+		}
+		add(rhs) {
+				return this.add2(this, rhs);
+		}
+		clone() {
+				const cstr = this.constructor;
+				return new cstr().copy(this);
+		}
+		copy(rhs) {
+				const src = rhs.data, dst = this.data;
+				dst[0] = src[0];
+				dst[1] = src[1];
+				dst[2] = src[2];
+				dst[3] = src[3];
+				dst[4] = src[4];
+				dst[5] = src[5];
+				dst[6] = src[6];
+				dst[7] = src[7];
+				dst[8] = src[8];
+				dst[9] = src[9];
+				dst[10] = src[10];
+				dst[11] = src[11];
+				dst[12] = src[12];
+				dst[13] = src[13];
+				dst[14] = src[14];
+				dst[15] = src[15];
+				return this;
+		}
+		equals(rhs) {
+				const l = this.data, r = rhs.data;
+				return l[0] === r[0] && l[1] === r[1] && l[2] === r[2] && l[3] === r[3] && l[4] === r[4] && l[5] === r[5] && l[6] === r[6] && l[7] === r[7] && l[8] === r[8] && l[9] === r[9] && l[10] === r[10] && l[11] === r[11] && l[12] === r[12] && l[13] === r[13] && l[14] === r[14] && l[15] === r[15];
+		}
+		isIdentity() {
+				const m = this.data;
+				return m[0] === 1 && m[1] === 0 && m[2] === 0 && m[3] === 0 && m[4] === 0 && m[5] === 1 && m[6] === 0 && m[7] === 0 && m[8] === 0 && m[9] === 0 && m[10] === 1 && m[11] === 0 && m[12] === 0 && m[13] === 0 && m[14] === 0 && m[15] === 1;
+		}
+		mul2(lhs, rhs) {
+				const a = lhs.data;
+				const b = rhs.data;
+				const r = this.data;
+				const a00 = a[0];
+				const a01 = a[1];
+				const a02 = a[2];
+				const a03 = a[3];
+				const a10 = a[4];
+				const a11 = a[5];
+				const a12 = a[6];
+				const a13 = a[7];
+				const a20 = a[8];
+				const a21 = a[9];
+				const a22 = a[10];
+				const a23 = a[11];
+				const a30 = a[12];
+				const a31 = a[13];
+				const a32 = a[14];
+				const a33 = a[15];
+				let b0, b1, b2, b3;
+				b0 = b[0];
+				b1 = b[1];
+				b2 = b[2];
+				b3 = b[3];
+				r[0] = a00 * b0 + a10 * b1 + a20 * b2 + a30 * b3;
+				r[1] = a01 * b0 + a11 * b1 + a21 * b2 + a31 * b3;
+				r[2] = a02 * b0 + a12 * b1 + a22 * b2 + a32 * b3;
+				r[3] = a03 * b0 + a13 * b1 + a23 * b2 + a33 * b3;
+				b0 = b[4];
+				b1 = b[5];
+				b2 = b[6];
+				b3 = b[7];
+				r[4] = a00 * b0 + a10 * b1 + a20 * b2 + a30 * b3;
+				r[5] = a01 * b0 + a11 * b1 + a21 * b2 + a31 * b3;
+				r[6] = a02 * b0 + a12 * b1 + a22 * b2 + a32 * b3;
+				r[7] = a03 * b0 + a13 * b1 + a23 * b2 + a33 * b3;
+				b0 = b[8];
+				b1 = b[9];
+				b2 = b[10];
+				b3 = b[11];
+				r[8] = a00 * b0 + a10 * b1 + a20 * b2 + a30 * b3;
+				r[9] = a01 * b0 + a11 * b1 + a21 * b2 + a31 * b3;
+				r[10] = a02 * b0 + a12 * b1 + a22 * b2 + a32 * b3;
+				r[11] = a03 * b0 + a13 * b1 + a23 * b2 + a33 * b3;
+				b0 = b[12];
+				b1 = b[13];
+				b2 = b[14];
+				b3 = b[15];
+				r[12] = a00 * b0 + a10 * b1 + a20 * b2 + a30 * b3;
+				r[13] = a01 * b0 + a11 * b1 + a21 * b2 + a31 * b3;
+				r[14] = a02 * b0 + a12 * b1 + a22 * b2 + a32 * b3;
+				r[15] = a03 * b0 + a13 * b1 + a23 * b2 + a33 * b3;
+				return this;
+		}
+		mulAffine2(lhs, rhs) {
+				const a = lhs.data;
+				const b = rhs.data;
+				const r = this.data;
+				const a00 = a[0];
+				const a01 = a[1];
+				const a02 = a[2];
+				const a10 = a[4];
+				const a11 = a[5];
+				const a12 = a[6];
+				const a20 = a[8];
+				const a21 = a[9];
+				const a22 = a[10];
+				const a30 = a[12];
+				const a31 = a[13];
+				const a32 = a[14];
+				let b0, b1, b2;
+				b0 = b[0];
+				b1 = b[1];
+				b2 = b[2];
+				r[0] = a00 * b0 + a10 * b1 + a20 * b2;
+				r[1] = a01 * b0 + a11 * b1 + a21 * b2;
+				r[2] = a02 * b0 + a12 * b1 + a22 * b2;
+				r[3] = 0;
+				b0 = b[4];
+				b1 = b[5];
+				b2 = b[6];
+				r[4] = a00 * b0 + a10 * b1 + a20 * b2;
+				r[5] = a01 * b0 + a11 * b1 + a21 * b2;
+				r[6] = a02 * b0 + a12 * b1 + a22 * b2;
+				r[7] = 0;
+				b0 = b[8];
+				b1 = b[9];
+				b2 = b[10];
+				r[8] = a00 * b0 + a10 * b1 + a20 * b2;
+				r[9] = a01 * b0 + a11 * b1 + a21 * b2;
+				r[10] = a02 * b0 + a12 * b1 + a22 * b2;
+				r[11] = 0;
+				b0 = b[12];
+				b1 = b[13];
+				b2 = b[14];
+				r[12] = a00 * b0 + a10 * b1 + a20 * b2 + a30;
+				r[13] = a01 * b0 + a11 * b1 + a21 * b2 + a31;
+				r[14] = a02 * b0 + a12 * b1 + a22 * b2 + a32;
+				r[15] = 1;
+				return this;
+		}
+		mul(rhs) {
+				return this.mul2(this, rhs);
+		}
+		transformPoint(vec, res = new Vec3()) {
+				const m = this.data;
+				const { x, y, z } = vec;
+				res.x = x * m[0] + y * m[4] + z * m[8] + m[12];
+				res.y = x * m[1] + y * m[5] + z * m[9] + m[13];
+				res.z = x * m[2] + y * m[6] + z * m[10] + m[14];
+				return res;
+		}
+		transformVector(vec, res = new Vec3()) {
+				const m = this.data;
+				const { x, y, z } = vec;
+				res.x = x * m[0] + y * m[4] + z * m[8];
+				res.y = x * m[1] + y * m[5] + z * m[9];
+				res.z = x * m[2] + y * m[6] + z * m[10];
+				return res;
+		}
+		transformVec4(vec, res = new Vec4()) {
+				const m = this.data;
+				const { x, y, z, w } = vec;
+				res.x = x * m[0] + y * m[4] + z * m[8] + w * m[12];
+				res.y = x * m[1] + y * m[5] + z * m[9] + w * m[13];
+				res.z = x * m[2] + y * m[6] + z * m[10] + w * m[14];
+				res.w = x * m[3] + y * m[7] + z * m[11] + w * m[15];
+				return res;
+		}
+		setLookAt(position, target, up) {
+				z.sub2(position, target).normalize();
+				y.copy(up).normalize();
+				x.cross(y, z).normalize();
+				y.cross(z, x);
+				const r = this.data;
+				r[0] = x.x;
+				r[1] = x.y;
+				r[2] = x.z;
+				r[3] = 0;
+				r[4] = y.x;
+				r[5] = y.y;
+				r[6] = y.z;
+				r[7] = 0;
+				r[8] = z.x;
+				r[9] = z.y;
+				r[10] = z.z;
+				r[11] = 0;
+				r[12] = position.x;
+				r[13] = position.y;
+				r[14] = position.z;
+				r[15] = 1;
+				return this;
+		}
+		setFrustum(left, right, bottom, top, znear, zfar) {
+				const temp1 = 2 * znear;
+				const temp2 = right - left;
+				const temp3 = top - bottom;
+				const temp4 = zfar - znear;
+				const r = this.data;
+				r[0] = temp1 / temp2;
+				r[1] = 0;
+				r[2] = 0;
+				r[3] = 0;
+				r[4] = 0;
+				r[5] = temp1 / temp3;
+				r[6] = 0;
+				r[7] = 0;
+				r[8] = (right + left) / temp2;
+				r[9] = (top + bottom) / temp3;
+				r[10] = (-zfar - znear) / temp4;
+				r[11] = -1;
+				r[12] = 0;
+				r[13] = 0;
+				r[14] = -temp1 * zfar / temp4;
+				r[15] = 0;
+				return this;
+		}
+		setPerspective(fov, aspect, znear, zfar, fovIsHorizontal) {
+				Mat4._getPerspectiveHalfSize(_halfSize, fov, aspect, znear, fovIsHorizontal);
+				return this.setFrustum(-_halfSize.x, _halfSize.x, -_halfSize.y, _halfSize.y, znear, zfar);
+		}
+		setOrtho(left, right, bottom, top, near, far) {
+				const r = this.data;
+				r[0] = 2 / (right - left);
+				r[1] = 0;
+				r[2] = 0;
+				r[3] = 0;
+				r[4] = 0;
+				r[5] = 2 / (top - bottom);
+				r[6] = 0;
+				r[7] = 0;
+				r[8] = 0;
+				r[9] = 0;
+				r[10] = -2 / (far - near);
+				r[11] = 0;
+				r[12] = -(right + left) / (right - left);
+				r[13] = -(top + bottom) / (top - bottom);
+				r[14] = -(far + near) / (far - near);
+				r[15] = 1;
+				return this;
+		}
+		setFromAxisAngle(axis, angle) {
+				angle *= math.DEG_TO_RAD;
+				const { x, y, z } = axis;
+				const c = Math.cos(angle);
+				const s = Math.sin(angle);
+				const t = 1 - c;
+				const tx = t * x;
+				const ty = t * y;
+				const m = this.data;
+				m[0] = tx * x + c;
+				m[1] = tx * y + s * z;
+				m[2] = tx * z - s * y;
+				m[3] = 0;
+				m[4] = tx * y - s * z;
+				m[5] = ty * y + c;
+				m[6] = ty * z + s * x;
+				m[7] = 0;
+				m[8] = tx * z + s * y;
+				m[9] = ty * z - x * s;
+				m[10] = t * z * z + c;
+				m[11] = 0;
+				m[12] = 0;
+				m[13] = 0;
+				m[14] = 0;
+				m[15] = 1;
+				return this;
+		}
+		setTranslate(x, y, z) {
+				const m = this.data;
+				m[0] = 1;
+				m[1] = 0;
+				m[2] = 0;
+				m[3] = 0;
+				m[4] = 0;
+				m[5] = 1;
+				m[6] = 0;
+				m[7] = 0;
+				m[8] = 0;
+				m[9] = 0;
+				m[10] = 1;
+				m[11] = 0;
+				m[12] = x;
+				m[13] = y;
+				m[14] = z;
+				m[15] = 1;
+				return this;
+		}
+		setScale(x, y, z) {
+				const m = this.data;
+				m[0] = x;
+				m[1] = 0;
+				m[2] = 0;
+				m[3] = 0;
+				m[4] = 0;
+				m[5] = y;
+				m[6] = 0;
+				m[7] = 0;
+				m[8] = 0;
+				m[9] = 0;
+				m[10] = z;
+				m[11] = 0;
+				m[12] = 0;
+				m[13] = 0;
+				m[14] = 0;
+				m[15] = 1;
+				return this;
+		}
+		setViewport(x, y, width, height) {
+				const m = this.data;
+				m[0] = width * 0.5;
+				m[1] = 0;
+				m[2] = 0;
+				m[3] = 0;
+				m[4] = 0;
+				m[5] = height * 0.5;
+				m[6] = 0;
+				m[7] = 0;
+				m[8] = 0;
+				m[9] = 0;
+				m[10] = 0.5;
+				m[11] = 0;
+				m[12] = x + width * 0.5;
+				m[13] = y + height * 0.5;
+				m[14] = 0.5;
+				m[15] = 1;
+				return this;
+		}
+		setReflection(normal, distance) {
+				const a = normal.x;
+				const b = normal.y;
+				const c = normal.z;
+				const data = this.data;
+				data[0] = 1.0 - 2 * a * a;
+				data[1] = -2 * a * b;
+				data[2] = -2 * a * c;
+				data[3] = 0;
+				data[4] = -2 * a * b;
+				data[5] = 1.0 - 2 * b * b;
+				data[6] = -2 * b * c;
+				data[7] = 0;
+				data[8] = -2 * a * c;
+				data[9] = -2 * b * c;
+				data[10] = 1.0 - 2 * c * c;
+				data[11] = 0;
+				data[12] = -2 * a * distance;
+				data[13] = -2 * b * distance;
+				data[14] = -2 * c * distance;
+				data[15] = 1;
+				return this;
+		}
+		invert(src = this) {
+				const s = src.data;
+				const a00 = s[0];
+				const a01 = s[1];
+				const a02 = s[2];
+				const a03 = s[3];
+				const a10 = s[4];
+				const a11 = s[5];
+				const a12 = s[6];
+				const a13 = s[7];
+				const a20 = s[8];
+				const a21 = s[9];
+				const a22 = s[10];
+				const a23 = s[11];
+				const a30 = s[12];
+				const a31 = s[13];
+				const a32 = s[14];
+				const a33 = s[15];
+				const b00 = a00 * a11 - a01 * a10;
+				const b01 = a00 * a12 - a02 * a10;
+				const b02 = a00 * a13 - a03 * a10;
+				const b03 = a01 * a12 - a02 * a11;
+				const b04 = a01 * a13 - a03 * a11;
+				const b05 = a02 * a13 - a03 * a12;
+				const b06 = a20 * a31 - a21 * a30;
+				const b07 = a20 * a32 - a22 * a30;
+				const b08 = a20 * a33 - a23 * a30;
+				const b09 = a21 * a32 - a22 * a31;
+				const b10 = a21 * a33 - a23 * a31;
+				const b11 = a22 * a33 - a23 * a32;
+				const det = b00 * b11 - b01 * b10 + b02 * b09 + b03 * b08 - b04 * b07 + b05 * b06;
+				if (det === 0) {
+						this.setIdentity();
+				} else {
+						const invDet = 1 / det;
+						const t = this.data;
+						t[0] = (a11 * b11 - a12 * b10 + a13 * b09) * invDet;
+						t[1] = (-a01 * b11 + a02 * b10 - a03 * b09) * invDet;
+						t[2] = (a31 * b05 - a32 * b04 + a33 * b03) * invDet;
+						t[3] = (-a21 * b05 + a22 * b04 - a23 * b03) * invDet;
+						t[4] = (-a10 * b11 + a12 * b08 - a13 * b07) * invDet;
+						t[5] = (a00 * b11 - a02 * b08 + a03 * b07) * invDet;
+						t[6] = (-a30 * b05 + a32 * b02 - a33 * b01) * invDet;
+						t[7] = (a20 * b05 - a22 * b02 + a23 * b01) * invDet;
+						t[8] = (a10 * b10 - a11 * b08 + a13 * b06) * invDet;
+						t[9] = (-a00 * b10 + a01 * b08 - a03 * b06) * invDet;
+						t[10] = (a30 * b04 - a31 * b02 + a33 * b00) * invDet;
+						t[11] = (-a20 * b04 + a21 * b02 - a23 * b00) * invDet;
+						t[12] = (-a10 * b09 + a11 * b07 - a12 * b06) * invDet;
+						t[13] = (a00 * b09 - a01 * b07 + a02 * b06) * invDet;
+						t[14] = (-a30 * b03 + a31 * b01 - a32 * b00) * invDet;
+						t[15] = (a20 * b03 - a21 * b01 + a22 * b00) * invDet;
+				}
+				return this;
+		}
+		set(src) {
+				const dst = this.data;
+				dst[0] = src[0];
+				dst[1] = src[1];
+				dst[2] = src[2];
+				dst[3] = src[3];
+				dst[4] = src[4];
+				dst[5] = src[5];
+				dst[6] = src[6];
+				dst[7] = src[7];
+				dst[8] = src[8];
+				dst[9] = src[9];
+				dst[10] = src[10];
+				dst[11] = src[11];
+				dst[12] = src[12];
+				dst[13] = src[13];
+				dst[14] = src[14];
+				dst[15] = src[15];
+				return this;
+		}
+		setIdentity() {
+				const m = this.data;
+				m[0] = 1;
+				m[1] = 0;
+				m[2] = 0;
+				m[3] = 0;
+				m[4] = 0;
+				m[5] = 1;
+				m[6] = 0;
+				m[7] = 0;
+				m[8] = 0;
+				m[9] = 0;
+				m[10] = 1;
+				m[11] = 0;
+				m[12] = 0;
+				m[13] = 0;
+				m[14] = 0;
+				m[15] = 1;
+				return this;
+		}
+		setTRS(t, r, s) {
+				const qx = r.x;
+				const qy = r.y;
+				const qz = r.z;
+				const qw = r.w;
+				const sx = s.x;
+				const sy = s.y;
+				const sz = s.z;
+				const x2 = qx + qx;
+				const y2 = qy + qy;
+				const z2 = qz + qz;
+				const xx = qx * x2;
+				const xy = qx * y2;
+				const xz = qx * z2;
+				const yy = qy * y2;
+				const yz = qy * z2;
+				const zz = qz * z2;
+				const wx = qw * x2;
+				const wy = qw * y2;
+				const wz = qw * z2;
+				const m = this.data;
+				m[0] = (1 - (yy + zz)) * sx;
+				m[1] = (xy + wz) * sx;
+				m[2] = (xz - wy) * sx;
+				m[3] = 0;
+				m[4] = (xy - wz) * sy;
+				m[5] = (1 - (xx + zz)) * sy;
+				m[6] = (yz + wx) * sy;
+				m[7] = 0;
+				m[8] = (xz + wy) * sz;
+				m[9] = (yz - wx) * sz;
+				m[10] = (1 - (xx + yy)) * sz;
+				m[11] = 0;
+				m[12] = t.x;
+				m[13] = t.y;
+				m[14] = t.z;
+				m[15] = 1;
+				return this;
+		}
+		transpose(src = this) {
+				const s = src.data;
+				const t = this.data;
+				if (s === t) {
+						let tmp;
+						tmp = s[1];
+						t[1] = s[4];
+						t[4] = tmp;
+						tmp = s[2];
+						t[2] = s[8];
+						t[8] = tmp;
+						tmp = s[3];
+						t[3] = s[12];
+						t[12] = tmp;
+						tmp = s[6];
+						t[6] = s[9];
+						t[9] = tmp;
+						tmp = s[7];
+						t[7] = s[13];
+						t[13] = tmp;
+						tmp = s[11];
+						t[11] = s[14];
+						t[14] = tmp;
+				} else {
+						t[0] = s[0];
+						t[1] = s[4];
+						t[2] = s[8];
+						t[3] = s[12];
+						t[4] = s[1];
+						t[5] = s[5];
+						t[6] = s[9];
+						t[7] = s[13];
+						t[8] = s[2];
+						t[9] = s[6];
+						t[10] = s[10];
+						t[11] = s[14];
+						t[12] = s[3];
+						t[13] = s[7];
+						t[14] = s[11];
+						t[15] = s[15];
+				}
+				return this;
+		}
+		getTranslation(t = new Vec3()) {
+				return t.set(this.data[12], this.data[13], this.data[14]);
+		}
+		getX(x = new Vec3()) {
+				return x.set(this.data[0], this.data[1], this.data[2]);
+		}
+		getY(y = new Vec3()) {
+				return y.set(this.data[4], this.data[5], this.data[6]);
+		}
+		getZ(z = new Vec3()) {
+				return z.set(this.data[8], this.data[9], this.data[10]);
+		}
+		getScale(scale = new Vec3()) {
+				this.getX(x);
+				this.getY(y);
+				this.getZ(z);
+				scale.set(x.length(), y.length(), z.length());
+				return scale;
+		}
+		get scaleSign() {
+				this.getX(x);
+				this.getY(y);
+				this.getZ(z);
+				x.cross(x, y);
+				return x.dot(z) < 0 ? -1 : 1;
+		}
+		setFromEulerAngles(ex, ey, ez) {
+				ex *= math.DEG_TO_RAD;
+				ey *= math.DEG_TO_RAD;
+				ez *= math.DEG_TO_RAD;
+				const s1 = Math.sin(-ex);
+				const c1 = Math.cos(-ex);
+				const s2 = Math.sin(-ey);
+				const c2 = Math.cos(-ey);
+				const s3 = Math.sin(-ez);
+				const c3 = Math.cos(-ez);
+				const m = this.data;
+				m[0] = c2 * c3;
+				m[1] = -c2 * s3;
+				m[2] = s2;
+				m[3] = 0;
+				m[4] = c1 * s3 + c3 * s1 * s2;
+				m[5] = c1 * c3 - s1 * s2 * s3;
+				m[6] = -c2 * s1;
+				m[7] = 0;
+				m[8] = s1 * s3 - c1 * c3 * s2;
+				m[9] = c3 * s1 + c1 * s2 * s3;
+				m[10] = c1 * c2;
+				m[11] = 0;
+				m[12] = 0;
+				m[13] = 0;
+				m[14] = 0;
+				m[15] = 1;
+				return this;
+		}
+		getEulerAngles(eulers = new Vec3()) {
+				this.getScale(scale);
+				const sx = scale.x;
+				const sy = scale.y;
+				const sz = scale.z;
+				if (sx === 0 || sy === 0 || sz === 0) {
+						return eulers.set(0, 0, 0);
+				}
+				const m = this.data;
+				const y = Math.asin(-m[2] / sx);
+				const halfPi = Math.PI * 0.5;
+				let x, z;
+				if (y < halfPi) {
+						if (y > -halfPi) {
+								x = Math.atan2(m[6] / sy, m[10] / sz);
+								z = Math.atan2(m[1] / sx, m[0] / sx);
+						} else {
+								z = 0;
+								x = -Math.atan2(m[4] / sy, m[5] / sy);
+						}
+				} else {
+						z = 0;
+						x = Math.atan2(m[4] / sy, m[5] / sy);
+				}
+				return eulers.set(x, y, z).mulScalar(math.RAD_TO_DEG);
+		}
+		toString() {
+				return `[${this.data.join(', ')}]`;
+		}
+		static{
+				this.IDENTITY = Object.freeze(new Mat4());
+		}
+		static{
+				this.ZERO = Object.freeze(new Mat4().set([
+						0,
+						0,
+						0,
+						0,
+						0,
+						0,
+						0,
+						0,
+						0,
+						0,
+						0,
+						0,
+						0,
+						0,
+						0,
+						0
+				]));
+		}
+}
+
+class Quat {
+		constructor(x = 0, y = 0, z = 0, w = 1){
+				if (x.length === 4) {
+						this.x = x[0];
+						this.y = x[1];
+						this.z = x[2];
+						this.w = x[3];
+				} else {
+						this.x = x;
+						this.y = y;
+						this.z = z;
+						this.w = w;
+				}
+		}
+		clone() {
+				const cstr = this.constructor;
+				return new cstr(this.x, this.y, this.z, this.w);
+		}
+		conjugate(src = this) {
+				this.x = src.x * -1;
+				this.y = src.y * -1;
+				this.z = src.z * -1;
+				this.w = src.w;
+				return this;
+		}
+		copy(rhs) {
+				this.x = rhs.x;
+				this.y = rhs.y;
+				this.z = rhs.z;
+				this.w = rhs.w;
+				return this;
+		}
+		dot(other) {
+				return this.x * other.x + this.y * other.y + this.z * other.z + this.w * other.w;
+		}
+		equals(rhs) {
+				return this.x === rhs.x && this.y === rhs.y && this.z === rhs.z && this.w === rhs.w;
+		}
+		equalsApprox(rhs, epsilon = 1e-6) {
+				return Math.abs(this.x - rhs.x) < epsilon && Math.abs(this.y - rhs.y) < epsilon && Math.abs(this.z - rhs.z) < epsilon && Math.abs(this.w - rhs.w) < epsilon;
+		}
+		getAxisAngle(axis) {
+				let rad = Math.acos(this.w) * 2;
+				const s = Math.sin(rad / 2);
+				if (s !== 0) {
+						axis.x = this.x / s;
+						axis.y = this.y / s;
+						axis.z = this.z / s;
+						if (axis.x < 0 || axis.y < 0 || axis.z < 0) {
+								axis.x *= -1;
+								axis.y *= -1;
+								axis.z *= -1;
+								rad *= -1;
+						}
+				} else {
+						axis.x = 1;
+						axis.y = 0;
+						axis.z = 0;
+				}
+				return rad * math.RAD_TO_DEG;
+		}
+		getEulerAngles(eulers = new Vec3()) {
+				let x, y, z;
+				const qx = this.x;
+				const qy = this.y;
+				const qz = this.z;
+				const qw = this.w;
+				const a2 = 2 * (qw * qy - qx * qz);
+				if (a2 <= -0.99999) {
+						x = 2 * Math.atan2(qx, qw);
+						y = -Math.PI / 2;
+						z = 0;
+				} else if (a2 >= 0.99999) {
+						x = 2 * Math.atan2(qx, qw);
+						y = Math.PI / 2;
+						z = 0;
+				} else {
+						x = Math.atan2(2 * (qw * qx + qy * qz), 1 - 2 * (qx * qx + qy * qy));
+						y = Math.asin(a2);
+						z = Math.atan2(2 * (qw * qz + qx * qy), 1 - 2 * (qy * qy + qz * qz));
+				}
+				return eulers.set(x, y, z).mulScalar(math.RAD_TO_DEG);
+		}
+		invert(src = this) {
+				return this.conjugate(src).normalize();
+		}
+		length() {
+				return Math.sqrt(this.x * this.x + this.y * this.y + this.z * this.z + this.w * this.w);
+		}
+		lengthSq() {
+				return this.x * this.x + this.y * this.y + this.z * this.z + this.w * this.w;
+		}
+		lerp(lhs, rhs, alpha) {
+				const omt = (1 - alpha) * (lhs.dot(rhs) < 0 ? -1 : 1);
+				this.x = lhs.x * omt + rhs.x * alpha;
+				this.y = lhs.y * omt + rhs.y * alpha;
+				this.z = lhs.z * omt + rhs.z * alpha;
+				this.w = lhs.w * omt + rhs.w * alpha;
+				return this.normalize();
+		}
+		mul(rhs) {
+				const q1x = this.x;
+				const q1y = this.y;
+				const q1z = this.z;
+				const q1w = this.w;
+				const q2x = rhs.x;
+				const q2y = rhs.y;
+				const q2z = rhs.z;
+				const q2w = rhs.w;
+				this.x = q1w * q2x + q1x * q2w + q1y * q2z - q1z * q2y;
+				this.y = q1w * q2y + q1y * q2w + q1z * q2x - q1x * q2z;
+				this.z = q1w * q2z + q1z * q2w + q1x * q2y - q1y * q2x;
+				this.w = q1w * q2w - q1x * q2x - q1y * q2y - q1z * q2z;
+				return this;
+		}
+		mulScalar(scalar, src = this) {
+				this.x = src.x * scalar;
+				this.y = src.y * scalar;
+				this.z = src.z * scalar;
+				this.w = src.w * scalar;
+				return this;
+		}
+		mul2(lhs, rhs) {
+				const q1x = lhs.x;
+				const q1y = lhs.y;
+				const q1z = lhs.z;
+				const q1w = lhs.w;
+				const q2x = rhs.x;
+				const q2y = rhs.y;
+				const q2z = rhs.z;
+				const q2w = rhs.w;
+				this.x = q1w * q2x + q1x * q2w + q1y * q2z - q1z * q2y;
+				this.y = q1w * q2y + q1y * q2w + q1z * q2x - q1x * q2z;
+				this.z = q1w * q2z + q1z * q2w + q1x * q2y - q1y * q2x;
+				this.w = q1w * q2w - q1x * q2x - q1y * q2y - q1z * q2z;
+				return this;
+		}
+		normalize(src = this) {
+				let len = src.length();
+				if (len === 0) {
+						this.x = this.y = this.z = 0;
+						this.w = 1;
+				} else {
+						len = 1 / len;
+						this.x = src.x * len;
+						this.y = src.y * len;
+						this.z = src.z * len;
+						this.w = src.w * len;
+				}
+				return this;
+		}
+		set(x, y, z, w) {
+				this.x = x;
+				this.y = y;
+				this.z = z;
+				this.w = w;
+				return this;
+		}
+		setFromAxisAngle(axis, angle) {
+				angle *= 0.5 * math.DEG_TO_RAD;
+				const sa = Math.sin(angle);
+				const ca = Math.cos(angle);
+				this.x = sa * axis.x;
+				this.y = sa * axis.y;
+				this.z = sa * axis.z;
+				this.w = ca;
+				return this;
+		}
+		setFromEulerAngles(ex, ey, ez) {
+				if (ex instanceof Vec3) {
+						const vec = ex;
+						ex = vec.x;
+						ey = vec.y;
+						ez = vec.z;
+				}
+				const halfToRad = 0.5 * math.DEG_TO_RAD;
+				ex *= halfToRad;
+				ey *= halfToRad;
+				ez *= halfToRad;
+				const sx = Math.sin(ex);
+				const cx = Math.cos(ex);
+				const sy = Math.sin(ey);
+				const cy = Math.cos(ey);
+				const sz = Math.sin(ez);
+				const cz = Math.cos(ez);
+				this.x = sx * cy * cz - cx * sy * sz;
+				this.y = cx * sy * cz + sx * cy * sz;
+				this.z = cx * cy * sz - sx * sy * cz;
+				this.w = cx * cy * cz + sx * sy * sz;
+				return this;
+		}
+		setFromMat4(m) {
+				const d = m.data;
+				let m00 = d[0];
+				let m01 = d[1];
+				let m02 = d[2];
+				let m10 = d[4];
+				let m11 = d[5];
+				let m12 = d[6];
+				let m20 = d[8];
+				let m21 = d[9];
+				let m22 = d[10];
+				let l;
+				l = m00 * m00 + m01 * m01 + m02 * m02;
+				if (l === 0) return this.set(0, 0, 0, 1);
+				l = 1 / Math.sqrt(l);
+				m00 *= l;
+				m01 *= l;
+				m02 *= l;
+				l = m10 * m10 + m11 * m11 + m12 * m12;
+				if (l === 0) return this.set(0, 0, 0, 1);
+				l = 1 / Math.sqrt(l);
+				m10 *= l;
+				m11 *= l;
+				m12 *= l;
+				l = m20 * m20 + m21 * m21 + m22 * m22;
+				if (l === 0) return this.set(0, 0, 0, 1);
+				l = 1 / Math.sqrt(l);
+				m20 *= l;
+				m21 *= l;
+				m22 *= l;
+				if (m22 < 0) {
+						if (m00 > m11) {
+								this.set(1 + m00 - m11 - m22, m01 + m10, m20 + m02, m12 - m21);
+						} else {
+								this.set(m01 + m10, 1 - m00 + m11 - m22, m12 + m21, m20 - m02);
+						}
+				} else {
+						if (m00 < -m11) {
+								this.set(m20 + m02, m12 + m21, 1 - m00 - m11 + m22, m01 - m10);
+						} else {
+								this.set(m12 - m21, m20 - m02, m01 - m10, 1 + m00 + m11 + m22);
+						}
+				}
+				return this.mulScalar(1.0 / this.length());
+		}
+		setFromDirections(from, to) {
+				const dotProduct = 1 + from.dot(to);
+				if (dotProduct < Number.EPSILON) {
+						if (Math.abs(from.x) > Math.abs(from.y)) {
+								this.x = -from.z;
+								this.y = 0;
+								this.z = from.x;
+								this.w = 0;
+						} else {
+								this.x = 0;
+								this.y = -from.z;
+								this.z = from.y;
+								this.w = 0;
+						}
+				} else {
+						this.x = from.y * to.z - from.z * to.y;
+						this.y = from.z * to.x - from.x * to.z;
+						this.z = from.x * to.y - from.y * to.x;
+						this.w = dotProduct;
+				}
+				return this.normalize();
+		}
+		slerp(lhs, rhs, alpha) {
+				const lx = lhs.x;
+				const ly = lhs.y;
+				const lz = lhs.z;
+				const lw = lhs.w;
+				let rx = rhs.x;
+				let ry = rhs.y;
+				let rz = rhs.z;
+				let rw = rhs.w;
+				let cosHalfTheta = lw * rw + lx * rx + ly * ry + lz * rz;
+				if (cosHalfTheta < 0) {
+						rw = -rw;
+						rx = -rx;
+						ry = -ry;
+						rz = -rz;
+						cosHalfTheta = -cosHalfTheta;
+				}
+				if (Math.abs(cosHalfTheta) >= 1) {
+						this.w = lw;
+						this.x = lx;
+						this.y = ly;
+						this.z = lz;
+						return this;
+				}
+				const halfTheta = Math.acos(cosHalfTheta);
+				const sinHalfTheta = Math.sqrt(1 - cosHalfTheta * cosHalfTheta);
+				if (Math.abs(sinHalfTheta) < 0.001) {
+						this.w = lw * 0.5 + rw * 0.5;
+						this.x = lx * 0.5 + rx * 0.5;
+						this.y = ly * 0.5 + ry * 0.5;
+						this.z = lz * 0.5 + rz * 0.5;
+						return this;
+				}
+				const ratioA = Math.sin((1 - alpha) * halfTheta) / sinHalfTheta;
+				const ratioB = Math.sin(alpha * halfTheta) / sinHalfTheta;
+				this.w = lw * ratioA + rw * ratioB;
+				this.x = lx * ratioA + rx * ratioB;
+				this.y = ly * ratioA + ry * ratioB;
+				this.z = lz * ratioA + rz * ratioB;
+				return this;
+		}
+		transformVector(vec, res = new Vec3()) {
+				const x = vec.x, y = vec.y, z = vec.z;
+				const qx = this.x, qy = this.y, qz = this.z, qw = this.w;
+				const ix = qw * x + qy * z - qz * y;
+				const iy = qw * y + qz * x - qx * z;
+				const iz = qw * z + qx * y - qy * x;
+				const iw = -qx * x - qy * y - qz * z;
+				res.x = ix * qw + iw * -qx + iy * -qz - iz * -qy;
+				res.y = iy * qw + iw * -qy + iz * -qx - ix * -qz;
+				res.z = iz * qw + iw * -qz + ix * -qy - iy * -qx;
+				return res;
+		}
+		fromArray(arr, offset = 0) {
+				this.x = arr[offset] ?? this.x;
+				this.y = arr[offset + 1] ?? this.y;
+				this.z = arr[offset + 2] ?? this.z;
+				this.w = arr[offset + 3] ?? this.w;
+				return this;
+		}
+		toString() {
+				return `[${this.x}, ${this.y}, ${this.z}, ${this.w}]`;
+		}
+		toArray(arr = [], offset = 0) {
+				arr[offset] = this.x;
+				arr[offset + 1] = this.y;
+				arr[offset + 2] = this.z;
+				arr[offset + 3] = this.w;
+				return arr;
+		}
+		static{
+				this.IDENTITY = Object.freeze(new Quat(0, 0, 0, 1));
+		}
+		static{
+				this.ZERO = Object.freeze(new Quat(0, 0, 0, 0));
+		}
+}
+
+var version = "0.2.0";
+
+class Column {
+    name;
+    data;
+    constructor(name, data) {
+        this.name = name;
+        this.data = data;
+    }
+    get dataType() {
+        switch (this.data.constructor) {
+            case Int8Array: return 'int8';
+            case Uint8Array: return 'uint8';
+            case Int16Array: return 'int16';
+            case Uint16Array: return 'uint16';
+            case Int32Array: return 'int32';
+            case Uint32Array: return 'uint32';
+            case Float32Array: return 'float32';
+            case Float64Array: return 'float64';
+        }
+        return null;
+    }
+    clone() {
+        return new Column(this.name, this.data.slice());
+    }
+    filter(length, filter) {
+        const constructor = this.data.constructor;
+        const data = new constructor(length);
+        let j = 0;
+        for (let i = 0; i < this.data.length; i++) {
+            if (filter[i]) {
+                data[j++] = this.data[i];
+            }
+        }
+        return new Column(this.name, data);
+    }
+}
+class DataTable {
+    columns;
+    constructor(columns) {
+        if (columns.length === 0) {
+            throw new Error('DataTable must have at least one column');
+        }
+        // check all columns have the same lengths
+        for (let i = 1; i < columns.length; i++) {
+            if (columns[i].data.length !== columns[0].data.length) {
+                throw new Error(`Column '${columns[i].name}' has inconsistent number of rows: expected ${columns[0].data.length}, got ${columns[i].data.length}`);
+            }
+        }
+        this.columns = columns;
+    }
+    // rows
+    get numRows() {
+        return this.columns[0].data.length;
+    }
+    getRow(index, row = {}, columns = this.columns) {
+        for (const column of columns) {
+            row[column.name] = column.data[index];
+        }
+        return row;
+    }
+    setRow(index, row, columns = this.columns) {
+        for (const column of columns) {
+            if (row.hasOwnProperty(column.name)) {
+                column.data[index] = row[column.name];
+            }
+        }
+    }
+    // columns
+    get numColumns() {
+        return this.columns.length;
+    }
+    get columnNames() {
+        return this.columns.map(column => column.name);
+    }
+    get columnData() {
+        return this.columns.map(column => column.data);
+    }
+    get columnTypes() {
+        return this.columns.map(column => column.dataType);
+    }
+    getColumn(index) {
+        return this.columns[index];
+    }
+    getColumnIndex(name) {
+        return this.columns.findIndex(column => column.name === name);
+    }
+    getColumnByName(name) {
+        return this.columns.find(column => column.name === name);
+    }
+    hasColumn(name) {
+        return this.columns.some(column => column.name === name);
+    }
+    addColumn(column) {
+        if (column.data.length !== this.numRows) {
+            throw new Error(`Column '${column.name}' has inconsistent number of rows: expected ${this.numRows}, got ${column.data.length}`);
+        }
+        this.columns.push(column);
+    }
+    removeColumn(name) {
+        const index = this.columns.findIndex(column => column.name === name);
+        if (index === -1) {
+            return false;
+        }
+        this.columns.splice(index, 1);
+        return true;
+    }
+    // general
+    clone() {
+        return new DataTable(this.columns.map(c => c.clone()));
+    }
+    filter(predicate) {
+        const flags = new Uint8Array(this.numRows);
+        const row = {};
+        let numRows = 0;
+        for (let i = 0; i < this.numRows; i++) {
+            this.getRow(i, row);
+            flags[i] = predicate(i, row) ? 1 : 0;
+            numRows += flags[i];
+        }
+        if (numRows === 0) {
+            return null;
+        }
+        if (numRows === this.numRows) {
+            return this;
+        }
+        return new DataTable(this.columns.map(c => c.filter(numRows, flags)));
+    }
+}
+
+/* eslint-disable indent */
+const kSqrt03_02 = Math.sqrt(3.0 / 2.0);
+const kSqrt01_03 = Math.sqrt(1.0 / 3.0);
+const kSqrt02_03 = Math.sqrt(2.0 / 3.0);
+const kSqrt04_03 = Math.sqrt(4.0 / 3.0);
+const kSqrt01_04 = Math.sqrt(1.0 / 4.0);
+const kSqrt03_04 = Math.sqrt(3.0 / 4.0);
+const kSqrt01_05 = Math.sqrt(1.0 / 5.0);
+const kSqrt03_05 = Math.sqrt(3.0 / 5.0);
+const kSqrt06_05 = Math.sqrt(6.0 / 5.0);
+const kSqrt08_05 = Math.sqrt(8.0 / 5.0);
+const kSqrt09_05 = Math.sqrt(9.0 / 5.0);
+const kSqrt01_06 = Math.sqrt(1.0 / 6.0);
+const kSqrt05_06 = Math.sqrt(5.0 / 6.0);
+const kSqrt03_08 = Math.sqrt(3.0 / 8.0);
+const kSqrt05_08 = Math.sqrt(5.0 / 8.0);
+const kSqrt09_08 = Math.sqrt(9.0 / 8.0);
+const kSqrt05_09 = Math.sqrt(5.0 / 9.0);
+const kSqrt08_09 = Math.sqrt(8.0 / 9.0);
+const kSqrt01_10 = Math.sqrt(1.0 / 10.0);
+const kSqrt03_10 = Math.sqrt(3.0 / 10.0);
+const kSqrt01_12 = Math.sqrt(1.0 / 12.0);
+const kSqrt04_15 = Math.sqrt(4.0 / 15.0);
+const kSqrt01_16 = Math.sqrt(1.0 / 16.0);
+const kSqrt15_16 = Math.sqrt(15.0 / 16.0);
+const kSqrt01_18 = Math.sqrt(1.0 / 18.0);
+const kSqrt01_60 = Math.sqrt(1.0 / 60.0);
+const dp = (n, start, a, b) => {
+    let sum = 0;
+    for (let i = 0; i < n; i++) {
+        sum += a[start + i] * b[i];
+    }
+    return sum;
+};
+const coeffsIn = new Float32Array(15);
+// Rotate spherical harmonics up to band 3 based on https://github.com/andrewwillmott/sh-lib
+//
+// This implementation calculates the rotation factors during construction which can then
+// be used to rotate multiple spherical harmonics cheaply.
+class RotateSH {
+    apply;
+    constructor(mat) {
+        const rot = mat.data;
+        // band 1
+        const sh1 = [
+            [rot[4], -rot[7], rot[1]],
+            [-rot[5], rot[8], -rot[2]],
+            [rot[3], -rot[6], rot[0]]
+        ];
+        // band 2
+        const sh2 = [[
+                kSqrt01_04 * ((sh1[2][2] * sh1[0][0] + sh1[2][0] * sh1[0][2]) + (sh1[0][2] * sh1[2][0] + sh1[0][0] * sh1[2][2])),
+                (sh1[2][1] * sh1[0][0] + sh1[0][1] * sh1[2][0]),
+                kSqrt03_04 * (sh1[2][1] * sh1[0][1] + sh1[0][1] * sh1[2][1]),
+                (sh1[2][1] * sh1[0][2] + sh1[0][1] * sh1[2][2]),
+                kSqrt01_04 * ((sh1[2][2] * sh1[0][2] - sh1[2][0] * sh1[0][0]) + (sh1[0][2] * sh1[2][2] - sh1[0][0] * sh1[2][0]))
+            ], [
+                kSqrt01_04 * ((sh1[1][2] * sh1[0][0] + sh1[1][0] * sh1[0][2]) + (sh1[0][2] * sh1[1][0] + sh1[0][0] * sh1[1][2])),
+                sh1[1][1] * sh1[0][0] + sh1[0][1] * sh1[1][0],
+                kSqrt03_04 * (sh1[1][1] * sh1[0][1] + sh1[0][1] * sh1[1][1]),
+                sh1[1][1] * sh1[0][2] + sh1[0][1] * sh1[1][2],
+                kSqrt01_04 * ((sh1[1][2] * sh1[0][2] - sh1[1][0] * sh1[0][0]) + (sh1[0][2] * sh1[1][2] - sh1[0][0] * sh1[1][0]))
+            ], [
+                kSqrt01_03 * (sh1[1][2] * sh1[1][0] + sh1[1][0] * sh1[1][2]) - kSqrt01_12 * ((sh1[2][2] * sh1[2][0] + sh1[2][0] * sh1[2][2]) + (sh1[0][2] * sh1[0][0] + sh1[0][0] * sh1[0][2])),
+                kSqrt04_03 * sh1[1][1] * sh1[1][0] - kSqrt01_03 * (sh1[2][1] * sh1[2][0] + sh1[0][1] * sh1[0][0]),
+                sh1[1][1] * sh1[1][1] - kSqrt01_04 * (sh1[2][1] * sh1[2][1] + sh1[0][1] * sh1[0][1]),
+                kSqrt04_03 * sh1[1][1] * sh1[1][2] - kSqrt01_03 * (sh1[2][1] * sh1[2][2] + sh1[0][1] * sh1[0][2]),
+                kSqrt01_03 * (sh1[1][2] * sh1[1][2] - sh1[1][0] * sh1[1][0]) - kSqrt01_12 * ((sh1[2][2] * sh1[2][2] - sh1[2][0] * sh1[2][0]) + (sh1[0][2] * sh1[0][2] - sh1[0][0] * sh1[0][0]))
+            ], [
+                kSqrt01_04 * ((sh1[1][2] * sh1[2][0] + sh1[1][0] * sh1[2][2]) + (sh1[2][2] * sh1[1][0] + sh1[2][0] * sh1[1][2])),
+                sh1[1][1] * sh1[2][0] + sh1[2][1] * sh1[1][0],
+                kSqrt03_04 * (sh1[1][1] * sh1[2][1] + sh1[2][1] * sh1[1][1]),
+                sh1[1][1] * sh1[2][2] + sh1[2][1] * sh1[1][2],
+                kSqrt01_04 * ((sh1[1][2] * sh1[2][2] - sh1[1][0] * sh1[2][0]) + (sh1[2][2] * sh1[1][2] - sh1[2][0] * sh1[1][0]))
+            ], [
+                kSqrt01_04 * ((sh1[2][2] * sh1[2][0] + sh1[2][0] * sh1[2][2]) - (sh1[0][2] * sh1[0][0] + sh1[0][0] * sh1[0][2])),
+                (sh1[2][1] * sh1[2][0] - sh1[0][1] * sh1[0][0]),
+                kSqrt03_04 * (sh1[2][1] * sh1[2][1] - sh1[0][1] * sh1[0][1]),
+                (sh1[2][1] * sh1[2][2] - sh1[0][1] * sh1[0][2]),
+                kSqrt01_04 * ((sh1[2][2] * sh1[2][2] - sh1[2][0] * sh1[2][0]) - (sh1[0][2] * sh1[0][2] - sh1[0][0] * sh1[0][0]))
+            ]];
+        // band 3
+        const sh3 = [[
+                kSqrt01_04 * ((sh1[2][2] * sh2[0][0] + sh1[2][0] * sh2[0][4]) + (sh1[0][2] * sh2[4][0] + sh1[0][0] * sh2[4][4])),
+                kSqrt03_02 * (sh1[2][1] * sh2[0][0] + sh1[0][1] * sh2[4][0]),
+                kSqrt15_16 * (sh1[2][1] * sh2[0][1] + sh1[0][1] * sh2[4][1]),
+                kSqrt05_06 * (sh1[2][1] * sh2[0][2] + sh1[0][1] * sh2[4][2]),
+                kSqrt15_16 * (sh1[2][1] * sh2[0][3] + sh1[0][1] * sh2[4][3]),
+                kSqrt03_02 * (sh1[2][1] * sh2[0][4] + sh1[0][1] * sh2[4][4]),
+                kSqrt01_04 * ((sh1[2][2] * sh2[0][4] - sh1[2][0] * sh2[0][0]) + (sh1[0][2] * sh2[4][4] - sh1[0][0] * sh2[4][0]))
+            ], [
+                kSqrt01_06 * (sh1[1][2] * sh2[0][0] + sh1[1][0] * sh2[0][4]) + kSqrt01_06 * ((sh1[2][2] * sh2[1][0] + sh1[2][0] * sh2[1][4]) + (sh1[0][2] * sh2[3][0] + sh1[0][0] * sh2[3][4])),
+                sh1[1][1] * sh2[0][0] + (sh1[2][1] * sh2[1][0] + sh1[0][1] * sh2[3][0]),
+                kSqrt05_08 * sh1[1][1] * sh2[0][1] + kSqrt05_08 * (sh1[2][1] * sh2[1][1] + sh1[0][1] * sh2[3][1]),
+                kSqrt05_09 * sh1[1][1] * sh2[0][2] + kSqrt05_09 * (sh1[2][1] * sh2[1][2] + sh1[0][1] * sh2[3][2]),
+                kSqrt05_08 * sh1[1][1] * sh2[0][3] + kSqrt05_08 * (sh1[2][1] * sh2[1][3] + sh1[0][1] * sh2[3][3]),
+                sh1[1][1] * sh2[0][4] + (sh1[2][1] * sh2[1][4] + sh1[0][1] * sh2[3][4]),
+                kSqrt01_06 * (sh1[1][2] * sh2[0][4] - sh1[1][0] * sh2[0][0]) + kSqrt01_06 * ((sh1[2][2] * sh2[1][4] - sh1[2][0] * sh2[1][0]) + (sh1[0][2] * sh2[3][4] - sh1[0][0] * sh2[3][0]))
+            ], [
+                kSqrt04_15 * (sh1[1][2] * sh2[1][0] + sh1[1][0] * sh2[1][4]) + kSqrt01_05 * (sh1[0][2] * sh2[2][0] + sh1[0][0] * sh2[2][4]) - kSqrt01_60 * ((sh1[2][2] * sh2[0][0] + sh1[2][0] * sh2[0][4]) - (sh1[0][2] * sh2[4][0] + sh1[0][0] * sh2[4][4])),
+                kSqrt08_05 * sh1[1][1] * sh2[1][0] + kSqrt06_05 * sh1[0][1] * sh2[2][0] - kSqrt01_10 * (sh1[2][1] * sh2[0][0] - sh1[0][1] * sh2[4][0]),
+                sh1[1][1] * sh2[1][1] + kSqrt03_04 * sh1[0][1] * sh2[2][1] - kSqrt01_16 * (sh1[2][1] * sh2[0][1] - sh1[0][1] * sh2[4][1]),
+                kSqrt08_09 * sh1[1][1] * sh2[1][2] + kSqrt02_03 * sh1[0][1] * sh2[2][2] - kSqrt01_18 * (sh1[2][1] * sh2[0][2] - sh1[0][1] * sh2[4][2]),
+                sh1[1][1] * sh2[1][3] + kSqrt03_04 * sh1[0][1] * sh2[2][3] - kSqrt01_16 * (sh1[2][1] * sh2[0][3] - sh1[0][1] * sh2[4][3]),
+                kSqrt08_05 * sh1[1][1] * sh2[1][4] + kSqrt06_05 * sh1[0][1] * sh2[2][4] - kSqrt01_10 * (sh1[2][1] * sh2[0][4] - sh1[0][1] * sh2[4][4]),
+                kSqrt04_15 * (sh1[1][2] * sh2[1][4] - sh1[1][0] * sh2[1][0]) + kSqrt01_05 * (sh1[0][2] * sh2[2][4] - sh1[0][0] * sh2[2][0]) - kSqrt01_60 * ((sh1[2][2] * sh2[0][4] - sh1[2][0] * sh2[0][0]) - (sh1[0][2] * sh2[4][4] - sh1[0][0] * sh2[4][0]))
+            ], [
+                kSqrt03_10 * (sh1[1][2] * sh2[2][0] + sh1[1][0] * sh2[2][4]) - kSqrt01_10 * ((sh1[2][2] * sh2[3][0] + sh1[2][0] * sh2[3][4]) + (sh1[0][2] * sh2[1][0] + sh1[0][0] * sh2[1][4])),
+                kSqrt09_05 * sh1[1][1] * sh2[2][0] - kSqrt03_05 * (sh1[2][1] * sh2[3][0] + sh1[0][1] * sh2[1][0]),
+                kSqrt09_08 * sh1[1][1] * sh2[2][1] - kSqrt03_08 * (sh1[2][1] * sh2[3][1] + sh1[0][1] * sh2[1][1]),
+                sh1[1][1] * sh2[2][2] - kSqrt01_03 * (sh1[2][1] * sh2[3][2] + sh1[0][1] * sh2[1][2]),
+                kSqrt09_08 * sh1[1][1] * sh2[2][3] - kSqrt03_08 * (sh1[2][1] * sh2[3][3] + sh1[0][1] * sh2[1][3]),
+                kSqrt09_05 * sh1[1][1] * sh2[2][4] - kSqrt03_05 * (sh1[2][1] * sh2[3][4] + sh1[0][1] * sh2[1][4]),
+                kSqrt03_10 * (sh1[1][2] * sh2[2][4] - sh1[1][0] * sh2[2][0]) - kSqrt01_10 * ((sh1[2][2] * sh2[3][4] - sh1[2][0] * sh2[3][0]) + (sh1[0][2] * sh2[1][4] - sh1[0][0] * sh2[1][0]))
+            ], [
+                kSqrt04_15 * (sh1[1][2] * sh2[3][0] + sh1[1][0] * sh2[3][4]) + kSqrt01_05 * (sh1[2][2] * sh2[2][0] + sh1[2][0] * sh2[2][4]) - kSqrt01_60 * ((sh1[2][2] * sh2[4][0] + sh1[2][0] * sh2[4][4]) + (sh1[0][2] * sh2[0][0] + sh1[0][0] * sh2[0][4])),
+                kSqrt08_05 * sh1[1][1] * sh2[3][0] + kSqrt06_05 * sh1[2][1] * sh2[2][0] - kSqrt01_10 * (sh1[2][1] * sh2[4][0] + sh1[0][1] * sh2[0][0]),
+                sh1[1][1] * sh2[3][1] + kSqrt03_04 * sh1[2][1] * sh2[2][1] - kSqrt01_16 * (sh1[2][1] * sh2[4][1] + sh1[0][1] * sh2[0][1]),
+                kSqrt08_09 * sh1[1][1] * sh2[3][2] + kSqrt02_03 * sh1[2][1] * sh2[2][2] - kSqrt01_18 * (sh1[2][1] * sh2[4][2] + sh1[0][1] * sh2[0][2]),
+                sh1[1][1] * sh2[3][3] + kSqrt03_04 * sh1[2][1] * sh2[2][3] - kSqrt01_16 * (sh1[2][1] * sh2[4][3] + sh1[0][1] * sh2[0][3]),
+                kSqrt08_05 * sh1[1][1] * sh2[3][4] + kSqrt06_05 * sh1[2][1] * sh2[2][4] - kSqrt01_10 * (sh1[2][1] * sh2[4][4] + sh1[0][1] * sh2[0][4]),
+                kSqrt04_15 * (sh1[1][2] * sh2[3][4] - sh1[1][0] * sh2[3][0]) + kSqrt01_05 * (sh1[2][2] * sh2[2][4] - sh1[2][0] * sh2[2][0]) - kSqrt01_60 * ((sh1[2][2] * sh2[4][4] - sh1[2][0] * sh2[4][0]) + (sh1[0][2] * sh2[0][4] - sh1[0][0] * sh2[0][0]))
+            ], [
+                kSqrt01_06 * (sh1[1][2] * sh2[4][0] + sh1[1][0] * sh2[4][4]) + kSqrt01_06 * ((sh1[2][2] * sh2[3][0] + sh1[2][0] * sh2[3][4]) - (sh1[0][2] * sh2[1][0] + sh1[0][0] * sh2[1][4])),
+                sh1[1][1] * sh2[4][0] + (sh1[2][1] * sh2[3][0] - sh1[0][1] * sh2[1][0]),
+                kSqrt05_08 * sh1[1][1] * sh2[4][1] + kSqrt05_08 * (sh1[2][1] * sh2[3][1] - sh1[0][1] * sh2[1][1]),
+                kSqrt05_09 * sh1[1][1] * sh2[4][2] + kSqrt05_09 * (sh1[2][1] * sh2[3][2] - sh1[0][1] * sh2[1][2]),
+                kSqrt05_08 * sh1[1][1] * sh2[4][3] + kSqrt05_08 * (sh1[2][1] * sh2[3][3] - sh1[0][1] * sh2[1][3]),
+                sh1[1][1] * sh2[4][4] + (sh1[2][1] * sh2[3][4] - sh1[0][1] * sh2[1][4]),
+                kSqrt01_06 * (sh1[1][2] * sh2[4][4] - sh1[1][0] * sh2[4][0]) + kSqrt01_06 * ((sh1[2][2] * sh2[3][4] - sh1[2][0] * sh2[3][0]) - (sh1[0][2] * sh2[1][4] - sh1[0][0] * sh2[1][0]))
+            ], [
+                kSqrt01_04 * ((sh1[2][2] * sh2[4][0] + sh1[2][0] * sh2[4][4]) - (sh1[0][2] * sh2[0][0] + sh1[0][0] * sh2[0][4])),
+                kSqrt03_02 * (sh1[2][1] * sh2[4][0] - sh1[0][1] * sh2[0][0]),
+                kSqrt15_16 * (sh1[2][1] * sh2[4][1] - sh1[0][1] * sh2[0][1]),
+                kSqrt05_06 * (sh1[2][1] * sh2[4][2] - sh1[0][1] * sh2[0][2]),
+                kSqrt15_16 * (sh1[2][1] * sh2[4][3] - sh1[0][1] * sh2[0][3]),
+                kSqrt03_02 * (sh1[2][1] * sh2[4][4] - sh1[0][1] * sh2[0][4]),
+                kSqrt01_04 * ((sh1[2][2] * sh2[4][4] - sh1[2][0] * sh2[4][0]) - (sh1[0][2] * sh2[0][4] - sh1[0][0] * sh2[0][0]))
+            ]];
+        // rotate spherical harmonic coefficients, up to band 3
+        this.apply = (result, src) => {
+            if (!src || src === result) {
+                coeffsIn.set(result);
+                src = coeffsIn;
+            }
+            // band 1
+            if (result.length < 3) {
+                return;
+            }
+            result[0] = dp(3, 0, src, sh1[0]);
+            result[1] = dp(3, 0, src, sh1[1]);
+            result[2] = dp(3, 0, src, sh1[2]);
+            // band 2
+            if (result.length < 8) {
+                return;
+            }
+            result[3] = dp(5, 3, src, sh2[0]);
+            result[4] = dp(5, 3, src, sh2[1]);
+            result[5] = dp(5, 3, src, sh2[2]);
+            result[6] = dp(5, 3, src, sh2[3]);
+            result[7] = dp(5, 3, src, sh2[4]);
+            // band 3
+            if (result.length < 15) {
+                return;
+            }
+            result[8] = dp(7, 8, src, sh3[0]);
+            result[9] = dp(7, 8, src, sh3[1]);
+            result[10] = dp(7, 8, src, sh3[2]);
+            result[11] = dp(7, 8, src, sh3[3]);
+            result[12] = dp(7, 8, src, sh3[4]);
+            result[13] = dp(7, 8, src, sh3[5]);
+            result[14] = dp(7, 8, src, sh3[6]);
+        };
+    }
+}
+
+const shNames$2 = new Array(45).fill('').map((_, i) => `f_rest_${i}`);
+const v = new Vec3();
+const q$1 = new Quat();
+// apply translation, rotation and scale to a data table
+const transform = (dataTable, t, r, s) => {
+    const mat = new Mat4().setTRS(t, r, new Vec3(s, s, s));
+    const mat3 = new Mat3().setFromQuat(r);
+    const rotateSH = new RotateSH(mat3);
+    const hasTranslation = ['x', 'y', 'z'].every(c => dataTable.hasColumn(c));
+    const hasRotation = ['rot_0', 'rot_1', 'rot_2', 'rot_3'].every(c => dataTable.hasColumn(c));
+    const hasScale = ['scale_0', 'scale_1', 'scale_2'].every(c => dataTable.hasColumn(c));
+    const shBands = { '9': 1, '24': 2, '-1': 3 }[shNames$2.findIndex(v => !dataTable.hasColumn(v))] ?? 0;
+    const shCoeffs = new Float32Array([0, 3, 8, 15][shBands]);
+    const row = {};
+    for (let i = 0; i < dataTable.numRows; ++i) {
+        dataTable.getRow(i, row);
+        if (hasTranslation) {
+            v.set(row.x, row.y, row.z);
+            mat.transformPoint(v, v);
+            row.x = v.x;
+            row.y = v.y;
+            row.z = v.z;
+        }
+        if (hasRotation) {
+            q$1.set(row.rot_1, row.rot_2, row.rot_3, row.rot_0).mul2(r, q$1);
+            row.rot_0 = q$1.w;
+            row.rot_1 = q$1.x;
+            row.rot_2 = q$1.y;
+            row.rot_3 = q$1.z;
+        }
+        if (hasScale) {
+            row.scale_0 = Math.log(Math.exp(row.scale_0) * s);
+            row.scale_1 = Math.log(Math.exp(row.scale_1) * s);
+            row.scale_2 = Math.log(Math.exp(row.scale_2) * s);
+        }
+        if (shBands > 0) {
+            for (let j = 0; j < 3; ++j) {
+                for (let k = 0; k < shCoeffs.length; ++k) {
+                    shCoeffs[k] = row[shNames$2[k + j * shCoeffs.length]];
+                }
+                rotateSH.apply(shCoeffs);
+                for (let k = 0; k < shCoeffs.length; ++k) {
+                    row[shNames$2[k + j * shCoeffs.length]] = shCoeffs[k];
+                }
+            }
+        }
+        dataTable.setRow(i, row);
+    }
+};
+
+const shNames$1 = new Array(45).fill('').map((_, i) => `f_rest_${i}`);
+// process a data table with standard options
+const process = (dataTable, processActions) => {
+    let result = dataTable;
+    for (let i = 0; i < processActions.length; i++) {
+        const processAction = processActions[i];
+        switch (processAction.kind) {
+            case 'translate':
+                transform(result, processAction.value, Quat.IDENTITY, 1);
+                break;
+            case 'rotate':
+                transform(result, Vec3.ZERO, new Quat().setFromEulerAngles(processAction.value.x, processAction.value.y, processAction.value.z), 1);
+                break;
+            case 'scale':
+                transform(result, Vec3.ZERO, Quat.IDENTITY, processAction.value);
+                break;
+            case 'filterNaN': {
+                const predicate = (rowIndex, row) => {
+                    for (const key in row) {
+                        if (!isFinite(row[key])) {
+                            return false;
+                        }
+                    }
+                    return true;
+                };
+                result = result.filter(predicate);
+                break;
+            }
+            case 'filterByValue': {
+                const { columnName, comparator, value } = processAction;
+                const Predicates = {
+                    'lt': (rowIndex, row) => row[columnName] < value,
+                    'lte': (rowIndex, row) => row[columnName] <= value,
+                    'gt': (rowIndex, row) => row[columnName] > value,
+                    'gte': (rowIndex, row) => row[columnName] >= value,
+                    'eq': (rowIndex, row) => row[columnName] === value,
+                    'neq': (rowIndex, row) => row[columnName] !== value
+                };
+                const predicate = Predicates[comparator] ?? ((rowIndex, row) => true);
+                result = result.filter(predicate);
+                break;
+            }
+            case 'filterBands': {
+                const inputBands = { '9': 1, '24': 2, '-1': 3 }[shNames$1.findIndex(v => !dataTable.hasColumn(v))] ?? 0;
+                const outputBands = processAction.value;
+                if (outputBands < inputBands) {
+                    const inputCoeffs = [0, 3, 8, 15][inputBands];
+                    const outputCoeffs = [0, 3, 8, 15][outputBands];
+                    const map = {};
+                    for (let i = 0; i < inputCoeffs; ++i) {
+                        for (let j = 0; j < 3; ++j) {
+                            const inputName = `f_rest_${i + j * inputCoeffs}`;
+                            map[inputName] = i < outputCoeffs ? `f_rest_${i + j * outputCoeffs}` : null;
+                        }
+                    }
+                    result = new DataTable(result.columns.map((column) => {
+                        if (map.hasOwnProperty(column.name)) {
+                            const name = map[column.name];
+                            return name ? new Column(name, column.data) : null;
+                        }
+                        return column;
+                    }).filter(c => c !== null));
+                }
+                break;
+            }
+        }
+    }
+    return result;
+};
 
 const getDataType = (type) => {
     switch (type) {
@@ -16,36 +2320,28 @@ const getDataType = (type) => {
         default: return null;
     }
 };
-const calcDataSize = (plyFile) => {
-    let result = 0;
-    for (const element of plyFile.elements) {
-        for (const property of element.properties) {
-            result += getDataType(property.type).BYTES_PER_ELEMENT * element.count;
-        }
-    }
-    return result;
-};
-const shNames = new Array(45).fill('').map((_, i) => `f_rest_${i}`);
-
 // parse the ply header text and return an array of Element structures and a
 // string containing the ply format
-const parsePlyHeader = (data) => {
+const parseHeader = (data) => {
     // decode header and split into lines
     const strings = new TextDecoder('ascii')
         .decode(data)
         .split('\n')
         .filter(line => line);
     const elements = [];
+    const comments = [];
     let element;
     for (let i = 1; i < strings.length; ++i) {
         const words = strings[i].split(' ');
         switch (words[0]) {
             case 'ply':
             case 'format':
-            case 'comment':
             case 'end_header':
                 // skip
                 break;
+            case 'comment':
+                comments.push(strings[i].substring(8)); // skip 'comment '
+                break;
             case 'element': {
                 if (words.length !== 3) {
                     throw new Error('invalid ply header');
@@ -73,7 +2369,7 @@ const parsePlyHeader = (data) => {
             }
         }
     }
-    return { strings, elements };
+    return { comments, elements };
 };
 const cmp = (a, b, aOffset = 0) => {
     for (let i = 0; i < b.length; ++i) {
@@ -87,7 +2383,7 @@ const magicBytes = new Uint8Array([112, 108, 121, 10]); // ply\n
 const endHeaderBytes = new Uint8Array([10, 101, 110, 100, 95, 104, 101, 97, 100, 101, 114, 10]); // \nend_header\n
 const readPly = async (fileHandle) => {
     // we don't support ply text header larger than 128k
-    const headerBuf = Buffer.alloc(128 * 1024);
+    const headerBuf = Buffer$1.alloc(128 * 1024);
     // smallest possible header size
     let headerSize = magicBytes.length + endHeaderBytes.length;
     if ((await fileHandle.read(headerBuf, 0, headerSize)).bytesRead !== headerSize) {
@@ -108,693 +2404,52 @@ const readPly = async (fileHandle) => {
         }
     }
     // parse the header
-    const header = parsePlyHeader(headerBuf.subarray(0, headerSize));
-    const dataSize = calcDataSize(header);
-    const data = Buffer.alloc(dataSize);
-    if ((await fileHandle.read(data, 0, dataSize)).bytesRead !== dataSize) {
-        throw new Error('failed reading ply data');
-    }
-    return { header, data };
-};
-
-// wraps ply file data and adds helpers accessors
-class Splat {
-    plyFile;
-    vertex;
-    properties = {};
-    constructor(plyFile) {
-        this.plyFile = plyFile;
-        // find vertex element and populate property offsets
-        let offset = 0;
-        for (let i = 0; i < plyFile.header.elements.length; ++i) {
-            const element = plyFile.header.elements[i];
-            if (element.name === 'vertex') {
-                this.vertex = element;
-            }
-            for (let j = 0; j < element.properties.length; ++j) {
-                const property = element.properties[j];
-                if (element === this.vertex) {
-                    this.properties[property.name] = {
-                        type: property.type,
-                        offset
-                    };
+    const header = parseHeader(headerBuf.subarray(0, headerSize));
+    // create a data table for each ply element
+    const elements = [];
+    for (let i = 0; i < header.elements.length; ++i) {
+        const element = header.elements[i];
+        const columns = element.properties.map((property) => {
+            return new Column(property.name, new (getDataType(property.type))(element.count));
+        });
+        const buffers = columns.map(column => new Uint8Array(column.data.buffer));
+        const sizes = columns.map(column => column.data.BYTES_PER_ELEMENT);
+        const rowSize = sizes.reduce((total, size) => total + size, 0);
+        // read data in chunks of 1024 rows at a time
+        const chunkSize = 1024;
+        const numChunks = Math.ceil(element.count / chunkSize);
+        const chunkData = Buffer$1.alloc(chunkSize * rowSize);
+        for (let c = 0; c < numChunks; ++c) {
+            const numRows = Math.min(chunkSize, element.count - c * chunkSize);
+            await fileHandle.read(chunkData, 0, rowSize * numRows);
+            let offset = 0;
+            // read data row at a time
+            for (let r = 0; r < numRows; ++r) {
+                const rowOffset = c * chunkSize + r;
+                // copy into column data
+                for (let p = 0; p < columns.length; ++p) {
+                    const s = sizes[p];
+                    chunkData.copy(buffers[p], rowOffset * s, offset, offset + s);
+                    offset += s;
                 }
-                offset += getDataType(property.type).BYTES_PER_ELEMENT;
             }
         }
+        elements.push({
+            name: element.name,
+            dataTable: new DataTable(columns)
+        });
     }
-    // return the total number of splats
-    get numSplats() {
-        return this.vertex?.count;
-    }
-    // return the number of spherical harmonic bands present in the data
-    get numSHBands() {
-        return { '9': 1, '24': 2, '-1': 3 }[shNames.findIndex(v => !this.properties.hasOwnProperty(v))] ?? 0;
-    }
-    // simple iterator that assumes input data is float32
-    createIterator(fields, result) {
-        const offsets = fields.map(f => this.properties[f].offset / 4);
-        const float32 = new Float32Array(this.plyFile.data.buffer);
-        return (index) => {
-            const base = index * this.vertex.properties.length;
-            for (let i = 0; i < fields.length; ++i) {
-                result[i] = float32[base + offsets[i]];
-            }
-        };
-    }
-}
-
-const math = {
-	DEG_TO_RAD: Math.PI / 180,
-	RAD_TO_DEG: 180 / Math.PI,
-	clamp(value, min, max) {
-		if (value >= max) return max;
-		if (value <= min) return min;
-		return value;
-	},
-	intToBytes24(i) {
-		const r = i >> 16 & 0xff;
-		const g = i >> 8 & 0xff;
-		const b = i & 0xff;
-		return [r, g, b];
-	},
-	intToBytes32(i) {
-		const r = i >> 24 & 0xff;
-		const g = i >> 16 & 0xff;
-		const b = i >> 8 & 0xff;
-		const a = i & 0xff;
-		return [r, g, b, a];
-	},
-	bytesToInt24(r, g, b) {
-		if (r.length) {
-			b = r[2];
-			g = r[1];
-			r = r[0];
-		}
-		return r << 16 | g << 8 | b;
-	},
-	bytesToInt32(r, g, b, a) {
-		if (r.length) {
-			a = r[3];
-			b = r[2];
-			g = r[1];
-			r = r[0];
-		}
-		return (r << 24 | g << 16 | b << 8 | a) >>> 0;
-	},
-	lerp(a, b, alpha) {
-		return a + (b - a) * math.clamp(alpha, 0, 1);
-	},
-	lerpAngle(a, b, alpha) {
-		if (b - a > 180) {
-			b -= 360;
-		}
-		if (b - a < -180) {
-			b += 360;
-		}
-		return math.lerp(a, b, math.clamp(alpha, 0, 1));
-	},
-	powerOfTwo(x) {
-		return x !== 0 && !(x & x - 1);
-	},
-	nextPowerOfTwo(val) {
-		val--;
-		val |= val >> 1;
-		val |= val >> 2;
-		val |= val >> 4;
-		val |= val >> 8;
-		val |= val >> 16;
-		val++;
-		return val;
-	},
-	nearestPowerOfTwo(val) {
-		return Math.pow(2, Math.round(Math.log(val) / Math.log(2)));
-	},
-	random(min, max) {
-		const diff = max - min;
-		return Math.random() * diff + min;
-	},
-	smoothstep(min, max, x) {
-		if (x <= min) return 0;
-		if (x >= max) return 1;
-		x = (x - min) / (max - min);
-		return x * x * (3 - 2 * x);
-	},
-	smootherstep(min, max, x) {
-		if (x <= min) return 0;
-		if (x >= max) return 1;
-		x = (x - min) / (max - min);
-		return x * x * x * (x * (x * 6 - 15) + 10);
-	},
-	roundUp(numToRound, multiple) {
-		if (multiple === 0) {
-			return numToRound;
-		}
-		return Math.ceil(numToRound / multiple) * multiple;
-	},
-	between(num, a, b, inclusive) {
-		const min = Math.min(a, b);
-		const max = Math.max(a, b);
-		return inclusive ? num >= min && num <= max : num > min && num < max;
-	}
+    return {
+        comments: header.comments,
+        elements
+    };
 };
 
-var _Vec;
-class Vec3 {
-	constructor(x = 0, y = 0, z = 0) {
-		this.x = void 0;
-		this.y = void 0;
-		this.z = void 0;
-		if (x.length === 3) {
-			this.x = x[0];
-			this.y = x[1];
-			this.z = x[2];
-		} else {
-			this.x = x;
-			this.y = y;
-			this.z = z;
-		}
-	}
-	add(rhs) {
-		this.x += rhs.x;
-		this.y += rhs.y;
-		this.z += rhs.z;
-		return this;
-	}
-	add2(lhs, rhs) {
-		this.x = lhs.x + rhs.x;
-		this.y = lhs.y + rhs.y;
-		this.z = lhs.z + rhs.z;
-		return this;
-	}
-	addScalar(scalar) {
-		this.x += scalar;
-		this.y += scalar;
-		this.z += scalar;
-		return this;
-	}
-	addScaled(rhs, scalar) {
-		this.x += rhs.x * scalar;
-		this.y += rhs.y * scalar;
-		this.z += rhs.z * scalar;
-		return this;
-	}
-	clone() {
-		const cstr = this.constructor;
-		return new cstr(this.x, this.y, this.z);
-	}
-	copy(rhs) {
-		this.x = rhs.x;
-		this.y = rhs.y;
-		this.z = rhs.z;
-		return this;
-	}
-	cross(lhs, rhs) {
-		const lx = lhs.x;
-		const ly = lhs.y;
-		const lz = lhs.z;
-		const rx = rhs.x;
-		const ry = rhs.y;
-		const rz = rhs.z;
-		this.x = ly * rz - ry * lz;
-		this.y = lz * rx - rz * lx;
-		this.z = lx * ry - rx * ly;
-		return this;
-	}
-	distance(rhs) {
-		const x = this.x - rhs.x;
-		const y = this.y - rhs.y;
-		const z = this.z - rhs.z;
-		return Math.sqrt(x * x + y * y + z * z);
-	}
-	div(rhs) {
-		this.x /= rhs.x;
-		this.y /= rhs.y;
-		this.z /= rhs.z;
-		return this;
-	}
-	div2(lhs, rhs) {
-		this.x = lhs.x / rhs.x;
-		this.y = lhs.y / rhs.y;
-		this.z = lhs.z / rhs.z;
-		return this;
-	}
-	divScalar(scalar) {
-		this.x /= scalar;
-		this.y /= scalar;
-		this.z /= scalar;
-		return this;
-	}
-	dot(rhs) {
-		return this.x * rhs.x + this.y * rhs.y + this.z * rhs.z;
-	}
-	equals(rhs) {
-		return this.x === rhs.x && this.y === rhs.y && this.z === rhs.z;
-	}
-	equalsApprox(rhs, epsilon = 1e-6) {
-		return Math.abs(this.x - rhs.x) < epsilon && Math.abs(this.y - rhs.y) < epsilon && Math.abs(this.z - rhs.z) < epsilon;
-	}
-	length() {
-		return Math.sqrt(this.x * this.x + this.y * this.y + this.z * this.z);
-	}
-	lengthSq() {
-		return this.x * this.x + this.y * this.y + this.z * this.z;
-	}
-	lerp(lhs, rhs, alpha) {
-		this.x = lhs.x + alpha * (rhs.x - lhs.x);
-		this.y = lhs.y + alpha * (rhs.y - lhs.y);
-		this.z = lhs.z + alpha * (rhs.z - lhs.z);
-		return this;
-	}
-	mul(rhs) {
-		this.x *= rhs.x;
-		this.y *= rhs.y;
-		this.z *= rhs.z;
-		return this;
-	}
-	mul2(lhs, rhs) {
-		this.x = lhs.x * rhs.x;
-		this.y = lhs.y * rhs.y;
-		this.z = lhs.z * rhs.z;
-		return this;
-	}
-	mulScalar(scalar) {
-		this.x *= scalar;
-		this.y *= scalar;
-		this.z *= scalar;
-		return this;
-	}
-	normalize(src = this) {
-		const lengthSq = src.x * src.x + src.y * src.y + src.z * src.z;
-		if (lengthSq > 0) {
-			const invLength = 1 / Math.sqrt(lengthSq);
-			this.x = src.x * invLength;
-			this.y = src.y * invLength;
-			this.z = src.z * invLength;
-		}
-		return this;
-	}
-	floor(src = this) {
-		this.x = Math.floor(src.x);
-		this.y = Math.floor(src.y);
-		this.z = Math.floor(src.z);
-		return this;
-	}
-	ceil(src = this) {
-		this.x = Math.ceil(src.x);
-		this.y = Math.ceil(src.y);
-		this.z = Math.ceil(src.z);
-		return this;
-	}
-	round(src = this) {
-		this.x = Math.round(src.x);
-		this.y = Math.round(src.y);
-		this.z = Math.round(src.z);
-		return this;
-	}
-	min(rhs) {
-		if (rhs.x < this.x) this.x = rhs.x;
-		if (rhs.y < this.y) this.y = rhs.y;
-		if (rhs.z < this.z) this.z = rhs.z;
-		return this;
-	}
-	max(rhs) {
-		if (rhs.x > this.x) this.x = rhs.x;
-		if (rhs.y > this.y) this.y = rhs.y;
-		if (rhs.z > this.z) this.z = rhs.z;
-		return this;
-	}
-	project(rhs) {
-		const a_dot_b = this.x * rhs.x + this.y * rhs.y + this.z * rhs.z;
-		const b_dot_b = rhs.x * rhs.x + rhs.y * rhs.y + rhs.z * rhs.z;
-		const s = a_dot_b / b_dot_b;
-		this.x = rhs.x * s;
-		this.y = rhs.y * s;
-		this.z = rhs.z * s;
-		return this;
-	}
-	set(x, y, z) {
-		this.x = x;
-		this.y = y;
-		this.z = z;
-		return this;
-	}
-	sub(rhs) {
-		this.x -= rhs.x;
-		this.y -= rhs.y;
-		this.z -= rhs.z;
-		return this;
-	}
-	sub2(lhs, rhs) {
-		this.x = lhs.x - rhs.x;
-		this.y = lhs.y - rhs.y;
-		this.z = lhs.z - rhs.z;
-		return this;
-	}
-	subScalar(scalar) {
-		this.x -= scalar;
-		this.y -= scalar;
-		this.z -= scalar;
-		return this;
-	}
-	toString() {
-		return `[${this.x}, ${this.y}, ${this.z}]`;
-	}
-}
-_Vec = Vec3;
-Vec3.ZERO = Object.freeze(new _Vec(0, 0, 0));
-Vec3.HALF = Object.freeze(new _Vec(0.5, 0.5, 0.5));
-Vec3.ONE = Object.freeze(new _Vec(1, 1, 1));
-Vec3.UP = Object.freeze(new _Vec(0, 1, 0));
-Vec3.DOWN = Object.freeze(new _Vec(0, -1, 0));
-Vec3.RIGHT = Object.freeze(new _Vec(1, 0, 0));
-Vec3.LEFT = Object.freeze(new _Vec(-1, 0, 0));
-Vec3.FORWARD = Object.freeze(new _Vec(0, 0, -1));
-Vec3.BACK = Object.freeze(new _Vec(0, 0, 1));
-
-var _Quat;
-class Quat {
-	constructor(x = 0, y = 0, z = 0, w = 1) {
-		this.x = void 0;
-		this.y = void 0;
-		this.z = void 0;
-		this.w = void 0;
-		if (x.length === 4) {
-			this.x = x[0];
-			this.y = x[1];
-			this.z = x[2];
-			this.w = x[3];
-		} else {
-			this.x = x;
-			this.y = y;
-			this.z = z;
-			this.w = w;
-		}
-	}
-	clone() {
-		const cstr = this.constructor;
-		return new cstr(this.x, this.y, this.z, this.w);
-	}
-	conjugate(src = this) {
-		this.x = src.x * -1;
-		this.y = src.y * -1;
-		this.z = src.z * -1;
-		this.w = src.w;
-		return this;
-	}
-	copy(rhs) {
-		this.x = rhs.x;
-		this.y = rhs.y;
-		this.z = rhs.z;
-		this.w = rhs.w;
-		return this;
-	}
-	equals(rhs) {
-		return this.x === rhs.x && this.y === rhs.y && this.z === rhs.z && this.w === rhs.w;
-	}
-	equalsApprox(rhs, epsilon = 1e-6) {
-		return Math.abs(this.x - rhs.x) < epsilon && Math.abs(this.y - rhs.y) < epsilon && Math.abs(this.z - rhs.z) < epsilon && Math.abs(this.w - rhs.w) < epsilon;
-	}
-	getAxisAngle(axis) {
-		let rad = Math.acos(this.w) * 2;
-		const s = Math.sin(rad / 2);
-		if (s !== 0) {
-			axis.x = this.x / s;
-			axis.y = this.y / s;
-			axis.z = this.z / s;
-			if (axis.x < 0 || axis.y < 0 || axis.z < 0) {
-				axis.x *= -1;
-				axis.y *= -1;
-				axis.z *= -1;
-				rad *= -1;
-			}
-		} else {
-			axis.x = 1;
-			axis.y = 0;
-			axis.z = 0;
-		}
-		return rad * math.RAD_TO_DEG;
-	}
-	getEulerAngles(eulers = new Vec3()) {
-		let x, y, z;
-		const qx = this.x;
-		const qy = this.y;
-		const qz = this.z;
-		const qw = this.w;
-		const a2 = 2 * (qw * qy - qx * qz);
-		if (a2 <= -0.99999) {
-			x = 2 * Math.atan2(qx, qw);
-			y = -Math.PI / 2;
-			z = 0;
-		} else if (a2 >= 0.99999) {
-			x = 2 * Math.atan2(qx, qw);
-			y = Math.PI / 2;
-			z = 0;
-		} else {
-			x = Math.atan2(2 * (qw * qx + qy * qz), 1 - 2 * (qx * qx + qy * qy));
-			y = Math.asin(a2);
-			z = Math.atan2(2 * (qw * qz + qx * qy), 1 - 2 * (qy * qy + qz * qz));
-		}
-		return eulers.set(x, y, z).mulScalar(math.RAD_TO_DEG);
-	}
-	invert(src = this) {
-		return this.conjugate(src).normalize();
-	}
-	length() {
-		return Math.sqrt(this.x * this.x + this.y * this.y + this.z * this.z + this.w * this.w);
-	}
-	lengthSq() {
-		return this.x * this.x + this.y * this.y + this.z * this.z + this.w * this.w;
-	}
-	mul(rhs) {
-		const q1x = this.x;
-		const q1y = this.y;
-		const q1z = this.z;
-		const q1w = this.w;
-		const q2x = rhs.x;
-		const q2y = rhs.y;
-		const q2z = rhs.z;
-		const q2w = rhs.w;
-		this.x = q1w * q2x + q1x * q2w + q1y * q2z - q1z * q2y;
-		this.y = q1w * q2y + q1y * q2w + q1z * q2x - q1x * q2z;
-		this.z = q1w * q2z + q1z * q2w + q1x * q2y - q1y * q2x;
-		this.w = q1w * q2w - q1x * q2x - q1y * q2y - q1z * q2z;
-		return this;
-	}
-	mulScalar(scalar, src = this) {
-		this.x = src.x * scalar;
-		this.y = src.y * scalar;
-		this.z = src.z * scalar;
-		this.w = src.w * scalar;
-		return this;
-	}
-	mul2(lhs, rhs) {
-		const q1x = lhs.x;
-		const q1y = lhs.y;
-		const q1z = lhs.z;
-		const q1w = lhs.w;
-		const q2x = rhs.x;
-		const q2y = rhs.y;
-		const q2z = rhs.z;
-		const q2w = rhs.w;
-		this.x = q1w * q2x + q1x * q2w + q1y * q2z - q1z * q2y;
-		this.y = q1w * q2y + q1y * q2w + q1z * q2x - q1x * q2z;
-		this.z = q1w * q2z + q1z * q2w + q1x * q2y - q1y * q2x;
-		this.w = q1w * q2w - q1x * q2x - q1y * q2y - q1z * q2z;
-		return this;
-	}
-	normalize(src = this) {
-		let len = src.length();
-		if (len === 0) {
-			this.x = this.y = this.z = 0;
-			this.w = 1;
-		} else {
-			len = 1 / len;
-			this.x = src.x * len;
-			this.y = src.y * len;
-			this.z = src.z * len;
-			this.w = src.w * len;
-		}
-		return this;
-	}
-	set(x, y, z, w) {
-		this.x = x;
-		this.y = y;
-		this.z = z;
-		this.w = w;
-		return this;
-	}
-	setFromAxisAngle(axis, angle) {
-		angle *= 0.5 * math.DEG_TO_RAD;
-		const sa = Math.sin(angle);
-		const ca = Math.cos(angle);
-		this.x = sa * axis.x;
-		this.y = sa * axis.y;
-		this.z = sa * axis.z;
-		this.w = ca;
-		return this;
-	}
-	setFromEulerAngles(ex, ey, ez) {
-		if (ex instanceof Vec3) {
-			const vec = ex;
-			ex = vec.x;
-			ey = vec.y;
-			ez = vec.z;
-		}
-		const halfToRad = 0.5 * math.DEG_TO_RAD;
-		ex *= halfToRad;
-		ey *= halfToRad;
-		ez *= halfToRad;
-		const sx = Math.sin(ex);
-		const cx = Math.cos(ex);
-		const sy = Math.sin(ey);
-		const cy = Math.cos(ey);
-		const sz = Math.sin(ez);
-		const cz = Math.cos(ez);
-		this.x = sx * cy * cz - cx * sy * sz;
-		this.y = cx * sy * cz + sx * cy * sz;
-		this.z = cx * cy * sz - sx * sy * cz;
-		this.w = cx * cy * cz + sx * sy * sz;
-		return this;
-	}
-	setFromMat4(m) {
-		const d = m.data;
-		let m00 = d[0];
-		let m01 = d[1];
-		let m02 = d[2];
-		let m10 = d[4];
-		let m11 = d[5];
-		let m12 = d[6];
-		let m20 = d[8];
-		let m21 = d[9];
-		let m22 = d[10];
-		let l;
-		l = m00 * m00 + m01 * m01 + m02 * m02;
-		if (l === 0) return this.set(0, 0, 0, 1);
-		l = 1 / Math.sqrt(l);
-		m00 *= l;
-		m01 *= l;
-		m02 *= l;
-		l = m10 * m10 + m11 * m11 + m12 * m12;
-		if (l === 0) return this.set(0, 0, 0, 1);
-		l = 1 / Math.sqrt(l);
-		m10 *= l;
-		m11 *= l;
-		m12 *= l;
-		l = m20 * m20 + m21 * m21 + m22 * m22;
-		if (l === 0) return this.set(0, 0, 0, 1);
-		l = 1 / Math.sqrt(l);
-		m20 *= l;
-		m21 *= l;
-		m22 *= l;
-		if (m22 < 0) {
-			if (m00 > m11) {
-				this.set(1 + m00 - m11 - m22, m01 + m10, m20 + m02, m12 - m21);
-			} else {
-				this.set(m01 + m10, 1 - m00 + m11 - m22, m12 + m21, m20 - m02);
-			}
-		} else {
-			if (m00 < -m11) {
-				this.set(m20 + m02, m12 + m21, 1 - m00 - m11 + m22, m01 - m10);
-			} else {
-				this.set(m12 - m21, m20 - m02, m01 - m10, 1 + m00 + m11 + m22);
-			}
-		}
-		return this.mulScalar(1.0 / this.length());
-	}
-	setFromDirections(from, to) {
-		const dotProduct = 1 + from.dot(to);
-		if (dotProduct < Number.EPSILON) {
-			if (Math.abs(from.x) > Math.abs(from.y)) {
-				this.x = -from.z;
-				this.y = 0;
-				this.z = from.x;
-				this.w = 0;
-			} else {
-				this.x = 0;
-				this.y = -from.z;
-				this.z = from.y;
-				this.w = 0;
-			}
-		} else {
-			this.x = from.y * to.z - from.z * to.y;
-			this.y = from.z * to.x - from.x * to.z;
-			this.z = from.x * to.y - from.y * to.x;
-			this.w = dotProduct;
-		}
-		return this.normalize();
-	}
-	slerp(lhs, rhs, alpha) {
-		const lx = lhs.x;
-		const ly = lhs.y;
-		const lz = lhs.z;
-		const lw = lhs.w;
-		let rx = rhs.x;
-		let ry = rhs.y;
-		let rz = rhs.z;
-		let rw = rhs.w;
-		let cosHalfTheta = lw * rw + lx * rx + ly * ry + lz * rz;
-		if (cosHalfTheta < 0) {
-			rw = -rw;
-			rx = -rx;
-			ry = -ry;
-			rz = -rz;
-			cosHalfTheta = -cosHalfTheta;
-		}
-		if (Math.abs(cosHalfTheta) >= 1) {
-			this.w = lw;
-			this.x = lx;
-			this.y = ly;
-			this.z = lz;
-			return this;
-		}
-		const halfTheta = Math.acos(cosHalfTheta);
-		const sinHalfTheta = Math.sqrt(1 - cosHalfTheta * cosHalfTheta);
-		if (Math.abs(sinHalfTheta) < 0.001) {
-			this.w = lw * 0.5 + rw * 0.5;
-			this.x = lx * 0.5 + rx * 0.5;
-			this.y = ly * 0.5 + ry * 0.5;
-			this.z = lz * 0.5 + rz * 0.5;
-			return this;
-		}
-		const ratioA = Math.sin((1 - alpha) * halfTheta) / sinHalfTheta;
-		const ratioB = Math.sin(alpha * halfTheta) / sinHalfTheta;
-		this.w = lw * ratioA + rw * ratioB;
-		this.x = lx * ratioA + rx * ratioB;
-		this.y = ly * ratioA + ry * ratioB;
-		this.z = lz * ratioA + rz * ratioB;
-		return this;
-	}
-	transformVector(vec, res = new Vec3()) {
-		const x = vec.x,
-			y = vec.y,
-			z = vec.z;
-		const qx = this.x,
-			qy = this.y,
-			qz = this.z,
-			qw = this.w;
-		const ix = qw * x + qy * z - qz * y;
-		const iy = qw * y + qz * x - qx * z;
-		const iz = qw * z + qx * y - qy * x;
-		const iw = -qx * x - qy * y - qz * z;
-		res.x = ix * qw + iw * -qx + iy * -qz - iz * -qy;
-		res.y = iy * qw + iw * -qy + iz * -qx - ix * -qz;
-		res.z = iz * qw + iw * -qz + ix * -qy - iy * -qx;
-		return res;
-	}
-	toString() {
-		return `[${this.x}, ${this.y}, ${this.z}, ${this.w}]`;
-	}
-}
-_Quat = Quat;
-Quat.IDENTITY = Object.freeze(new _Quat(0, 0, 0, 1));
-Quat.ZERO = Object.freeze(new _Quat(0, 0, 0, 0));
+const sigmoid = (v) => 1 / (1 + Math.exp(-v));
 
-const generatedByString = `Generated by splat-transform ${version}`;
-const shBandCoeffs = [0, 3, 8, 15];
 const q = new Quat();
 // process and compress a chunk of 256 splats
-class Chunk {
+class CompressedChunk {
     static members = [
         'x', 'y', 'z',
         'scale_0', 'scale_1', 'scale_2',
@@ -811,7 +2466,7 @@ class Chunk {
     color;
     constructor(size = 256) {
         this.size = size;
-        Chunk.members.forEach((m) => {
+        CompressedChunk.members.forEach((m) => {
             this.data[m] = new Float32Array(size);
         });
         this.chunkData = new Float32Array(18);
@@ -820,10 +2475,10 @@ class Chunk {
         this.scale = new Uint32Array(size);
         this.color = new Uint32Array(size);
     }
-    set(index, singleSplat) {
-        for (let i = 0; i < Chunk.members.length; ++i) {
-            this.data[Chunk.members[i]][index] = singleSplat[i];
-        }
+    set(index, data) {
+        CompressedChunk.members.forEach((m) => {
+            this.data[m][index] = data[m];
+        });
     }
     pack() {
         const calcMinMax = (data) => {
@@ -923,7 +2578,7 @@ class Chunk {
             this.position[i] = pack111011(normalize(x[i], px.min, px.max), normalize(y[i], py.min, py.max), normalize(z[i], pz.min, pz.max));
             this.rotation[i] = packRot(rot_0[i], rot_1[i], rot_2[i], rot_3[i]);
             this.scale[i] = pack111011(normalize(scale_0[i], sx.min, sx.max), normalize(scale_1[i], sy.min, sy.max), normalize(scale_2[i], sz.min, sz.max));
-            this.color[i] = pack8888(normalize(f_dc_0[i], cr.min, cr.max), normalize(f_dc_1[i], cg.min, cg.max), normalize(f_dc_2[i], cb.min, cb.max), 1 / (1 + Math.exp(-opacity[i])));
+            this.color[i] = pack8888(normalize(f_dc_0[i], cr.min, cr.max), normalize(f_dc_1[i], cg.min, cg.max), normalize(f_dc_2[i], cb.min, cb.max), sigmoid(opacity[i]));
         }
         this.chunkData.set([
             px.min, py.min, pz.min, px.max, py.max, pz.max,
@@ -932,72 +2587,108 @@ class Chunk {
         ], 0);
     }
 }
+
 // sort the compressed indices into morton order
-const sortSplats = (splat, indices) => {
-    // https://fgiesen.wordpress.com/2009/12/13/decoding-morton-codes/
-    const encodeMorton3 = (x, y, z) => {
-        const Part1By2 = (x) => {
-            x &= 0x000003ff;
-            x = (x ^ (x << 16)) & 0xff0000ff;
-            x = (x ^ (x << 8)) & 0x0300f00f;
-            x = (x ^ (x << 4)) & 0x030c30c3;
-            x = (x ^ (x << 2)) & 0x09249249;
-            return x;
+const generateOrdering = (dataTable) => {
+    const cx = dataTable.getColumnByName('x').data;
+    const cy = dataTable.getColumnByName('y').data;
+    const cz = dataTable.getColumnByName('z').data;
+    const generate = (indices) => {
+        // https://fgiesen.wordpress.com/2009/12/13/decoding-morton-codes/
+        const encodeMorton3 = (x, y, z) => {
+            const Part1By2 = (x) => {
+                x &= 0x000003ff;
+                x = (x ^ (x << 16)) & 0xff0000ff;
+                x = (x ^ (x << 8)) & 0x0300f00f;
+                x = (x ^ (x << 4)) & 0x030c30c3;
+                x = (x ^ (x << 2)) & 0x09249249;
+                return x;
+            };
+            return (Part1By2(z) << 2) + (Part1By2(y) << 1) + Part1By2(x);
         };
-        return (Part1By2(z) << 2) + (Part1By2(y) << 1) + Part1By2(x);
-    };
-    let minx;
-    let miny;
-    let minz;
-    let maxx;
-    let maxy;
-    let maxz;
-    const vertex = [0, 0, 0];
-    const it = splat.createIterator(['x', 'y', 'z'], vertex);
-    // calculate scene extents across all splats (using sort centers, because they're in world space)
-    for (let i = 0; i < splat.numSplats; ++i) {
-        it(i);
-        const x = vertex[0];
-        const y = vertex[1];
-        const z = vertex[2];
-        if (minx === undefined) {
-            minx = maxx = x;
-            miny = maxy = y;
-            minz = maxz = z;
+        let mx;
+        let my;
+        let mz;
+        let Mx;
+        let My;
+        let Mz;
+        // calculate scene extents across all splats (using sort centers, because they're in world space)
+        for (let i = 0; i < indices.length; ++i) {
+            const ri = indices[i];
+            const x = cx[ri];
+            const y = cy[ri];
+            const z = cz[ri];
+            if (mx === undefined) {
+                mx = Mx = x;
+                my = My = y;
+                mz = Mz = z;
+            }
+            else {
+                if (x < mx)
+                    mx = x;
+                else if (x > Mx)
+                    Mx = x;
+                if (y < my)
+                    my = y;
+                else if (y > My)
+                    My = y;
+                if (z < mz)
+                    mz = z;
+                else if (z > Mz)
+                    Mz = z;
+            }
         }
-        else {
-            if (x < minx)
-                minx = x;
-            else if (x > maxx)
-                maxx = x;
-            if (y < miny)
-                miny = y;
-            else if (y > maxy)
-                maxy = y;
-            if (z < minz)
-                minz = z;
-            else if (z > maxz)
-                maxz = z;
+        const xlen = Mx - mx;
+        const ylen = My - my;
+        const zlen = Mz - mz;
+        if (!isFinite(xlen) || !isFinite(ylen) || !isFinite(zlen)) {
+            console.log('invalid extents', xlen, ylen, zlen);
+            return;
         }
+        const xmul = 1024 / xlen;
+        const ymul = 1024 / ylen;
+        const zmul = 1024 / zlen;
+        const morton = new Uint32Array(indices.length);
+        for (let i = 0; i < indices.length; ++i) {
+            const ri = indices[i];
+            const x = cx[ri];
+            const y = cy[ri];
+            const z = cz[ri];
+            const ix = Math.min(1023, (x - mx) * xmul) >>> 0;
+            const iy = Math.min(1023, (y - my) * ymul) >>> 0;
+            const iz = Math.min(1023, (z - mz) * zmul) >>> 0;
+            morton[i] = encodeMorton3(ix, iy, iz);
+        }
+        // sort indices by morton code
+        const order = indices.map((_, i) => i);
+        order.sort((a, b) => morton[a] - morton[b]);
+        const tmpIndices = indices.slice();
+        for (let i = 0; i < indices.length; ++i) {
+            indices[i] = tmpIndices[order[i]];
+        }
+        // sort the largest buckets recursively
+        let start = 0;
+        let end = 1;
+        while (start < indices.length) {
+            while (end < indices.length && morton[order[end]] === morton[order[start]]) {
+                ++end;
+            }
+            if (end - start > 256) {
+                // console.log('sorting', end - start);
+                generate(indices.subarray(start, end));
+            }
+            start = end;
+        }
+    };
+    const indices = new Uint32Array(dataTable.numRows);
+    for (let i = 0; i < indices.length; ++i) {
+        indices[i] = i;
     }
-    const xlen = maxx - minx;
-    const ylen = maxy - miny;
-    const zlen = maxz - minz;
-    const morton = new Uint32Array(indices.length);
-    let idx = 0;
-    for (let i = 0; i < splat.numSplats; ++i) {
-        it(i);
-        const x = vertex[0];
-        const y = vertex[1];
-        const z = vertex[2];
-        const ix = Math.floor(1024 * (x - minx) / xlen);
-        const iy = Math.floor(1024 * (y - miny) / ylen);
-        const iz = Math.floor(1024 * (z - minz) / zlen);
-        morton[idx++] = encodeMorton3(ix, iy, iz);
-    }
-    // order splats by morton code
-    indices.sort((a, b) => morton[a.globalIndex] - morton[b.globalIndex]);
+    generate(indices);
+    return indices;
 };
+
+const generatedByString = `Generated by splat-transform ${version}`;
 const chunkProps = [
     'min_x', 'min_y', 'min_z',
     'max_x', 'max_y', 'max_z',
@@ -1012,20 +2703,13 @@ const vertexProps = [
     'packed_scale',
     'packed_color'
 ];
-const writeCompressedPly = async (fileHandle, splat) => {
-    // make a list of indices spanning all splats (so we can sort them together)
-    const indices = [];
-    for (let i = 0; i < splat.numSplats; ++i) {
-        indices.push({ splatIndex: 0, i, globalIndex: indices.length });
-    }
-    if (indices.length === 0) {
-        throw new Error('no splats to write');
-    }
-    const numSplats = indices.length;
+const shNames = new Array(45).fill('').map((_, i) => `f_rest_${i}`);
+const writeCompressedPly = async (fileHandle, dataTable) => {
+    const shBands = { '9': 1, '24': 2, '-1': 3 }[shNames.findIndex(v => !dataTable.hasColumn(v))] ?? 0;
+    const outputSHCoeffs = [0, 3, 8, 15][shBands];
+    const numSplats = dataTable.numRows;
     const numChunks = Math.ceil(numSplats / 256);
-    const outputSHBands = splat.numSHBands;
-    const outputSHCoeffs = shBandCoeffs[outputSHBands];
-    const shHeader = outputSHBands ? [
+    const shHeader = shBands ? [
         `element sh ${numSplats}`,
         new Array(outputSHCoeffs * 3).fill('').map((_, i) => `property uchar f_rest_${i}`)
     ].flat() : [];
@@ -1042,32 +2726,31 @@ const writeCompressedPly = async (fileHandle, splat) => {
     ].flat().join('\n');
     const header = (new TextEncoder()).encode(headerText);
     const chunkData = new Float32Array(numChunks * chunkProps.length);
-    const splatData = new Uint32Array(numSplats * vertexProps.length);
+    const splatIData = new Uint32Array(numSplats * vertexProps.length);
     const shData = new Uint8Array(numSplats * outputSHCoeffs * 3);
     // sort splats into some kind of order (morton order rn)
-    sortSplats(splat, indices);
-    const singleSplat = Chunk.members.map(_ => 0);
-    const it = splat.createIterator(Chunk.members, singleSplat);
-    const shMembers = shNames.slice(0, outputSHCoeffs * 3);
-    const singleSH = shMembers.map(_ => 0);
-    const shIt = splat.createIterator(shMembers, singleSH);
-    const chunk = new Chunk();
+    const sortIndices = generateOrdering(dataTable);
+    const row = {};
+    const chunk = new CompressedChunk();
     for (let i = 0; i < numChunks; ++i) {
         const num = Math.min(numSplats, (i + 1) * 256) - i * 256;
         for (let j = 0; j < num; ++j) {
-            const index = indices[i * 256 + j];
+            const index = sortIndices[i * 256 + j];
             // read splat data
-            it(index.i);
+            dataTable.getRow(index, row);
             // update chunk
-            chunk.set(j, singleSplat);
-            shIt(index.i);
+            chunk.set(j, row);
             // quantize and write sh data
             let off = (i * 256 + j) * outputSHCoeffs * 3;
             for (let k = 0; k < outputSHCoeffs * 3; ++k) {
-                const nvalue = singleSH[k] / 8 + 0.5;
+                const nvalue = row[shNames[k]] / 8 + 0.5;
                 shData[off++] = Math.max(0, Math.min(255, Math.trunc(nvalue * 256)));
             }
         }
+        // repeat the last gaussian to fill the rest of the final chunk
+        for (let j = num; j < 256; ++j) {
+            chunk.set(j, row);
+        }
         // pack the chunk
         chunk.pack();
         // store the float data
@@ -1075,57 +2758,490 @@ const writeCompressedPly = async (fileHandle, splat) => {
         // write packed bits
         const offset = i * 256 * 4;
         for (let j = 0; j < num; ++j) {
-            splatData[offset + j * 4 + 0] = chunk.position[j];
-            splatData[offset + j * 4 + 1] = chunk.rotation[j];
-            splatData[offset + j * 4 + 2] = chunk.scale[j];
-            splatData[offset + j * 4 + 3] = chunk.color[j];
+            splatIData[offset + j * 4 + 0] = chunk.position[j];
+            splatIData[offset + j * 4 + 1] = chunk.rotation[j];
+            splatIData[offset + j * 4 + 2] = chunk.scale[j];
+            splatIData[offset + j * 4 + 3] = chunk.color[j];
         }
     }
     await fileHandle.write(header);
     await fileHandle.write(new Uint8Array(chunkData.buffer));
-    await fileHandle.write(new Uint8Array(splatData.buffer));
+    await fileHandle.write(new Uint8Array(splatIData.buffer));
     await fileHandle.write(shData);
 };
 
-const readData = async (filename) => {
-    // open input
-    console.log(`loading '${filename}'...`);
+const columnTypeToPlyType = (type) => {
+    switch (type) {
+        case 'float32': return 'float';
+        case 'float64': return 'double';
+        case 'int8': return 'char';
+        case 'uint8': return 'uchar';
+        case 'int16': return 'short';
+        case 'uint16': return 'ushort';
+        case 'int32': return 'int';
+        case 'uint32': return 'uint';
+    }
+};
+const writePly = async (fileHandle, plyData) => {
+    const header = [
+        'ply',
+        'format binary_little_endian 1.0',
+        plyData.comments.map(c => `comment ${c}`),
+        plyData.elements.map((element) => {
+            return [
+                `element ${element.name} ${element.dataTable.numRows}`,
+                element.dataTable.columns.map((column) => {
+                    return `property ${columnTypeToPlyType(column.dataType)} ${column.name}`;
+                })
+            ];
+        }),
+        'end_header'
+    ];
+    // write the header
+    await fileHandle.write((new TextEncoder()).encode(`${header.flat(3).join('\n')}\n`));
+    for (let i = 0; i < plyData.elements.length; ++i) {
+        const table = plyData.elements[i].dataTable;
+        const columns = table.columns;
+        const buffers = columns.map(c => Buffer.from(c.data.buffer));
+        const sizes = columns.map(c => c.data.BYTES_PER_ELEMENT);
+        const rowSize = sizes.reduce((total, size) => total + size, 0);
+        // write to file in chunks of 1024 rows
+        const chunkSize = 1024;
+        const numChunks = Math.ceil(table.numRows / chunkSize);
+        const chunkData = Buffer.alloc(chunkSize * rowSize);
+        for (let c = 0; c < numChunks; ++c) {
+            const numRows = Math.min(chunkSize, table.numRows - c * chunkSize);
+            let offset = 0;
+            for (let r = 0; r < numRows; ++r) {
+                const rowOffset = c * chunkSize + r;
+                for (let p = 0; p < columns.length; ++p) {
+                    const s = sizes[p];
+                    buffers[p].copy(chunkData, offset, rowOffset * s, rowOffset * s + s);
+                    offset += s;
+                }
+            }
+            // write the chunk
+            await fileHandle.write(chunkData.subarray(0, offset));
+        }
+    }
+};
+
+new Array(45).fill('').map((_, i) => `f_rest_${i}`);
+const calcMinMax = (dataTable, columnNames) => {
+    const columns = columnNames.map(name => dataTable.getColumnByName(name));
+    const minMax = columnNames.map(() => [Infinity, -Infinity]);
+    const row = {};
+    for (let i = 0; i < dataTable.numRows; ++i) {
+        const r = dataTable.getRow(i, row, columns);
+        for (let j = 0; j < columnNames.length; ++j) {
+            const value = r[columnNames[j]];
+            if (value < minMax[j][0])
+                minMax[j][0] = value;
+            if (value > minMax[j][1])
+                minMax[j][1] = value;
+        }
+    }
+    return minMax;
+};
+const logTransform = (value) => {
+    return Math.sign(value) * Math.log(Math.abs(value) + 1);
+};
+// calculate the output index of the gaussian given its index. chunks of
+// 256 gaussians are packed into 16x16 tiles on the output texture.
+const target = (index, width) => {
+    const chunkWidth = width / 16;
+    const chunkIndex = Math.floor(index / 256);
+    const chunkX = chunkIndex % chunkWidth;
+    const chunkY = Math.floor(chunkIndex / chunkWidth);
+    const x = chunkX * 16 + (index % 16);
+    const y = chunkY * 16 + Math.floor((index % 256) / 16);
+    return x + y * width;
+};
+const writeSogs = async (outputFilename, dataTable) => {
+    // generate an optimal ordering
+    const sortIndices = generateOrdering(dataTable);
+    const numRows = dataTable.numRows;
+    const width = Math.ceil(Math.sqrt(numRows) / 16) * 16;
+    const height = Math.ceil(numRows / width / 16) * 16;
+    const channels = 4;
+    const write = (filename, data, w = width, h = height) => {
+        const pathname = resolve(dirname(outputFilename), filename);
+        console.log(`writing '${pathname}'...`);
+        return sharp(data, { raw: { width: w, height: h, channels } })
+            .webp({ lossless: true })
+            .toFile(pathname);
+    };
+    const row = {};
+    // convert position/means
+    const meansL = new Uint8Array(width * height * channels);
+    const meansU = new Uint8Array(width * height * channels);
+    const meansNames = ['x', 'y', 'z'];
+    const meansMinMax = calcMinMax(dataTable, meansNames).map(v => v.map(logTransform));
+    const meansColumns = meansNames.map(name => dataTable.getColumnByName(name));
+    for (let i = 0; i < dataTable.numRows; ++i) {
+        dataTable.getRow(sortIndices[i], row, meansColumns);
+        const x = 65535 * (logTransform(row.x) - meansMinMax[0][0]) / (meansMinMax[0][1] - meansMinMax[0][0]);
+        const y = 65535 * (logTransform(row.y) - meansMinMax[1][0]) / (meansMinMax[1][1] - meansMinMax[1][0]);
+        const z = 65535 * (logTransform(row.z) - meansMinMax[2][0]) / (meansMinMax[2][1] - meansMinMax[2][0]);
+        const ti = target(i, width);
+        meansL[ti * 4] = x & 0xff;
+        meansL[ti * 4 + 1] = y & 0xff;
+        meansL[ti * 4 + 2] = z & 0xff;
+        meansL[ti * 4 + 3] = 0xff;
+        meansU[ti * 4] = (x >> 8) & 0xff;
+        meansU[ti * 4 + 1] = (y >> 8) & 0xff;
+        meansU[ti * 4 + 2] = (z >> 8) & 0xff;
+        meansU[ti * 4 + 3] = 0xff;
+    }
+    await write('means_l.webp', meansL);
+    await write('means_u.webp', meansU);
+    // convert quaternions
+    const quats = new Uint8Array(width * height * channels);
+    const quatNames = ['rot_0', 'rot_1', 'rot_2', 'rot_3'];
+    const quatColumns = quatNames.map(name => dataTable.getColumnByName(name));
+    const q = [0, 0, 0, 0];
+    for (let i = 0; i < dataTable.numRows; ++i) {
+        dataTable.getRow(sortIndices[i], row, quatColumns);
+        q[0] = row.rot_0;
+        q[1] = row.rot_1;
+        q[2] = row.rot_2;
+        q[3] = row.rot_3;
+        const l = Math.sqrt(q[0] * q[0] + q[1] * q[1] + q[2] * q[2] + q[3] * q[3]);
+        // normalize
+        q.forEach((v, j) => {
+            q[j] = v / l;
+        });
+        // find max component
+        const maxComp = q.reduce((v, _, i) => (Math.abs(q[i]) > Math.abs(q[v]) ? i : v), 0);
+        // invert if max component is negative
+        if (q[maxComp] < 0) {
+            q.forEach((v, j) => {
+                q[j] *= -1;
+            });
+        }
+        // scale by sqrt(2) to fit in [-1, 1] range
+        const sqrt2 = Math.sqrt(2);
+        q.forEach((v, j) => {
+            q[j] *= sqrt2;
+        });
+        const idx = [
+            [1, 2, 3],
+            [0, 2, 3],
+            [0, 1, 3],
+            [0, 1, 2]
+        ][maxComp];
+        const ti = target(i, width);
+        quats[ti * 4] = 255 * (q[idx[0]] * 0.5 + 0.5);
+        quats[ti * 4 + 1] = 255 * (q[idx[1]] * 0.5 + 0.5);
+        quats[ti * 4 + 2] = 255 * (q[idx[2]] * 0.5 + 0.5);
+        quats[ti * 4 + 3] = 252 + maxComp;
+    }
+    await write('quats.webp', quats);
+    // scales
+    const scales = new Uint8Array(width * height * channels);
+    const scaleNames = ['scale_0', 'scale_1', 'scale_2'];
+    const scaleColumns = scaleNames.map(name => dataTable.getColumnByName(name));
+    const scaleMinMax = calcMinMax(dataTable, scaleNames);
+    for (let i = 0; i < dataTable.numRows; ++i) {
+        dataTable.getRow(sortIndices[i], row, scaleColumns);
+        const ti = target(i, width);
+        scales[ti * 4] = 255 * (row.scale_0 - scaleMinMax[0][0]) / (scaleMinMax[0][1] - scaleMinMax[0][0]);
+        scales[ti * 4 + 1] = 255 * (row.scale_1 - scaleMinMax[1][0]) / (scaleMinMax[1][1] - scaleMinMax[1][0]);
+        scales[ti * 4 + 2] = 255 * (row.scale_2 - scaleMinMax[2][0]) / (scaleMinMax[2][1] - scaleMinMax[2][0]);
+        scales[ti * 4 + 3] = 0xff;
+    }
+    await write('scales.webp', scales);
+    // colors
+    const sh0 = new Uint8Array(width * height * channels);
+    const sh0Names = ['f_dc_0', 'f_dc_1', 'f_dc_2', 'opacity'];
+    const sh0Columns = sh0Names.map(name => dataTable.getColumnByName(name));
+    const sh0MinMax = calcMinMax(dataTable, sh0Names);
+    for (let i = 0; i < dataTable.numRows; ++i) {
+        dataTable.getRow(sortIndices[i], row, sh0Columns);
+        const ti = target(i, width);
+        sh0[ti * 4] = 255 * (row.f_dc_0 - sh0MinMax[0][0]) / (sh0MinMax[0][1] - sh0MinMax[0][0]);
+        sh0[ti * 4 + 1] = 255 * (row.f_dc_1 - sh0MinMax[1][0]) / (sh0MinMax[1][1] - sh0MinMax[1][0]);
+        sh0[ti * 4 + 2] = 255 * (row.f_dc_2 - sh0MinMax[2][0]) / (sh0MinMax[2][1] - sh0MinMax[2][0]);
+        sh0[ti * 4 + 3] = 255 * (row.opacity - sh0MinMax[3][0]) / (sh0MinMax[3][1] - sh0MinMax[3][0]);
+    }
+    await write('sh0.webp', sh0);
+    // write meta.json
+    const meta = {
+        means: {
+            shape: [numRows, 3],
+            dtype: 'float32',
+            mins: meansMinMax.map(v => v[0]),
+            maxs: meansMinMax.map(v => v[1]),
+            files: [
+                'means_l.webp',
+                'means_u.webp'
+            ]
+        },
+        scales: {
+            shape: [numRows, 3],
+            dtype: 'float32',
+            mins: scaleMinMax.map(v => v[0]),
+            maxs: scaleMinMax.map(v => v[1]),
+            files: ['scales.webp']
+        },
+        quats: {
+            shape: [numRows, 4],
+            dtype: 'uint8',
+            encoding: 'quaternion_packed',
+            files: ['quats.webp']
+        },
+        sh0: {
+            shape: [numRows, 1, 4],
+            dtype: 'float32',
+            mins: sh0MinMax.map(v => v[0]),
+            maxs: sh0MinMax.map(v => v[1]),
+            files: ['sh0.webp']
+        }
+    };
+    const outputFile = await open(outputFilename, 'w');
+    await outputFile.write((new TextEncoder()).encode(JSON.stringify(meta, null, 4)));
+    await outputFile.close();
+};
+
+const readFile = async (filename) => {
+    console.log(`reading '${filename}'...`);
     const inputFile = await open(filename, 'r');
-    // read contents
-    console.log(`reading contents...`);
-    const plyFile = await readPly(inputFile);
-    // close file
+    const plyData = await readPly(inputFile);
     await inputFile.close();
-    return plyFile;
+    return plyData;
 };
-const processData = (plyFile) => {
-    // check we have the necessary elements for processing
+const writeFile = async (filename, dataTable) => {
+    if (filename.endsWith('.json')) {
+        await writeSogs(filename, dataTable);
+    }
+    else if (filename.endsWith('.compressed.ply')) {
+        console.log(`writing '${filename}'...`);
+        const outputFile = await open(filename, 'w');
+        await writeCompressedPly(outputFile, dataTable);
+        await outputFile.close();
+    }
+    else {
+        console.log(`writing '${filename}'...`);
+        const outputFile = await open(filename, 'w');
+        await writePly(outputFile, {
+            comments: [],
+            elements: [{
+                    name: 'vertex',
+                    dataTable: dataTable
+                }]
+        });
+        await outputFile.close();
+    }
 };
-const writeData = async (filename, plyFile) => {
-    const outputFile = await open(filename, 'w');
-    await writeCompressedPly(outputFile, new Splat(plyFile));
-    await outputFile.close();
+// combine multiple tables into one
+// columns with matching name and type are combined
+const combine = (dataTables) => {
+    if (dataTables.length === 1) {
+        // nothing to combine
+        return dataTables[0];
+    }
+    const findMatchingColumn = (columns, column) => {
+        for (let i = 0; i < columns.length; ++i) {
+            if (columns[i].name === column.name &&
+                columns[i].dataType === column.dataType) {
+                return columns[i];
+            }
+        }
+        return null;
+    };
+    // make unique list of columns where name and type much match
+    const columns = dataTables[0].columns.slice();
+    for (let i = 1; i < dataTables.length; ++i) {
+        const dataTable = dataTables[i];
+        for (let j = 0; j < dataTable.columns.length; ++j) {
+            if (!findMatchingColumn(columns, dataTable.columns[j])) {
+                columns.push(dataTable.columns[j]);
+            }
+        }
+    }
+    // count total number of rows
+    const totalRows = dataTables.reduce((sum, dataTable) => sum + dataTable.numRows, 0);
+    // construct output dataTable
+    const resultColumns = columns.map((column) => {
+        const constructor = column.data.constructor;
+        return new Column(column.name, new constructor(totalRows));
+    });
+    const result = new DataTable(resultColumns);
+    // copy data
+    let rowOffset = 0;
+    for (let i = 0; i < dataTables.length; ++i) {
+        const dataTable = dataTables[i];
+        for (let j = 0; j < dataTable.columns.length; ++j) {
+            const column = dataTable.columns[j];
+            const targetColumn = findMatchingColumn(result.columns, column);
+            targetColumn.data.set(column.data, rowOffset);
+        }
+        rowOffset += dataTable.numRows;
+    }
+    return result;
+};
+const isGSDataTable = (dataTable) => {
+    if (![
+        'x', 'y', 'z',
+        'rot_0', 'rot_1', 'rot_2', 'rot_3',
+        'scale_0', 'scale_1', 'scale_2',
+        'f_dc_0', 'f_dc_1', 'f_dc_2',
+        'opacity'
+    ].every(c => dataTable.hasColumn(c))) {
+        return false;
+    }
+    return true;
+};
+const parseArguments = () => {
+    const { values: v, tokens } = parseArgs({
+        tokens: true,
+        strict: true,
+        allowPositionals: true,
+        options: {
+            translate: { type: 'string', short: 't', multiple: true },
+            rotate: { type: 'string', short: 'r', multiple: true },
+            scale: { type: 'string', short: 's', multiple: true },
+            filterNaN: { type: 'boolean', short: 'n', multiple: true },
+            filterByValue: { type: 'string', short: 'c', multiple: true },
+            filterBands: { type: 'string', short: 'h', multiple: true }
+        }
+    });
+    const parseNumber = (value) => {
+        const result = Number(value);
+        if (isNaN(result)) {
+            throw new Error(`Invalid number value: ${value}`);
+        }
+        return result;
+    };
+    const parseVec3 = (value) => {
+        const parts = value.split(',').map(Number);
+        if (parts.length !== 3 || parts.some(isNaN)) {
+            throw new Error(`Invalid Vec3 value: ${value}`);
+        }
+        return new Vec3(parts[0], parts[1], parts[2]);
+    };
+    const parseComparator = (value) => {
+        switch (value) {
+            case 'lt': return 'lt';
+            case 'lte': return 'lte';
+            case 'gt': return 'gt';
+            case 'gte': return 'gte';
+            case 'eq': return 'eq';
+            case 'neq': return 'neq';
+            default:
+                throw new Error(`Invalid comparator value: ${value}`);
+        }
+    };
+    const files = [];
+    for (const t of tokens) {
+        if (t.kind === 'positional') {
+            files.push({
+                filename: t.value,
+                processActions: []
+            });
+        }
+        else if (t.kind === 'option' && files.length > 0) {
+            const current = files[files.length - 1];
+            switch (t.name) {
+                case 'translate':
+                    current.processActions.push({
+                        kind: 'translate',
+                        value: parseVec3(t.value)
+                    });
+                    break;
+                case 'rotate':
+                    current.processActions.push({
+                        kind: 'rotate',
+                        value: parseVec3(t.value)
+                    });
+                    break;
+                case 'scale':
+                    current.processActions.push({
+                        kind: 'scale',
+                        value: parseNumber(t.value)
+                    });
+                    break;
+                case 'filterNaN':
+                    current.processActions.push({
+                        kind: 'filterNaN'
+                    });
+                    break;
+                case 'filterByValue': {
+                    const parts = t.value.split(',').map(p => p.trim());
+                    if (parts.length !== 3) {
+                        throw new Error(`Invalid filterByValue value: ${t.value}`);
+                    }
+                    current.processActions.push({
+                        kind: 'filterByValue',
+                        columnName: parts[0],
+                        comparator: parseComparator(parts[1]),
+                        value: parseNumber(parts[2])
+                    });
+                    break;
+                }
+                case 'filterBands': {
+                    const shBands = parseNumber(t.value);
+                    if (![0, 1, 2, 3].includes(shBands)) {
+                        throw new Error(`Invalid filterBands value: ${t.value}. Must be 0, 1, 2, or 3.`);
+                    }
+                    current.processActions.push({
+                        kind: 'filterBands',
+                        value: shBands
+                    });
+                    break;
+                }
+            }
+        }
+    }
+    return files;
 };
+const usage = `Usage: splat-transform input.ply [actions] input.ply [actions] ... output.ply [actions]
+actions:
+-translate     -t x,y,z                     Translate splats by (x, y, z)
+-rotate        -r x,y,z                     Rotate splats by euler angles (x, y, z) (in degrees)
+-scale         -s x                         Scale splats by x (uniform scaling)
+-filterNaN     -n                           Remove gaussians containing any NaN or Inf value
+-filterByValue -c name,comparator,value     Filter gaussians by a value. Specify the value name, comparator (lt, lte, gt, gte, eq, neq) and value
+-filterBands   -h 1                         Filter spherical harmonic band data. Value must be 0, 1, 2 or 3.
+`;
 const main = async () => {
     console.log(`splat-transform v${version}`);
-    if (process.argv.length < 3) {
-        console.error('Usage: splat-transform <input-file> <output-file>');
-        process.exit(1);
+    // read args
+    const files = parseArguments();
+    if (files.length < 2) {
+        console.error(usage);
+        exit(1);
     }
-    const inputFilename = process.argv[2];
-    const outputFilename = process.argv[3];
+    const inputArgs = files.slice(0, -1);
+    const outputArg = files[files.length - 1];
     try {
-        // open input
-        const plyFile = await readData(inputFilename);
-        // process
-        processData(plyFile);
-        // write
-        await writeData(outputFilename, plyFile);
+        // read, filter, process input files
+        const inputFiles = await Promise.all(inputArgs.map(async (inputArg) => {
+            const file = await readFile(resolve(inputArg.filename));
+            // filter out non-gs files
+            if (file.elements.length !== 1) {
+                return null;
+            }
+            const element = file.elements[0];
+            if (element.name !== 'vertex') {
+                return null;
+            }
+            const { dataTable } = element;
+            if (dataTable.numRows === 0 || !isGSDataTable(dataTable)) {
+                return null;
+            }
+            file.elements[0].dataTable = process(dataTable, inputArg.processActions);
+            return file;
+        }));
+        // combine inputs into a single output dataTable
+        const dataTable = process(combine(inputFiles.map(file => file.elements[0].dataTable)), outputArg.processActions);
+        // write file
+        await writeFile(resolve(outputArg.filename), dataTable);
     }
     catch (err) {
         // handle errors
         console.error(`error: ${err.message}`);
-        process.exit(1);
+        exit(1);
     }
     console.log('done');
 };