easycomponentstools 1.2.4 → 1.2.5

package/dist/webgl-x_coeunZ.js

@@ -0,0 +1,784 @@
+import { l as e } from "./get-attribute-from-layouts-CW53R-qj.js";
+import { n as t, t as n } from "./buffer-transform-9D2EHz6U.js";
+import { _ as r, a as i, n as a, r as o, t as s, v as c } from "./expression-DyJkfNa7.js";
+//#region node_modules/@luma.gl/gpgpu/dist/operations/webgl/common/helper.js
+function l(e, t, n = !1) {
+	if (n) return t === 1 ? "float" : `vec${t}`;
+	switch (e) {
+		case "uint8":
+		case "uint16":
+		case "uint32": return t === 1 ? "uint" : `uvec${t}`;
+		case "sint8":
+		case "sint16":
+		case "sint32": return t === 1 ? "int" : `ivec${t}`;
+		default: return t === 1 ? "float" : `vec${t}`;
+	}
+}
+function u(e, t, n = !1) {
+	let r;
+	if (n) switch (e) {
+		case "uint8":
+			r = "unorm8";
+			break;
+		case "sint8":
+			r = "snorm8";
+			break;
+		case "uint16":
+			r = "unorm16";
+			break;
+		case "sint16":
+			r = "snorm16";
+			break;
+		case "float32":
+			r = "float32";
+			break;
+		default: throw Error(`Unsupported normalized vertex format for ${e}`);
+	}
+	else r = e;
+	return t === 1 ? r : t === 3 && !r.startsWith("float32") && !r.endsWith("32") ? `${r}x3-webgl` : `${r}x${t}`;
+}
+function d(e) {
+	switch (e[0]) {
+		case "u": return "0u";
+		case "s": return "0";
+		default: return "0.";
+	}
+}
+function f(e, t) {
+	switch (e) {
+		case "uint8":
+		case "uint16":
+		case "uint32": return `${Math.trunc(t)}u`;
+		case "sint8":
+		case "sint16":
+		case "sint32": return `${Math.trunc(t)}`;
+		default: return Number.isInteger(t) ? `${t}.0` : `${t}`;
+	}
+}
+function p(e) {
+	switch (e) {
+		case "uint8": return "r8uint";
+		case "sint8": return "r8sint";
+		case "uint16": return "r16uint";
+		case "sint16": return "r16sint";
+		case "uint32": return "r32uint";
+		case "sint32": return "r32sint";
+		case "float32": return "r32float";
+		default: throw Error(`Unsupported WebGL gather texture format for ${e}`);
+	}
+}
+function m(e) {
+	return e;
+}
+function h(e) {
+	switch (e) {
+		case "uint32": return "usampler2D";
+		case "sint32": return "isampler2D";
+		case "float32": return "sampler2D";
+		default: throw Error(`Unsupported WebGL gather sampler type for ${e}`);
+	}
+}
+//#endregion
+//#region node_modules/@luma.gl/gpgpu/dist/operations/webgl/common/row-transform.js
+var g = "GPGPU Operation Counts", _ = "Transform Runs", v = new c();
+function y({ module: e, elementWise: t = !1, expression: r, inputs: a, output: s, operationType: c = s.type, outputBuffer: u }) {
+	let f = u.device, p = C("result", s.type, s.size, s.normalized), m = [e, p], h = [], y = {}, w = l(s.type, 1, s.normalized), T = l(c, 1, s.normalized), E = "", D = null, O = {
+		TYPE: T,
+		RESULT_LEN: s.size.toString()
+	}, k = b(a);
+	for (let [e, t] of k) m.push(x(e, t.type, t.size, t.normalized, c)), h.push(S(e, t)), t instanceof o ? y[e] = t.buffer : (D ||= i.createOrReuse(f, u.byteLength), y[e] = D), E += `TYPE ${e}[${t.size}]; get_${e}(${e});\n`, O[`${e.toUpperCase()}_LEN`] = t.size.toString();
+	let A = "";
+	if (r) for (let e = 0; e < s.size; e++) A += `result[${e}]=${r(e)};\n`;
+	else if (t) for (let t = 0; t < s.size; t++) {
+		let n = d(T), r = k.map(([e, r]) => t < r.size ? `${e}[${t}]` : n);
+		A += `result[${t}]=${e.name}(${r.join(", ")});\n`;
+	}
+	else A = `${e.name}(${k.map(([e]) => e).join(", ")}, result);`;
+	let j = `\
+#version 300 es
+
+void main() {
+${E}
+${w} result[${s.size}];
+${A}
+set_result(result);
+}
+  `, M = new n(f, {
+		vs: j,
+		shaderAssembler: v,
+		defines: O,
+		modules: m,
+		bufferLayout: h,
+		vertexCount: 1,
+		instanceCount: s.length,
+		attributes: y,
+		feedbackBufferMode: "interleaved",
+		outputs: p.varyings
+	});
+	f.statsManager.getStats(g).get(_).incrementCount(), M.run({
+		inputBuffers: y,
+		outputBuffers: { [p.varyings[0]]: s.offset === 0 ? u : {
+			buffer: u,
+			byteOffset: s.offset,
+			byteLength: s.byteLength
+		} }
+	}), D && i.recycle(D);
+}
+function b(e) {
+	return Array.isArray(e) ? e.map((e, t) => [`x${t}`, e]) : Object.entries(e);
+}
+function x(e, t, n, r = !1, i = t) {
+	let a = "", o = "";
+	for (let s = 0; s < n; s += 4) {
+		let c = Math.min(n - s, 4), u = l(t, c, r);
+		a += `in ${u} a${e}_${s};\n`;
+		for (let n = 0; n < c; n++) {
+			let a = `a${e}_${s}`;
+			c > 1 && (a = `${a}[${n}]`), (r || t !== i) && (a = `TYPE(${a})`), o += `v[${s + n}]=${a};\n`;
+		}
+	}
+	return {
+		name: e,
+		vs: `
+${a}
+void get_${e}(out TYPE v[${n}]) {
+  ${o}
+}
+`
+	};
+}
+function S(e, t) {
+	let n = {
+		name: e,
+		stepMode: t.isConstant ? "vertex" : "instance",
+		byteStride: t.stride,
+		attributes: []
+	};
+	for (let r = 0; r < t.size; r += 4) {
+		let i = Math.min(t.size - r, 4);
+		n.attributes.push({
+			attribute: `a${e}_${r}`,
+			format: u(t.type, i, t.normalized),
+			byteOffset: t.offset + t.ValueType.BYTES_PER_ELEMENT * r
+		});
+	}
+	return n;
+}
+function C(e, t, n, r = !1) {
+	let i = [], a = l(t, 1, r), o = "", s = "";
+	for (let a = 0; a < n; a += 4) {
+		let c = Math.min(n - a, 4), u = l(t, c, r);
+		i.push(`${e}_${a}`), o += `flat out ${u} ${e}_${a};\n`;
+		let d = Array.from({ length: c }, (e, t) => a + t);
+		s += `${e}_${a} = ${u}(${d.map((e) => `v[${e}]`).join(",")});\n`;
+	}
+	return {
+		name: e,
+		varyings: i,
+		vs: `
+${o}
+void set_${e}(in ${a} v[${n}]) {
+  ${s}
+}
+`
+	};
+}
+//#endregion
+//#region node_modules/@luma.gl/gpgpu/dist/operations/webgl/arithmetic.js
+var w = "TYPE arithmetic_add(TYPE x, TYPE y) {\n  return x + y;\n}\n\nTYPE arithmetic_subtract(TYPE x, TYPE y) {\n  return x - y;\n}\n\nTYPE arithmetic_multiply(TYPE x, TYPE y) {\n  return x * y;\n}\n\nTYPE arithmetic_divide(TYPE x, TYPE y) {\n  return x / y;\n}\n\nfloat arithmetic_tan(float x) {\n  return tan_fp32(x);\n}\n", T = ({ inputs: e, output: t, target: n }) => {
+	let i = t.type, o = l(i, 1, t.normalized), c = d(o), u = e.namedInputs;
+	return y({
+		module: {
+			name: "arithmetic",
+			dependencies: [r],
+			vs: w
+		},
+		inputs: u,
+		output: t,
+		operationType: i,
+		outputBuffer: n,
+		expression: (t) => s(e.expression, {
+			operations: a,
+			inputs: u,
+			laneIndex: t,
+			formatInput: (e) => `${e}[${t}]`,
+			formatOutOfBoundsInput: (e) => u[e].size === 1 ? `${e}[0]` : c,
+			formatLiteral: (e) => {
+				let n = Array.isArray(e) ? e[t] ?? 0 : e;
+				return `${o}(${f(i, n)})`;
+			},
+			formatCall: (e, t) => `${e}(${t.join(", ")})`
+		})
+	}), { success: !0 };
+}, E = "GPGPU Operation Counts", D = "Transform Runs", O = ({ inputs: n, output: r, target: a }) => {
+	let { sourceValues: s } = n, c = a.device;
+	if (s.length === 0) {
+		let e = new r.ValueType(r.length * r.size);
+		return a.write(e), {
+			success: !0,
+			value: e
+		};
+	}
+	if (s.isConstant) {
+		let e = s.value, t = new r.ValueType(r.length * r.size);
+		for (let n = 0; n < r.length; n++) {
+			let r = e[n];
+			t[n * 2] = r, t[n * 2 + 1] = r;
+		}
+		return a.write(t), {
+			success: !0,
+			value: t
+		};
+	}
+	let l = c.createTexture({
+		width: 1,
+		height: r.length,
+		format: "rg32float",
+		usage: e.RENDER | e.COPY_SRC | e.COPY_DST
+	}), u = c.createFramebuffer({ colorAttachments: [l] }), d = new t(c, {
+		vs: "#version 300 es\n\nflat out float extent_value;\n\nvoid main() {\n  float sourceValues[SOURCE_VALUES_LEN];\n  get_sourceValues(sourceValues);\n  extent_value = sourceValues[gl_VertexID];\n\n  float y = (float(gl_VertexID) + 0.5) / float(CHANNEL_COUNT) * 2.0 - 1.0;\n  gl_Position = vec4(0.0, y, 0.0, 1.0);\n  gl_PointSize = 1.0;\n}\n  ",
+		fs: "#version 300 es\n\nprecision highp float;\n\nflat in float extent_value;\nout vec2 fragColor;\n\nvoid main() {\n  fragColor = vec2(-extent_value, extent_value);\n}\n  ",
+		topology: "point-list",
+		parameters: {
+			depthCompare: "always",
+			blend: !0,
+			blendColorSrcFactor: "one",
+			blendColorDstFactor: "one",
+			blendColorOperation: "max",
+			blendAlphaSrcFactor: "one",
+			blendAlphaDstFactor: "one",
+			blendAlphaOperation: "max"
+		},
+		modules: [x("sourceValues", s.type, s.size, s.normalized)],
+		defines: {
+			TYPE: "float",
+			SOURCE_VALUES_LEN: s.size.toString(),
+			CHANNEL_COUNT: r.length.toString()
+		},
+		attributes: { sourceValues: s.buffer },
+		bufferLayout: [S("sourceValues", s)],
+		instanceCount: s.length,
+		vertexCount: r.length,
+		disableWarnings: !0
+	}), f = i.createOrReuse(c, r.byteLength);
+	try {
+		let e = c.beginRenderPass({
+			framebuffer: u,
+			parameters: { viewport: [
+				0,
+				0,
+				1,
+				r.length
+			] },
+			clearColor: [
+				-k,
+				-k,
+				0,
+				0
+			],
+			clearDepth: !1,
+			clearStencil: !1
+		});
+		c.statsManager.getStats(E).get(D).incrementCount(), d.draw(e), e.end();
+		let t = c.createCommandEncoder();
+		return t.copyTextureToBuffer({
+			sourceTexture: l,
+			width: 1,
+			height: r.length,
+			destinationBuffer: f,
+			byteOffset: 0,
+			bytesPerRow: 8
+		}), c.submit(t.finish()), T({
+			device: c,
+			inputs: {
+				expression: {
+					kind: "call",
+					op: "multiply",
+					args: [{
+						kind: "input",
+						name: "x"
+					}, {
+						kind: "literal",
+						value: [-1, 1]
+					}]
+				},
+				namedInputs: { x: new o({
+					buffer: f,
+					size: 2,
+					type: "float32",
+					length: r.length
+				}) }
+			},
+			output: r,
+			target: a
+		});
+	} finally {
+		d.destroy(), i.recycle(f), u.destroy(), l.destroy();
+	}
+}, k = 3e38, A = ({ inputs: e, output: t, target: n }) => {
+	let r = e.map((e, t) => [`x${t}`, e]);
+	j(n.device.limits.maxVertexAttributes, r), M(n.device.limits.maxInterStageShaderVariables, t);
+	let i = r.map(([e, t]) => `in TYPE ${e}[${t.size}]`).join(", "), a = 0;
+	return y({
+		module: {
+			name: "interleave",
+			vs: `\
+void interleave(${i}, out TYPE result[RESULT_LEN]) {
+${r.map(([e, t]) => {
+				let n = Array.from({ length: t.size }, (t, n) => `  result[${a + n}] = ${e}[${n}];`).join("\n");
+				return a += t.size, n;
+			}).join("\n")}
+}
+`
+		},
+		inputs: e,
+		output: t,
+		outputBuffer: n
+	}), { success: !0 };
+};
+function j(e, t) {
+	let n = t.reduce((e, [, t]) => e + Math.ceil(t.size / 4), 0);
+	if (n > e) throw Error(`interleave() requires ${n} vertex attributes, exceeding device limit ${e}`);
+}
+function M(e, t) {
+	if (t.size > e) throw Error(`interleave() output size ${t.size} exceeds device inter-stage component limit ${e}`);
+}
+//#endregion
+//#region node_modules/@luma.gl/gpgpu/dist/operations/webgl/fround.js
+function N() {
+	let e = new Uint16Array([255]);
+	return new Uint8Array(e.buffer)[0] > 0;
+}
+var P = `\
+#define LE ${+!!N()}
+const uint F32_NAN = 0xffffffffu;
+const uint F32_INF = 0x7f800000u;
+
+// Find first set bit using binary search
+// https://en.wikipedia.org/wiki/Find_first_set#CLZ
+int countLeadingZeros(uint a) {
+  if (a == 0u) return 32;
+  int n = 0;
+  if ((a & 0xffff0000u) == 0u) { n += 16; a = a << 16; }
+  if ((a & 0xff000000u) == 0u) { n += 8;  a = a << 8;  }
+  if ((a & 0xf0000000u) == 0u) { n += 4;  a = a << 4;  }
+  if ((a & 0xc0000000u) == 0u) { n += 2;  a = a << 2;  }
+  if ((a & 0x80000000u) == 0u) return n + 1;
+  return n;
+}
+
+uint roundShiftRight(uint value, int shift) {
+  if (shift <= 0) {
+    return value << (-shift);
+  }
+
+  if (shift >= 32) {
+    if (shift == 32 && value > 0x80000000u) {
+      return 1u;
+    }
+    return 0u;
+  }
+
+  uint truncated = value >> shift;
+  uint halfShift = 1u << (shift - 1);
+  uint remainder = value & ((1u << shift) - 1u);
+  if (remainder > halfShift || (remainder == halfShift && (truncated & 1u) == 1u)) {
+    return truncated + 1u;
+  }
+  return truncated;
+}
+
+uint makeFloat_(uint sign, int exponent, uint mantissa) {
+  return (sign << 31) | (uint(exponent + 127) << 23) | (mantissa & 0x7fffffu);
+}
+
+/**
+ * Assemble a float32 in bit representation according to IEEE 754
+ * https://en.wikipedia.org/wiki/Single-precision_floating-point_format
+ */
+uint makeFloat(uint sign, int exponent, uint significand) {
+  if (significand == 0u) {
+    return sign << 31;
+  }
+
+  // Remove any extra leading zeros for better precision
+  int lead_zeros = countLeadingZeros(significand);
+  // Significand is encoded as 1.fraction
+  int normalizedExponent = exponent + 31 - lead_zeros;
+
+  if (normalizedExponent > 127) {
+    return (sign << 31) | F32_INF;
+  }
+
+  uint mantissa;
+  if (normalizedExponent >= -126) {
+    mantissa = roundShiftRight(significand, 8 - lead_zeros);
+    if (mantissa >= 0x1000000u) {
+      mantissa >>= 1;
+      normalizedExponent++;
+      if (normalizedExponent > 127) {
+        return (sign << 31) | F32_INF;
+      }
+    }
+    return makeFloat_(sign, normalizedExponent, mantissa);
+  }
+
+  int subnormalShift = -149 - exponent;
+  mantissa = roundShiftRight(significand, subnormalShift);
+  if (mantissa >= 0x800000u) {
+    return (sign << 31) | (1u << 23);
+  }
+  return (sign << 31) | mantissa;
+}
+
+/**
+ * Parse 8-byte memory as a float64 number according to IEEE 754
+ * https://en.wikipedia.org/wiki/Double-precision_floating-point_format
+ * Returns 8-byte memory as 2 float32 numbers, consisting of
+ * high part: fround(d)
+ * low part: d - fround(d)
+ */
+uvec2 parseAsDouble(uvec2 d) {
+  #if LE
+  d = d.yx; // to big endian
+  #endif
+
+  uint sign = (d[0] >> 31) & 1u; // first bit
+  uint exponentBits = (d[0] >> 20) & 0x7ffu;
+  int exponent = int(exponentBits) - 1023; // next 11 bits
+  uint fractionHigh = d[0] & 0xfffffu;
+  uint fractionLow = d[1];
+
+  if (exponentBits == 0x7ffu) {
+    if (fractionHigh == 0u && fractionLow == 0u) {
+      return uvec2((sign << 31) | F32_INF, F32_NAN);
+    }
+    return uvec2(F32_NAN);
+  }
+  
+  if (exponentBits == 0u) {
+    // All float64 subnormals are too small to survive a float32 split.
+    return uvec2(sign << 31);
+  }
+
+  if (exponent > 127) {
+    return uvec2((sign << 31) | F32_INF, ((1u - sign) << 31) | F32_INF);
+  }
+
+  uint hi_part;
+  uint low_part;
+
+  // float64 significand has 52 bits
+  // float32 significand has 23 bits
+  // The significand of the high part is the significand of the double, trimmed
+  uint f_hi = 0x800000u | (fractionHigh << 3) | (fractionLow >> 29);
+  uint f_low = fractionLow & 0x1fffffffu;
+
+  if (exponent < -126) {
+    // For tiny normals, the top 24 significand bits still contribute to the float32
+    // high part, but they land in the float32 subnormal range.
+    hi_part = makeFloat(sign, exponent - 23, f_hi);
+
+    // The residual keeps the remaining 29 significand bits at the original double scale.
+    low_part = makeFloat(sign, exponent - 52, f_low);
+    return uvec2(hi_part, low_part);
+  }
+
+  bool roundUp = f_low > 0x10000000u || (f_low == 0x10000000u && (f_hi & 1u) == 1u);
+
+  uint f_rounded = f_hi + (roundUp ? 1u : 0u);
+  int exponent_hi = exponent;
+  if (f_rounded == 0x1000000u) {
+    f_rounded = 0x800000u;
+    exponent_hi++;
+  }
+
+  if (exponent_hi > 127) {
+    // Overflows float32 limit
+    hi_part = (sign << 31) | F32_INF;
+    low_part = ((1u - sign) << 31) | F32_INF;
+    return uvec2(hi_part, low_part);
+  }
+  
+  hi_part = makeFloat_(sign, exponent_hi, f_rounded);
+
+  int remainder = int(f_low);
+  uint sign_low = sign;
+  if (roundUp) {
+    remainder -= 0x20000000;
+  }
+  if (remainder < 0) {
+    sign_low = 1u - sign;
+    remainder = -remainder;
+  }
+  low_part = makeFloat(sign_low, exponent - 52, uint(remainder));
+
+  return uvec2(hi_part, low_part);
+}
+
+void fround(in uint x[X_LEN], out float result[X_LEN]) {
+  int n = X_LEN / 2;
+  for (int i = 0; i < n; i++) {
+    uvec2 f = parseAsDouble(uvec2(x[i * 2], x[i * 2 + 1]));
+    result[i] = uintBitsToFloat(f.x);
+    result[i + n] = uintBitsToFloat(f.y);
+  }
+}
+`, F = ({ inputs: e, output: t, target: n }) => (y({
+	module: {
+		name: "fround",
+		vs: P
+	},
+	inputs: e,
+	output: t,
+	operationType: "uint32",
+	outputBuffer: n
+}), { success: !0 });
+//#endregion
+//#region node_modules/@luma.gl/gpgpu/dist/operations/webgl/common/random-access-transform.js
+function I(e, t, n) {
+	let r = h(n), i = l(t, 1), a = Array.from({ length: e.size }, (e, t) => `  v[${t}] = ${i}(texelFetch(source_values_texture, ivec2(${t}, rowIndex), 0).r);`).join("\n");
+	return {
+		name: "source_values_texture",
+		vs: `
+uniform highp ${r} source_values_texture;
+void read_source_values(int rowIndex, out TYPE v[${e.size}]) {
+${a}
+}
+`
+	};
+}
+function L(t, n, r) {
+	let i = r.createTexture({
+		width: Math.max(t.size, 1),
+		height: t.length,
+		format: p(n),
+		usage: e.SAMPLE | e.COPY_DST
+	});
+	if (t.length === 0) return i;
+	let a = r.createCommandEncoder();
+	return a.copyBufferToTexture({
+		sourceBuffer: t.buffer,
+		destinationTexture: i,
+		byteOffset: t.offset,
+		bytesPerRow: t.stride,
+		rowsPerImage: t.length,
+		size: [
+			t.size,
+			t.length,
+			1
+		]
+	}), r.submit(a.finish()), i;
+}
+//#endregion
+//#region node_modules/@luma.gl/gpgpu/dist/operations/webgl/gather.js
+var R = async ({ inputs: e, output: t, target: r }) => {
+	let { ids: i, sourceValues: a } = e, o = r.device, s = C("result", t.type, t.size), c = l(i.type, 1), u = l(t.type, 1), d = m(t.type), f = L(a, d, o), p = `\
+#version 300 es
+
+void main() {
+  INDEX_TYPE ids[1];
+  get_ids(ids);
+  TYPE result[${t.size}];
+  gather(ids, result);
+  set_result(result);
+}
+  `, h = new n(o, {
+		vs: p,
+		defines: {
+			INDEX_TYPE: c,
+			TYPE: u,
+			RESULT_LEN: t.size.toString(),
+			SOURCE_VALUES_ROWS: a.length.toString()
+		},
+		modules: [
+			z(i, c),
+			I(a, t.type, d),
+			V(t.type),
+			s
+		],
+		bindings: { source_values_texture: f },
+		bufferLayout: [B(i)],
+		vertexCount: 1,
+		instanceCount: t.length,
+		feedbackBufferMode: "interleaved",
+		outputs: s.varyings
+	});
+	try {
+		return h.run({
+			inputBuffers: { ids: i.buffer },
+			outputBuffers: { [s.varyings[0]]: r }
+		}), { success: !0 };
+	} finally {
+		h.destroy(), f.destroy();
+	}
+};
+function z(e, t) {
+	let n = l(e.type, 1), r = "aids_0";
+	return e.type !== H(t) && (r = `${t}(${r})`), {
+		name: "ids",
+		vs: `
+in ${n} aids_0;
+void get_ids(out INDEX_TYPE v[1]) {
+  v[0] = ${r};
+}
+`
+	};
+}
+function B(e) {
+	return {
+		name: "ids",
+		stepMode: e.isConstant ? "vertex" : "instance",
+		byteStride: e.stride,
+		attributes: [{
+			attribute: "aids_0",
+			format: u(e.type, 1, e.normalized),
+			byteOffset: e.offset
+		}]
+	};
+}
+function V(e) {
+	return {
+		name: "gather",
+		vs: `
+void zero_result(out TYPE result[RESULT_LEN]) {
+  for (int i = 0; i < RESULT_LEN; i++) {
+    result[i] = ${d(e)};
+  }
+}
+
+void gather(in INDEX_TYPE ids[1], out TYPE result[RESULT_LEN]) {
+  int sourceIndex = int(ids[0]);
+  if (sourceIndex < 0 || sourceIndex >= SOURCE_VALUES_ROWS) {
+    zero_result(result);
+    return;
+  }
+  read_source_values(sourceIndex, result);
+}
+`
+	};
+}
+function H(e) {
+	switch (e) {
+		case "uint": return "uint32";
+		case "int": return "sint32";
+		default: return "float32";
+	}
+}
+//#endregion
+//#region node_modules/@luma.gl/gpgpu/dist/operations/webgl/dot.js
+var U = "void row_dot(in TYPE x[X_LEN], in TYPE y[Y_LEN], out float result[1]) {\n  float sum = 0.0;\n  for (int i = 0; i < X_LEN; i++) {\n    sum += float(x[i]) * float(y[i]);\n  }\n  result[0] = sum;\n}\n", W = ({ inputs: e, output: t, target: n }) => (y({
+	module: {
+		name: "row_dot",
+		vs: U
+	},
+	inputs: e,
+	output: t,
+	operationType: "float32",
+	outputBuffer: n
+}), { success: !0 }), G = "void equalAll(in TYPE x[X_LEN], in TYPE y[Y_LEN], out uint result[1]) {\n  uint allEqual = uint(1);\n  for (int i = 0; i < X_LEN; i++) {\n    if (x[i] != y[i]) {\n      allEqual = uint(0);\n      break;\n    }\n  }\n  result[0] = allEqual;\n}\n", K = ({ inputs: e, output: t, target: n }) => (y({
+	module: {
+		name: "equalAll",
+		vs: G
+	},
+	inputs: e,
+	output: t,
+	operationType: t.type === "uint32" ? e.x.type : t.type,
+	outputBuffer: n
+}), { success: !0 }), q = "void row_length(in TYPE x[X_LEN], out float result[1]) {\n  float sum = 0.0;\n  for (int i = 0; i < X_LEN; i++) {\n    sum += float(x[i]) * float(x[i]);\n  }\n  result[0] = sqrt(sum);\n}\n", J = ({ inputs: e, output: t, target: n }) => (y({
+	module: {
+		name: "row_length",
+		vs: q
+	},
+	inputs: e,
+	output: t,
+	operationType: "float32",
+	outputBuffer: n
+}), { success: !0 }), Y = async ({ inputs: e, output: t, target: r }) => {
+	let { segments: i } = e, a = r.device, o = C("result", t.type, t.size), s = m(i.type), c = L(i, s, a), l = new n(a, {
+		vs: "#version 300 es\n\nvoid main() {\n  TYPE result[RESULT_LEN];\n  segmentedMap(result);\n  set_result(result);\n}\n",
+		defines: {
+			TYPE: "uint",
+			RESULT_LEN: t.size.toString(),
+			SEGMENTS_LENGTH: i.length.toString()
+		},
+		modules: [
+			I(i, t.type, s),
+			X(),
+			o
+		],
+		bindings: { source_values_texture: c },
+		vertexCount: 1,
+		instanceCount: t.length,
+		feedbackBufferMode: "interleaved",
+		outputs: o.varyings
+	});
+	try {
+		return l.run({ outputBuffers: { [o.varyings[0]]: r } }), { success: !0 };
+	} finally {
+		l.destroy(), c.destroy();
+	}
+};
+function X() {
+	return {
+		name: "segmentedMap",
+		vs: "\nuint read_segment_start(int segmentIndex) {\n  TYPE value[1];\n  read_source_values(segmentIndex, value);\n  return uint(value[0]);\n}\n\nvoid segmentedMap(out TYPE result[RESULT_LEN]) {\n  uint vertexIndex = uint(gl_InstanceID);\n  int low = 0;\n  int high = SEGMENTS_LENGTH;\n\n  while (low < high) {\n    int mid = low + (high - low) / 2;\n    uint midStart = read_segment_start(mid);\n    if (midStart <= vertexIndex) {\n      low = mid + 1;\n    } else {\n      high = mid;\n    }\n  }\n\n  uint segmentIndex = uint(max(low - 1, 0));\n  uint segmentStart = read_segment_start(int(segmentIndex));\n  result[0] = segmentIndex;\n  result[1] = vertexIndex - segmentStart;\n}\n"
+	};
+}
+//#endregion
+//#region node_modules/@luma.gl/gpgpu/dist/operations/webgl/select.js
+var Z = async ({ inputs: e, output: t, target: n }) => {
+	let r = d(l(t.type, 1, t.normalized));
+	return y({
+		module: {
+			name: "select",
+			vs: ""
+		},
+		inputs: e,
+		output: t,
+		operationType: t.type,
+		outputBuffer: n,
+		expression: (t) => {
+			let n = Q("condition", e.condition, t, r), i = Q("whenTrue", e.whenTrue, t, r), a = Q("whenFalse", e.whenFalse, t, r);
+			return `(${n} != ${r} ? ${i} : ${a})`;
+		}
+	}), { success: !0 };
+};
+function Q(e, t, n, r) {
+	return n < t.size ? `${e}[${n}]` : t.size === 1 ? `${e}[0]` : r;
+}
+//#endregion
+//#region node_modules/@luma.gl/gpgpu/dist/operations/webgl/sequence.js
+var $ = ({ inputs: e, output: t, target: r }) => {
+	let i = C("result", t.type, t.size), a = new n(r.device, {
+		vs: "#version 300 es\n\nvoid main() {\n  int result[1];\n  result[0] = START + gl_InstanceID * STEP;\n  set_result(result);\n}\n",
+		defines: {
+			START: e.start.toString(),
+			STEP: e.step.toString()
+		},
+		modules: [i],
+		vertexCount: 1,
+		instanceCount: t.length,
+		feedbackBufferMode: "interleaved",
+		outputs: i.varyings
+	});
+	try {
+		return a.run({ outputBuffers: { [i.varyings[0]]: r } }), { success: !0 };
+	} finally {
+		a.destroy();
+	}
+}, ee = ({ inputs: e, output: t, target: n }) => {
+	let { columns: r } = e;
+	return y({
+		module: {
+			name: "swizzle",
+			vs: "// swizzle expression handled inline"
+		},
+		expression: (e) => `x[${r[e]}]`,
+		inputs: { x: e.x },
+		output: t,
+		outputBuffer: n
+	}), { success: !0 };
+};
+//#endregion
+export { T as arithmetic, W as dot, K as equalAll, O as extent, F as fround, R as gather, A as interleave, J as length, Y as segmentedMap, Z as select, $ as sequence, ee as swizzle };