easycomponentstools 1.2.4 → 1.2.5

package/dist/array-utils-flat-BeGpfCVx.js

@@ -0,0 +1,1535 @@
+//#region node_modules/@probe.gl/env/dist/lib/globals.js
+var e = globalThis;
+globalThis.document;
+var t = globalThis.process || {};
+globalThis.console;
+var n = globalThis.navigator || {};
+//#endregion
+//#region node_modules/@probe.gl/env/dist/lib/is-electron.js
+function r(e) {
+	if (typeof window < "u" && window.process?.type === "renderer" || typeof process < "u" && process.versions?.electron) return !0;
+	let t = typeof navigator < "u" && navigator.userAgent, n = e || t;
+	return !!(n && n.indexOf("Electron") >= 0);
+}
+//#endregion
+//#region node_modules/@probe.gl/env/dist/lib/is-browser.js
+function i() {
+	return !(typeof process == "object" && String(process) === "[object process]" && !process?.browser) || r();
+}
+//#endregion
+//#region node_modules/@probe.gl/env/dist/index.js
+var a = "4.1.2";
+//#endregion
+//#region node_modules/@probe.gl/log/dist/utils/assert.js
+function o(e, t) {
+	if (!e) throw Error(t || "Assertion failed");
+}
+//#endregion
+//#region node_modules/@probe.gl/log/dist/loggers/log-utils.js
+function s(e) {
+	if (!e) return 0;
+	let t;
+	switch (typeof e) {
+		case "number":
+			t = e;
+			break;
+		case "object":
+			t = e.logLevel || e.priority || 0;
+			break;
+		default: return 0;
+	}
+	return o(Number.isFinite(t) && t >= 0), t;
+}
+function c(e) {
+	let { logLevel: t, message: n } = e;
+	e.logLevel = s(t);
+	let r = e.args ? Array.from(e.args) : [];
+	for (; r.length && r.shift() !== n;);
+	switch (typeof t) {
+		case "string":
+		case "function":
+			n !== void 0 && r.unshift(n), e.message = t;
+			break;
+		case "object": Object.assign(e, t);
+	}
+	typeof e.message == "function" && (e.message = e.message());
+	let i = typeof e.message;
+	return o(i === "string" || i === "object"), Object.assign(e, { args: r }, e.opts);
+}
+//#endregion
+//#region node_modules/@probe.gl/log/dist/loggers/base-log.js
+var l = () => {}, u = class {
+	constructor({ level: e = 0 } = {}) {
+		this.userData = {}, this._onceCache = /* @__PURE__ */ new Set(), this._level = e;
+	}
+	set level(e) {
+		this.setLevel(e);
+	}
+	get level() {
+		return this.getLevel();
+	}
+	setLevel(e) {
+		return this._level = e, this;
+	}
+	getLevel() {
+		return this._level;
+	}
+	warn(e, ...t) {
+		return this._log("warn", 0, e, t, { once: !0 });
+	}
+	error(e, ...t) {
+		return this._log("error", 0, e, t);
+	}
+	log(e, t, ...n) {
+		return this._log("log", e, t, n);
+	}
+	info(e, t, ...n) {
+		return this._log("info", e, t, n);
+	}
+	once(e, t, ...n) {
+		return this._log("once", e, t, n, { once: !0 });
+	}
+	_log(e, t, n, r, i = {}) {
+		let a = c({
+			logLevel: t,
+			message: n,
+			args: this._buildArgs(t, n, r),
+			opts: i
+		});
+		return this._createLogFunction(e, a, i);
+	}
+	_buildArgs(e, t, n) {
+		return [
+			e,
+			t,
+			...n
+		];
+	}
+	_createLogFunction(e, t, n) {
+		if (!this._shouldLog(t.logLevel)) return l;
+		let r = this._getOnceTag(n.tag ?? t.tag ?? t.message);
+		if ((n.once || t.once) && r !== void 0) {
+			if (this._onceCache.has(r)) return l;
+			this._onceCache.add(r);
+		}
+		return this._emit(e, t);
+	}
+	_shouldLog(e) {
+		return this.getLevel() >= s(e);
+	}
+	_getOnceTag(e) {
+		if (e !== void 0) try {
+			return typeof e == "string" ? e : String(e);
+		} catch {
+			return;
+		}
+	}
+};
+//#endregion
+//#region node_modules/@probe.gl/log/dist/utils/local-storage.js
+function ee(e) {
+	try {
+		let t = window[e], n = "__storage_test__";
+		return t.setItem(n, n), t.removeItem(n), t;
+	} catch {
+		return null;
+	}
+}
+var te = class {
+	constructor(e, t, n = "sessionStorage") {
+		this.storage = ee(n), this.id = e, this.config = t, this._loadConfiguration();
+	}
+	getConfiguration() {
+		return this.config;
+	}
+	setConfiguration(e) {
+		if (Object.assign(this.config, e), this.storage) {
+			let e = JSON.stringify(this.config);
+			this.storage.setItem(this.id, e);
+		}
+	}
+	_loadConfiguration() {
+		let e = {};
+		if (this.storage) {
+			let t = this.storage.getItem(this.id);
+			e = t ? JSON.parse(t) : {};
+		}
+		return Object.assign(this.config, e), this;
+	}
+};
+//#endregion
+//#region node_modules/@probe.gl/log/dist/utils/formatters.js
+function ne(e) {
+	let t;
+	return t = e < 10 ? `${e.toFixed(2)}ms` : e < 100 ? `${e.toFixed(1)}ms` : e < 1e3 ? `${e.toFixed(0)}ms` : `${(e / 1e3).toFixed(2)}s`, t;
+}
+function re(e, t = 8) {
+	let n = Math.max(t - e.length, 0);
+	return `${" ".repeat(n)}${e}`;
+}
+//#endregion
+//#region node_modules/@probe.gl/log/dist/utils/color.js
+var d;
+(function(e) {
+	e[e.BLACK = 30] = "BLACK", e[e.RED = 31] = "RED", e[e.GREEN = 32] = "GREEN", e[e.YELLOW = 33] = "YELLOW", e[e.BLUE = 34] = "BLUE", e[e.MAGENTA = 35] = "MAGENTA", e[e.CYAN = 36] = "CYAN", e[e.WHITE = 37] = "WHITE", e[e.BRIGHT_BLACK = 90] = "BRIGHT_BLACK", e[e.BRIGHT_RED = 91] = "BRIGHT_RED", e[e.BRIGHT_GREEN = 92] = "BRIGHT_GREEN", e[e.BRIGHT_YELLOW = 93] = "BRIGHT_YELLOW", e[e.BRIGHT_BLUE = 94] = "BRIGHT_BLUE", e[e.BRIGHT_MAGENTA = 95] = "BRIGHT_MAGENTA", e[e.BRIGHT_CYAN = 96] = "BRIGHT_CYAN", e[e.BRIGHT_WHITE = 97] = "BRIGHT_WHITE";
+})(d ||= {});
+var ie = 10;
+function f(e) {
+	return typeof e == "string" ? (e = e.toUpperCase(), d[e] || d.WHITE) : e;
+}
+function ae(e, t, n) {
+	return !i && typeof e == "string" && (t && (e = `\u001b[${f(t)}m${e}\u001b[39m`), n && (e = `\u001b[${f(n) + ie}m${e}\u001b[49m`)), e;
+}
+//#endregion
+//#region node_modules/@probe.gl/log/dist/utils/autobind.js
+function oe(e, t = ["constructor"]) {
+	let n = Object.getPrototypeOf(e), r = Object.getOwnPropertyNames(n), i = e;
+	for (let n of r) {
+		let r = i[n];
+		typeof r == "function" && (t.find((e) => n === e) || (i[n] = r.bind(e)));
+	}
+}
+//#endregion
+//#region node_modules/@probe.gl/log/dist/probe.js
+var p = class {
+	getHighResolutionTimer() {
+		let n;
+		if (i() && e.performance) n = e?.performance?.now?.();
+		else if ("hrtime" in t) {
+			let e = t?.hrtime?.();
+			n = e[0] * 1e3 + e[1] / 1e6;
+		} else n = Date.now();
+		return n;
+	}
+	getMemoryUsageMB() {
+		let t = (e?.performance)?.memory?.usedJSHeapSize;
+		return t == null ? null : Math.trunc(t / 1024 / 1024);
+	}
+}, m = new p();
+globalThis.Probe = p, globalThis.probe = m;
+//#endregion
+//#region node_modules/@probe.gl/log/dist/loggers/probe-log.js
+var h = {
+	debug: i() && console.debug || console.log,
+	log: console.log,
+	info: console.info,
+	warn: console.warn,
+	error: console.error
+}, g = {
+	enabled: !0,
+	level: 0
+}, _ = class extends u {
+	constructor({ id: e } = { id: "" }) {
+		super({ level: 0 }), this.VERSION = a, this._startTs = m.getHighResolutionTimer(), this._deltaTs = m.getHighResolutionTimer(), this.userData = {}, this.LOG_THROTTLE_TIMEOUT = 0, this.id = e, this.userData = {}, this._storage = new te(`__probe-${this.id}__`, { [this.id]: g }), this.timeStamp(`${this.id} started`), oe(this), Object.seal(this);
+	}
+	isEnabled() {
+		return this._getConfiguration().enabled;
+	}
+	getLevel() {
+		return this._getConfiguration().level;
+	}
+	getTotal() {
+		return Number((m.getHighResolutionTimer() - this._startTs).toPrecision(10));
+	}
+	getDelta() {
+		return Number((m.getHighResolutionTimer() - this._deltaTs).toPrecision(10));
+	}
+	set priority(e) {
+		this.level = e;
+	}
+	get priority() {
+		return this.level;
+	}
+	getPriority() {
+		return this.level;
+	}
+	enable(e = !0) {
+		return this._updateConfiguration({ enabled: e }), this;
+	}
+	setLevel(e) {
+		return this._updateConfiguration({ level: e }), this;
+	}
+	get(e) {
+		return this._getConfiguration()[e];
+	}
+	set(e, t) {
+		this._updateConfiguration({ [e]: t });
+	}
+	settings() {
+		console.table ? console.table(this._storage.config) : console.log(this._storage.config);
+	}
+	assert(e, t) {
+		if (!e) throw Error(t || "Assertion failed");
+	}
+	warn(e, ...t) {
+		return this._log("warn", 0, e, t, {
+			method: h.warn,
+			once: !0
+		});
+	}
+	error(e, ...t) {
+		return this._log("error", 0, e, t, { method: h.error });
+	}
+	deprecated(e, t) {
+		return this.warn(`\`${e}\` is deprecated and will be removed \
+in a later version. Use \`${t}\` instead`);
+	}
+	removed(e, t) {
+		return this.error(`\`${e}\` has been removed. Use \`${t}\` instead`);
+	}
+	probe(e, t, ...n) {
+		let r = m.getMemoryUsageMB();
+		if (r !== null) {
+			let e = `${r}MB `;
+			typeof t == "function" ? t = () => `${e}${t()}` : typeof t == "string" && (t = `${e}${t}`);
+		}
+		return this._log("log", e, t, n, {
+			method: h.log,
+			time: !0,
+			once: !0
+		});
+	}
+	log(e, t, ...n) {
+		return this._log("log", e, t, n, { method: h.debug });
+	}
+	info(e, t, ...n) {
+		return this._log("info", e, t, n, { method: console.info });
+	}
+	once(e, t, ...n) {
+		return this._log("once", e, t, n, {
+			method: h.debug || h.info,
+			once: !0
+		});
+	}
+	table(e, t, n) {
+		return t ? this._log("table", e, t, n && [n] || [], {
+			method: console.table || l,
+			tag: ce(t)
+		}) : l;
+	}
+	time(e, t) {
+		return this._log("time", e, t, [], { method: console.time ? console.time : console.info });
+	}
+	timeEnd(e, t) {
+		return this._log("time", e, t, [], { method: console.timeEnd ? console.timeEnd : console.info });
+	}
+	timeStamp(e, t) {
+		return this._log("time", e, t, [], { method: console.timeStamp || l });
+	}
+	group(e, t, n = { collapsed: !1 }) {
+		let r = (n.collapsed ? console.groupCollapsed : console.group) || console.info;
+		return this._log("group", e, t, [], { method: r });
+	}
+	groupCollapsed(e, t, n = {}) {
+		return this.group(e, t, Object.assign({}, n, { collapsed: !0 }));
+	}
+	groupEnd(e) {
+		return this._log("groupEnd", e, "", [], { method: console.groupEnd || l });
+	}
+	withGroup(e, t, n) {
+		this.group(e, t)();
+		try {
+			n();
+		} finally {
+			this.groupEnd(e)();
+		}
+	}
+	trace() {
+		console.trace && console.trace();
+	}
+	_shouldLog(e) {
+		return this.isEnabled() && super._shouldLog(e);
+	}
+	_emit(e, t) {
+		let n = t.method;
+		o(n), t.total = this.getTotal(), t.delta = this.getDelta(), this._deltaTs = m.getHighResolutionTimer();
+		let r = se(this.id, t.message, t);
+		return n.bind(console, r, ...t.args);
+	}
+	_getConfiguration() {
+		return this._storage.config[this.id] || this._updateConfiguration(g), this._storage.config[this.id];
+	}
+	_updateConfiguration(e) {
+		let t = this._storage.config[this.id] || { ...g };
+		this._storage.setConfiguration({ [this.id]: {
+			...t,
+			...e
+		} });
+	}
+};
+_.VERSION = a;
+function se(e, t, n) {
+	if (typeof t == "string") {
+		let r = n.time ? re(ne(n.total)) : "";
+		t = n.time ? `${e}: ${r}  ${t}` : `${e}: ${t}`, t = ae(t, n.color, n.background);
+	}
+	return t;
+}
+function ce(e) {
+	for (let t in e) for (let n in e[t]) return n || "untitled";
+	return "empty";
+}
+//#endregion
+//#region node_modules/@luma.gl/core/dist/utils/log.js
+var v = new _({ id: "luma.gl" }), y = {};
+function b(e = "id") {
+	return y[e] = y[e] || 1, `${e}-${y[e]++}`;
+}
+//#endregion
+//#region node_modules/@luma.gl/core/dist/adapter/resources/resource.js
+var le = "cpu-hotspot-profiler", x = "GPU Resource Counts", S = "Resource Counts", C = "GPU Time and Memory", ue = [
+	"Resources",
+	"Buffers",
+	"Textures",
+	"Samplers",
+	"TextureViews",
+	"Framebuffers",
+	"QuerySets",
+	"Shaders",
+	"RenderPipelines",
+	"ComputePipelines",
+	"PipelineLayouts",
+	"VertexArrays",
+	"RenderPasss",
+	"RenderBundleEncoders",
+	"RenderBundles",
+	"ComputePasss",
+	"CommandEncoders",
+	"CommandBuffers"
+], de = [
+	"Resources",
+	"Buffers",
+	"Textures",
+	"Samplers",
+	"TextureViews",
+	"Framebuffers",
+	"QuerySets",
+	"Shaders",
+	"RenderPipelines",
+	"SharedRenderPipelines",
+	"ComputePipelines",
+	"PipelineLayouts",
+	"VertexArrays",
+	"RenderPasss",
+	"RenderBundleEncoders",
+	"RenderBundles",
+	"ComputePasss",
+	"CommandEncoders",
+	"CommandBuffers"
+], fe = ue.flatMap((e) => [`${e} Created`, `${e} Active`]), pe = de.flatMap((e) => [`${e} Created`, `${e} Active`]), w = /* @__PURE__ */ new WeakMap(), T = /* @__PURE__ */ new WeakMap(), E = class {
+	static defaultProps = {
+		id: "undefined",
+		handle: void 0,
+		_isHandleBorrowed: !1,
+		userData: void 0
+	};
+	toString() {
+		return `${this[Symbol.toStringTag] || this.constructor.name}:"${this.id}"`;
+	}
+	toJSON() {
+		return this.toString();
+	}
+	id;
+	props;
+	userData = {};
+	_device;
+	destroyed = !1;
+	allocatedBytes = 0;
+	allocatedBytesName = null;
+	_attachedResources = /* @__PURE__ */ new Set();
+	get ownsHandle() {
+		return (this.props.handle === void 0 || this.props.handle === null) && !this.isHandleBorrowed;
+	}
+	get isHandleBorrowed() {
+		return !!this.props._isHandleBorrowed;
+	}
+	constructor(e, t, n) {
+		if (!e) throw Error("no device");
+		this._device = e, this.props = me(t, n);
+		let r = this.props.id === "undefined" ? b(this[Symbol.toStringTag]) : this.props.id;
+		this.props.id = r, this.id = r, this.userData = this.props.userData || {}, this.addStats();
+	}
+	destroy() {
+		this.destroyed || this.destroyResource();
+	}
+	delete() {
+		return this.destroy(), this;
+	}
+	getProps() {
+		return this.props;
+	}
+	attachResource(e) {
+		this._attachedResources.add(e);
+	}
+	detachResource(e) {
+		this._attachedResources.delete(e);
+	}
+	destroyAttachedResource(e) {
+		this._attachedResources.delete(e) && e.destroy();
+	}
+	destroyAttachedResources() {
+		for (let e of this._attachedResources) e.destroy();
+		this._attachedResources = /* @__PURE__ */ new Set();
+	}
+	destroyResource() {
+		this.destroyed ||= (this.destroyAttachedResources(), this.removeStats(), !0);
+	}
+	removeStats() {
+		let e = k(this._device), t = e ? A() : 0, n = [this._device.statsManager.getStats(x), this._device.statsManager.getStats(S)], r = O(this._device);
+		for (let e of n) D(e, r);
+		let i = this.getStatsName();
+		for (let e of n) e.get("Resources Active").decrementCount(), e.get(`${i}s Active`).decrementCount();
+		e && (e.statsBookkeepingCalls = (e.statsBookkeepingCalls || 0) + 1, e.statsBookkeepingTimeMs = (e.statsBookkeepingTimeMs || 0) + (A() - t));
+	}
+	trackAllocatedMemory(e, t = this.getStatsName()) {
+		let n = k(this._device), r = n ? A() : 0, i = this._device.statsManager.getStats(C);
+		this.allocatedBytes > 0 && this.allocatedBytesName && (i.get("GPU Memory").subtractCount(this.allocatedBytes), i.get(`${this.allocatedBytesName} Memory`).subtractCount(this.allocatedBytes)), i.get("GPU Memory").addCount(e), i.get(`${t} Memory`).addCount(e), n && (n.statsBookkeepingCalls = (n.statsBookkeepingCalls || 0) + 1, n.statsBookkeepingTimeMs = (n.statsBookkeepingTimeMs || 0) + (A() - r)), this.allocatedBytes = e, this.allocatedBytesName = t;
+	}
+	trackReferencedMemory(e, t = this.getStatsName()) {
+		this.trackAllocatedMemory(e, `External ${t}`);
+	}
+	trackDeallocatedMemory(e = this.getStatsName()) {
+		if (this.allocatedBytes === 0) {
+			this.allocatedBytesName = null;
+			return;
+		}
+		let t = k(this._device), n = t ? A() : 0, r = this._device.statsManager.getStats(C);
+		r.get("GPU Memory").subtractCount(this.allocatedBytes), r.get(`${this.allocatedBytesName || e} Memory`).subtractCount(this.allocatedBytes), t && (t.statsBookkeepingCalls = (t.statsBookkeepingCalls || 0) + 1, t.statsBookkeepingTimeMs = (t.statsBookkeepingTimeMs || 0) + (A() - n)), this.allocatedBytes = 0, this.allocatedBytesName = null;
+	}
+	trackDeallocatedReferencedMemory(e = this.getStatsName()) {
+		this.trackDeallocatedMemory(`Referenced ${e}`);
+	}
+	addStats() {
+		let e = this.getStatsName(), t = k(this._device), n = t ? A() : 0, r = [this._device.statsManager.getStats(x), this._device.statsManager.getStats(S)], i = O(this._device);
+		for (let e of r) D(e, i);
+		for (let t of r) t.get("Resources Created").incrementCount(), t.get("Resources Active").incrementCount(), t.get(`${e}s Created`).incrementCount(), t.get(`${e}s Active`).incrementCount();
+		t && (t.statsBookkeepingCalls = (t.statsBookkeepingCalls || 0) + 1, t.statsBookkeepingTimeMs = (t.statsBookkeepingTimeMs || 0) + (A() - n)), he(this._device, e);
+	}
+	getStatsName() {
+		return ge(this);
+	}
+};
+function me(e, t) {
+	let n = { ...t };
+	for (let t in e) e[t] !== void 0 && (n[t] = e[t]);
+	return n;
+}
+function D(e, t) {
+	let n = e.stats, r = !1;
+	for (let i of t) n[i] || (e.get(i), r = !0);
+	let i = Object.keys(n).length, a = w.get(e);
+	if (!r && a?.orderedStatNames === t && a.statCount === i) return;
+	let o = {}, s = T.get(t);
+	s || (s = new Set(t), T.set(t, s));
+	for (let e of t) n[e] && (o[e] = n[e]);
+	for (let [e, t] of Object.entries(n)) s.has(e) || (o[e] = t);
+	for (let e of Object.keys(n)) delete n[e];
+	Object.assign(n, o), w.set(e, {
+		orderedStatNames: t,
+		statCount: i
+	});
+}
+function O(e) {
+	return e.type === "webgl" ? pe : fe;
+}
+function k(e) {
+	let t = e.userData[le];
+	return t?.enabled ? t : null;
+}
+function A() {
+	return globalThis.performance?.now?.() ?? Date.now();
+}
+function he(e, t) {
+	let n = k(e);
+	if (n && n.activeDefaultFramebufferAcquireDepth) switch (n.transientCanvasResourceCreates = (n.transientCanvasResourceCreates || 0) + 1, t) {
+		case "Texture":
+			n.transientCanvasTextureCreates = (n.transientCanvasTextureCreates || 0) + 1;
+			break;
+		case "TextureView":
+			n.transientCanvasTextureViewCreates = (n.transientCanvasTextureViewCreates || 0) + 1;
+			break;
+		case "Sampler":
+			n.transientCanvasSamplerCreates = (n.transientCanvasSamplerCreates || 0) + 1;
+			break;
+		case "Framebuffer": n.transientCanvasFramebufferCreates = (n.transientCanvasFramebufferCreates || 0) + 1;
+	}
+}
+function ge(e) {
+	let t = Object.getPrototypeOf(e);
+	for (; t;) {
+		let n = Object.getPrototypeOf(t);
+		if (!n || n === E.prototype) return _e(t) || e[Symbol.toStringTag] || e.constructor.name;
+		t = n;
+	}
+	return e[Symbol.toStringTag] || e.constructor.name;
+}
+function _e(e) {
+	let t = Object.getOwnPropertyDescriptor(e, Symbol.toStringTag);
+	return typeof t?.get == "function" ? t.get.call(e) : typeof t?.value == "string" ? t.value : null;
+}
+//#endregion
+//#region node_modules/@luma.gl/core/dist/adapter/resources/buffer.js
+var ve = class e extends E {
+	static INDEX = 16;
+	static VERTEX = 32;
+	static UNIFORM = 64;
+	static STORAGE = 128;
+	static INDIRECT = 256;
+	static QUERY_RESOLVE = 512;
+	static MAP_READ = 1;
+	static MAP_WRITE = 2;
+	static COPY_SRC = 4;
+	static COPY_DST = 8;
+	get [Symbol.toStringTag]() {
+		return "Buffer";
+	}
+	usage;
+	indexType;
+	updateTimestamp;
+	constructor(t, n) {
+		let r = { ...n };
+		(n.usage || 0) & e.INDEX && !n.indexType && (n.data instanceof Uint32Array ? r.indexType = "uint32" : n.data instanceof Uint16Array ? r.indexType = "uint16" : n.data instanceof Uint8Array && (r.indexType = "uint8")), delete r.data, super(t, r, e.defaultProps), this.usage = r.usage || 0, this.indexType = r.indexType, this.updateTimestamp = t.incrementTimestamp();
+	}
+	clone(e) {
+		return this.device.createBuffer({
+			...this.props,
+			...e
+		});
+	}
+	static DEBUG_DATA_MAX_LENGTH = 32;
+	debugData = /* @__PURE__ */ new ArrayBuffer(0);
+	_setDebugData(t, n, r) {
+		if (!this.device.props.debug) return;
+		let i = null, a;
+		ArrayBuffer.isView(t) ? (i = t, a = t.buffer) : a = t;
+		let o = Math.min(t ? t.byteLength : r, e.DEBUG_DATA_MAX_LENGTH);
+		if (a === null) this.debugData = new ArrayBuffer(o);
+		else {
+			let e = Math.min(i?.byteOffset || 0, a.byteLength), t = Math.max(0, a.byteLength - e), n = Math.min(o, t);
+			this.debugData = new Uint8Array(a, e, n).slice().buffer;
+		}
+	}
+	static defaultProps = {
+		...E.defaultProps,
+		handle: void 0,
+		usage: 0,
+		byteLength: 0,
+		byteOffset: 0,
+		data: null,
+		indexType: "uint16",
+		onMapped: void 0
+	};
+}, j = globalThis.Float16Array;
+function ye() {
+	return j ?? Uint16Array;
+}
+function be(e) {
+	return !!(j && e === j);
+}
+//#endregion
+//#region node_modules/@luma.gl/core/dist/shadertypes/data-types/decode-data-types.js
+function xe(e) {
+	let t = e.includes("norm"), n = !t && !e.startsWith("float"), r = e.startsWith("s"), [i, a, o] = I[e] || [
+		"uint8 ",
+		"i32",
+		1
+	];
+	return {
+		signedType: i,
+		primitiveType: a,
+		byteLength: o,
+		normalized: t,
+		integer: n,
+		signed: r
+	};
+}
+function Se(e) {
+	let t = e;
+	switch (t) {
+		case "uint8": return "unorm8";
+		case "sint8": return "snorm8";
+		case "uint16": return "unorm16";
+		case "sint16": return "snorm16";
+		default: return t;
+	}
+}
+function M(e, t) {
+	switch (t) {
+		case 1: return e;
+		case 2: return e + e % 2;
+		default: return e + (4 - e % 4) % 4;
+	}
+}
+function N(e) {
+	let t = ArrayBuffer.isView(e) ? e.constructor : e;
+	if (be(t)) return "float16";
+	if (t === Uint8ClampedArray) return "uint8";
+	let n = Object.values(I).find((e) => t === e[4]);
+	if (!n) throw Error(t.name);
+	return n[0];
+}
+function Ce(e) {
+	return N(e);
+}
+function P(e) {
+	if (e === "float16") return ye();
+	let t = I[e];
+	if (!t) throw Error(e);
+	let [, , , , n] = t;
+	return n;
+}
+function F(e) {
+	return P(e);
+}
+var I = {
+	uint8: [
+		"uint8",
+		"u32",
+		1,
+		!1,
+		Uint8Array
+	],
+	sint8: [
+		"sint8",
+		"i32",
+		1,
+		!1,
+		Int8Array
+	],
+	unorm8: [
+		"uint8",
+		"f32",
+		1,
+		!0,
+		Uint8Array
+	],
+	snorm8: [
+		"sint8",
+		"f32",
+		1,
+		!0,
+		Int8Array
+	],
+	uint16: [
+		"uint16",
+		"u32",
+		2,
+		!1,
+		Uint16Array
+	],
+	sint16: [
+		"sint16",
+		"i32",
+		2,
+		!1,
+		Int16Array
+	],
+	unorm16: [
+		"uint16",
+		"u32",
+		2,
+		!0,
+		Uint16Array
+	],
+	snorm16: [
+		"sint16",
+		"i32",
+		2,
+		!0,
+		Int16Array
+	],
+	float16: [
+		"float16",
+		"f16",
+		2,
+		!1,
+		Uint16Array
+	],
+	float32: [
+		"float32",
+		"f32",
+		4,
+		!1,
+		Float32Array
+	],
+	uint32: [
+		"uint32",
+		"u32",
+		4,
+		!1,
+		Uint32Array
+	],
+	sint32: [
+		"sint32",
+		"i32",
+		4,
+		!1,
+		Int32Array
+	]
+}, L = new class {
+	getDataTypeInfo(e) {
+		return xe(e);
+	}
+	getNormalizedDataType(e) {
+		return Se(e);
+	}
+	alignTo(e, t) {
+		return M(e, t);
+	}
+	getDataType(e) {
+		return Ce(e);
+	}
+	getTypedArrayConstructor(e) {
+		return F(e);
+	}
+}(), we = new class {
+	getVertexFormatInfo(e) {
+		if (e === "unorm10-10-10-2") return {
+			type: "unorm8",
+			components: 4,
+			byteLength: 4,
+			integer: !1,
+			signed: !1,
+			normalized: !0
+		};
+		let t = e === "unorm8x4-bgra" ? "unorm8x4" : e, n;
+		t.endsWith("-webgl") && (t = t.slice(0, -6), n = !0);
+		let r = t.split("x");
+		if (r.length > 2) throw Error(`Unsupported vertex format: ${e}`);
+		let [i, a] = r, o = i, s = Ee(e, a), c = Te(e, o), l;
+		try {
+			l = n ? De(e, o, s) : this.makeVertexFormat(c.signedType, s, c.normalized);
+		} catch {
+			throw Error(`Unsupported vertex format: ${e}`);
+		}
+		if (l !== (n ? e : t)) throw Error(`Unsupported vertex format: ${e}`);
+		let u = {
+			type: o,
+			components: s,
+			byteLength: c.byteLength * s,
+			integer: c.integer,
+			signed: c.signed,
+			normalized: c.normalized
+		};
+		return n && (u.webglOnly = !0), u;
+	}
+	makeVertexFormat(e, t, n) {
+		let r = n ? L.getNormalizedDataType(e) : e;
+		switch (r) {
+			case "unorm8": return t === 1 ? "unorm8" : t === 3 ? "unorm8x3-webgl" : `${r}x${t}`;
+			case "snorm8": return t === 1 ? "snorm8" : t === 3 ? "snorm8x3-webgl" : `${r}x${t}`;
+			case "uint8":
+			case "sint8":
+				if (t === 3) throw Error(`size: ${t}`);
+				return t === 1 ? r : `${r}x${t}`;
+			case "uint16": return t === 1 ? "uint16" : t === 3 ? "uint16x3-webgl" : `${r}x${t}`;
+			case "sint16": return t === 1 ? "sint16" : t === 3 ? "sint16x3-webgl" : `${r}x${t}`;
+			case "unorm16": return t === 1 ? "unorm16" : t === 3 ? "unorm16x3-webgl" : `${r}x${t}`;
+			case "snorm16": return t === 1 ? "snorm16" : t === 3 ? "snorm16x3-webgl" : `${r}x${t}`;
+			case "float16":
+				if (t === 3) throw Error(`size: ${t}`);
+				return t === 1 ? r : `${r}x${t}`;
+			default: return t === 1 ? r : `${r}x${t}`;
+		}
+	}
+	getVertexFormatFromAttribute(e, t, n) {
+		if (!t || t > 4) throw Error(`size ${t}`);
+		let r = t, i = L.getDataType(e);
+		return this.makeVertexFormat(i, r, n);
+	}
+	getCompatibleVertexFormat(e) {
+		let t;
+		switch (e.primitiveType) {
+			case "f32":
+				t = "float32";
+				break;
+			case "i32":
+				t = "sint32";
+				break;
+			case "u32":
+				t = "uint32";
+				break;
+			case "f16": return e.components <= 2 ? "float16x2" : "float16x4";
+		}
+		return e.components === 1 ? t : `${t}x${e.components}`;
+	}
+}();
+function Te(e, t) {
+	try {
+		return L.getDataTypeInfo(t);
+	} catch {
+		throw Error(`Unsupported vertex format: ${e}`);
+	}
+}
+function Ee(e, t) {
+	if (!t) return 1;
+	let n = Number(t);
+	if (n === 2 || n === 3 || n === 4) return n;
+	throw Error(`Unsupported vertex format: ${e}`);
+}
+function De(e, t, n) {
+	if (n !== 3) throw Error(`Unsupported vertex format: ${e}`);
+	switch (t) {
+		case "uint8":
+		case "sint8":
+		case "unorm8":
+		case "snorm8":
+		case "uint16":
+		case "sint16":
+		case "unorm16":
+		case "snorm16": return `${t}x3-webgl`;
+		default: throw Error(`Unsupported vertex format: ${e}`);
+	}
+}
+//#endregion
+//#region node_modules/@luma.gl/core/dist/utils/assert.js
+function R(e, t) {
+	if (!e) {
+		let e = Error(t ?? "luma.gl assertion failed.");
+		throw Error.captureStackTrace?.(e, R), e;
+	}
+}
+function Oe(e, t) {
+	return R(e, t), e;
+}
+//#endregion
+//#region node_modules/@luma.gl/core/dist/adapter-utils/format-compiler-log.js
+function ke(e, t, n) {
+	let r = "", i = t.split(/\r?\n/), a = e.slice().sort((e, t) => e.lineNum - t.lineNum);
+	switch (n?.showSourceCode || "no") {
+		case "all":
+			let t = 0;
+			for (let e = 1; e <= i.length; e++) {
+				let o = i[e - 1], s = a[t];
+				for (o && s && (r += B(o, e, n)); a.length > t && s.lineNum === e;) {
+					let e = a[t++];
+					e && (r += z(e, i, e.lineNum, {
+						...n,
+						inlineSource: !1
+					}));
+				}
+			}
+			for (; a.length > t;) {
+				let e = a[t++];
+				e && (r += z(e, [], 0, {
+					...n,
+					inlineSource: !1
+				}));
+			}
+			return r;
+		case "issues":
+		case "no":
+			for (let t of e) r += z(t, i, t.lineNum, { inlineSource: n?.showSourceCode !== "no" });
+			return r;
+	}
+}
+function z(e, t, n, r) {
+	if (r?.inlineSource) return `
+${Ae(t, n)}${e.linePos > 0 ? `${" ".repeat(e.linePos + 5)}^^^\n` : ""}${e.type.toUpperCase()}: ${e.message}
+
+`;
+	let i = e.type === "error" ? "red" : "orange";
+	return r?.html ? `<div class='luma-compiler-log-${e.type}' style="color:${i};"><b> ${e.type.toUpperCase()}: ${e.message}</b></div>` : `${e.type.toUpperCase()}: ${e.message}`;
+}
+function Ae(e, t, n) {
+	let r = "";
+	for (let i = t - 2; i <= t; i++) {
+		let a = e[i - 1];
+		a !== void 0 && (r += B(a, t, n));
+	}
+	return r;
+}
+function B(e, t, n) {
+	let r = n?.html ? Me(e) : e;
+	return `${je(String(t), 4)}: ${r}${n?.html ? "<br/>" : "\n"}`;
+}
+function je(e, t) {
+	let n = "";
+	for (let r = e.length; r < t; ++r) n += " ";
+	return n + e;
+}
+function Me(e) {
+	return e.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll("\"", "&quot;").replaceAll("'", "&#039;");
+}
+//#endregion
+//#region node_modules/@luma.gl/core/dist/adapter/resources/shader.js
+var Ne = class e extends E {
+	get [Symbol.toStringTag]() {
+		return "Shader";
+	}
+	stage;
+	source;
+	compilationStatus = "pending";
+	constructor(t, n) {
+		n = {
+			...n,
+			debugShaders: n.debugShaders || t.props.debugShaders || "errors"
+		}, super(t, {
+			id: Pe(n),
+			...n
+		}, e.defaultProps), this.stage = this.props.stage, this.source = this.props.source;
+	}
+	getCompilationInfoSync() {
+		return null;
+	}
+	getTranslatedSource() {
+		return null;
+	}
+	async debugShader() {
+		let e = this.props.debugShaders;
+		switch (e) {
+			case "never": return;
+			case "errors": if (this.compilationStatus === "success") return;
+		}
+		try {
+			let t = await this.getCompilationInfo();
+			if (e === "warnings" && t?.length === 0) return;
+			this._displayShaderLog(t, this.id);
+		} catch (e) {
+			v.warn(`Shader ${this.id}: failed to fetch compilation info during debug logging`, e)();
+		}
+	}
+	_displayShaderLog(e, t) {
+		if (typeof document > "u" || !document?.createElement) return;
+		let n = t, r = `${this.stage} shader "${n}"`, i = ke(e, this.source, {
+			showSourceCode: "all",
+			html: !0
+		}), a = this.getTranslatedSource(), o = document.createElement("div");
+		o.innerHTML = `\
+<h1>Compilation error in ${r}</h1>
+<div style="display:flex;position:fixed;top:10px;right:20px;gap:2px;">
+<button id="copy">Copy source</button><br/>
+<button id="close">Close</button>
+</div>
+<code><pre>${i}</pre></code>`, a && (o.innerHTML += `<br /><h1>Translated Source</h1><br /><br /><code><pre>${a}</pre></code>`), o.style.top = "0", o.style.left = "0", o.style.background = "white", o.style.position = "fixed", o.style.zIndex = "9999", o.style.maxWidth = "100vw", o.style.maxHeight = "100vh", o.style.overflowY = "auto", document.body.appendChild(o), o.querySelector(".luma-compiler-log-error")?.scrollIntoView(), o.querySelector("button#close").onclick = () => {
+			o.remove();
+		}, o.querySelector("button#copy").onclick = () => {
+			navigator.clipboard.writeText(this.source);
+		};
+	}
+	static defaultProps = {
+		...E.defaultProps,
+		language: "auto",
+		stage: void 0,
+		source: "",
+		sourceMap: null,
+		entryPoint: "main",
+		debugShaders: void 0
+	};
+};
+function Pe(e) {
+	return Fe(e.source) || e.id || b(`unnamed ${e.stage}-shader`);
+}
+function Fe(e, t = "unnamed") {
+	return /#define[\s*]SHADER_NAME[\s*]([A-Za-z0-9_-]+)[\s*]/.exec(e)?.[1] ?? t;
+}
+//#endregion
+//#region node_modules/@luma.gl/core/dist/adapter/resources/render-pipeline.js
+var Ie = class e extends E {
+	get [Symbol.toStringTag]() {
+		return "RenderPipeline";
+	}
+	shaderLayout;
+	bufferLayout;
+	linkStatus = "pending";
+	hash = "";
+	sharedRenderPipeline = null;
+	get isPending() {
+		return this.linkStatus === "pending" || this.vs.compilationStatus === "pending" || this.fs?.compilationStatus === "pending";
+	}
+	get isErrored() {
+		return this.linkStatus === "error" || this.vs.compilationStatus === "error" || this.fs?.compilationStatus === "error";
+	}
+	constructor(t, n) {
+		super(t, n, e.defaultProps), this.shaderLayout = this.props.shaderLayout, this.bufferLayout = this.props.bufferLayout || [], this.sharedRenderPipeline = this.props._sharedRenderPipeline || null;
+	}
+	static defaultProps = {
+		...E.defaultProps,
+		vs: null,
+		vertexEntryPoint: "vertexMain",
+		vsConstants: {},
+		fs: null,
+		fragmentEntryPoint: "fragmentMain",
+		fsConstants: {},
+		shaderLayout: null,
+		bufferLayout: [],
+		topology: "triangle-list",
+		colorAttachmentFormats: void 0,
+		depthStencilAttachmentFormat: void 0,
+		parameters: {},
+		varyings: void 0,
+		bufferMode: void 0,
+		disableWarnings: !1,
+		_sharedRenderPipeline: void 0,
+		_uniformBlockLayouts: [],
+		bindings: void 0,
+		bindGroups: void 0
+	};
+};
+//#endregion
+//#region node_modules/@luma.gl/core/dist/shadertypes/shader-types/shader-type-decoder.js
+function V(e) {
+	let t = Ue[U(e)];
+	if (!t) throw Error(`Unsupported variable shader type: ${e}`);
+	return t;
+}
+function Le(e) {
+	let t = He[H(e)];
+	if (!t) throw Error(`Unsupported attribute shader type: ${e}`);
+	let [n, r] = t, i = n === "i32" || n === "u32", a = n !== "u32";
+	return {
+		primitiveType: n,
+		components: r,
+		byteLength: Ve[n] * r,
+		integer: i,
+		signed: a
+	};
+}
+var Re = class {
+	getVariableShaderTypeInfo(e) {
+		return V(e);
+	}
+	getAttributeShaderTypeInfo(e) {
+		return Le(e);
+	}
+	makeShaderAttributeType(e, t) {
+		return ze(e, t);
+	}
+	resolveAttributeShaderTypeAlias(e) {
+		return H(e);
+	}
+	resolveVariableShaderTypeAlias(e) {
+		return U(e);
+	}
+};
+function ze(e, t) {
+	return t === 1 ? e : `vec${t}<${e}>`;
+}
+function H(e) {
+	return We[e] || e;
+}
+function U(e) {
+	return Ge[e] || e;
+}
+var Be = new Re(), Ve = {
+	f32: 4,
+	f16: 2,
+	i32: 4,
+	u32: 4
+}, He = {
+	f32: ["f32", 1],
+	"vec2<f32>": ["f32", 2],
+	"vec3<f32>": ["f32", 3],
+	"vec4<f32>": ["f32", 4],
+	f16: ["f16", 1],
+	"vec2<f16>": ["f16", 2],
+	"vec3<f16>": ["f16", 3],
+	"vec4<f16>": ["f16", 4],
+	i32: ["i32", 1],
+	"vec2<i32>": ["i32", 2],
+	"vec3<i32>": ["i32", 3],
+	"vec4<i32>": ["i32", 4],
+	u32: ["u32", 1],
+	"vec2<u32>": ["u32", 2],
+	"vec3<u32>": ["u32", 3],
+	"vec4<u32>": ["u32", 4]
+}, Ue = {
+	f32: {
+		type: "f32",
+		components: 1
+	},
+	f16: {
+		type: "f16",
+		components: 1
+	},
+	i32: {
+		type: "i32",
+		components: 1
+	},
+	u32: {
+		type: "u32",
+		components: 1
+	},
+	"vec2<f32>": {
+		type: "f32",
+		components: 2
+	},
+	"vec3<f32>": {
+		type: "f32",
+		components: 3
+	},
+	"vec4<f32>": {
+		type: "f32",
+		components: 4
+	},
+	"vec2<f16>": {
+		type: "f16",
+		components: 2
+	},
+	"vec3<f16>": {
+		type: "f16",
+		components: 3
+	},
+	"vec4<f16>": {
+		type: "f16",
+		components: 4
+	},
+	"vec2<i32>": {
+		type: "i32",
+		components: 2
+	},
+	"vec3<i32>": {
+		type: "i32",
+		components: 3
+	},
+	"vec4<i32>": {
+		type: "i32",
+		components: 4
+	},
+	"vec2<u32>": {
+		type: "u32",
+		components: 2
+	},
+	"vec3<u32>": {
+		type: "u32",
+		components: 3
+	},
+	"vec4<u32>": {
+		type: "u32",
+		components: 4
+	},
+	"mat2x2<f32>": {
+		type: "f32",
+		components: 4
+	},
+	"mat2x3<f32>": {
+		type: "f32",
+		components: 6
+	},
+	"mat2x4<f32>": {
+		type: "f32",
+		components: 8
+	},
+	"mat3x2<f32>": {
+		type: "f32",
+		components: 6
+	},
+	"mat3x3<f32>": {
+		type: "f32",
+		components: 9
+	},
+	"mat3x4<f32>": {
+		type: "f32",
+		components: 12
+	},
+	"mat4x2<f32>": {
+		type: "f32",
+		components: 8
+	},
+	"mat4x3<f32>": {
+		type: "f32",
+		components: 12
+	},
+	"mat4x4<f32>": {
+		type: "f32",
+		components: 16
+	},
+	"mat2x2<f16>": {
+		type: "f16",
+		components: 4
+	},
+	"mat2x3<f16>": {
+		type: "f16",
+		components: 6
+	},
+	"mat2x4<f16>": {
+		type: "f16",
+		components: 8
+	},
+	"mat3x2<f16>": {
+		type: "f16",
+		components: 6
+	},
+	"mat3x3<f16>": {
+		type: "f16",
+		components: 9
+	},
+	"mat3x4<f16>": {
+		type: "f16",
+		components: 12
+	},
+	"mat4x2<f16>": {
+		type: "f16",
+		components: 8
+	},
+	"mat4x3<f16>": {
+		type: "f16",
+		components: 12
+	},
+	"mat4x4<f16>": {
+		type: "f16",
+		components: 16
+	},
+	"mat2x2<i32>": {
+		type: "i32",
+		components: 4
+	},
+	"mat2x3<i32>": {
+		type: "i32",
+		components: 6
+	},
+	"mat2x4<i32>": {
+		type: "i32",
+		components: 8
+	},
+	"mat3x2<i32>": {
+		type: "i32",
+		components: 6
+	},
+	"mat3x3<i32>": {
+		type: "i32",
+		components: 9
+	},
+	"mat3x4<i32>": {
+		type: "i32",
+		components: 12
+	},
+	"mat4x2<i32>": {
+		type: "i32",
+		components: 8
+	},
+	"mat4x3<i32>": {
+		type: "i32",
+		components: 12
+	},
+	"mat4x4<i32>": {
+		type: "i32",
+		components: 16
+	},
+	"mat2x2<u32>": {
+		type: "u32",
+		components: 4
+	},
+	"mat2x3<u32>": {
+		type: "u32",
+		components: 6
+	},
+	"mat2x4<u32>": {
+		type: "u32",
+		components: 8
+	},
+	"mat3x2<u32>": {
+		type: "u32",
+		components: 6
+	},
+	"mat3x3<u32>": {
+		type: "u32",
+		components: 9
+	},
+	"mat3x4<u32>": {
+		type: "u32",
+		components: 12
+	},
+	"mat4x2<u32>": {
+		type: "u32",
+		components: 8
+	},
+	"mat4x3<u32>": {
+		type: "u32",
+		components: 12
+	},
+	"mat4x4<u32>": {
+		type: "u32",
+		components: 16
+	}
+}, We = {
+	vec2i: "vec2<i32>",
+	vec3i: "vec3<i32>",
+	vec4i: "vec4<i32>",
+	vec2u: "vec2<u32>",
+	vec3u: "vec3<u32>",
+	vec4u: "vec4<u32>",
+	vec2f: "vec2<f32>",
+	vec3f: "vec3<f32>",
+	vec4f: "vec4<f32>",
+	vec2h: "vec2<f16>",
+	vec3h: "vec3<f16>",
+	vec4h: "vec4<f16>"
+}, Ge = {
+	vec2i: "vec2<i32>",
+	vec3i: "vec3<i32>",
+	vec4i: "vec4<i32>",
+	vec2u: "vec2<u32>",
+	vec3u: "vec3<u32>",
+	vec4u: "vec4<u32>",
+	vec2f: "vec2<f32>",
+	vec3f: "vec3<f32>",
+	vec4f: "vec4<f32>",
+	vec2h: "vec2<f16>",
+	vec3h: "vec3<f16>",
+	vec4h: "vec4<f16>",
+	mat2x2f: "mat2x2<f32>",
+	mat2x3f: "mat2x3<f32>",
+	mat2x4f: "mat2x4<f32>",
+	mat3x2f: "mat3x2<f32>",
+	mat3x3f: "mat3x3<f32>",
+	mat3x4f: "mat3x4<f32>",
+	mat4x2f: "mat4x2<f32>",
+	mat4x3f: "mat4x3<f32>",
+	mat4x4f: "mat4x4<f32>",
+	mat2x2i: "mat2x2<i32>",
+	mat2x3i: "mat2x3<i32>",
+	mat2x4i: "mat2x4<i32>",
+	mat3x2i: "mat3x2<i32>",
+	mat3x3i: "mat3x3<i32>",
+	mat3x4i: "mat3x4<i32>",
+	mat4x2i: "mat4x2<i32>",
+	mat4x3i: "mat4x3<i32>",
+	mat4x4i: "mat4x4<i32>",
+	mat2x2u: "mat2x2<u32>",
+	mat2x3u: "mat2x3<u32>",
+	mat2x4u: "mat2x4<u32>",
+	mat3x2u: "mat3x2<u32>",
+	mat3x3u: "mat3x3<u32>",
+	mat3x4u: "mat3x4<u32>",
+	mat4x2u: "mat4x2<u32>",
+	mat4x3u: "mat4x3<u32>",
+	mat4x4u: "mat4x4<u32>",
+	mat2x2h: "mat2x2<f16>",
+	mat2x3h: "mat2x3<f16>",
+	mat2x4h: "mat2x4<f16>",
+	mat3x2h: "mat3x2<f16>",
+	mat3x3h: "mat3x3<f16>",
+	mat3x4h: "mat3x4<f16>",
+	mat4x2h: "mat4x2<f16>",
+	mat4x3h: "mat4x3<f16>",
+	mat4x4h: "mat4x4<f16>"
+};
+//#endregion
+//#region node_modules/@luma.gl/core/dist/shadertypes/shader-types/shader-block-layout.js
+function Ke(e, t = {}) {
+	let n = { ...e }, r = t.layout ?? "std140", i = {}, a = 0;
+	for (let [e, t] of Object.entries(n)) a = K(i, e, t, a, r);
+	return a = M(a, J(n, r)), {
+		layout: r,
+		byteLength: a * 4,
+		uniformTypes: n,
+		fields: i
+	};
+}
+function W(e, t) {
+	let n = U(e), r = V(n), i = /^mat(\d)x(\d)<.+>$/.exec(n);
+	if (i) {
+		let e = Number(i[1]), a = Number(i[2]), o = Y(a, n, r.type, t), s = Je(o.size, o.alignment, t);
+		return {
+			alignment: o.alignment,
+			size: e * s,
+			components: e * a,
+			columns: e,
+			rows: a,
+			columnStride: s,
+			shaderType: n,
+			type: r.type
+		};
+	}
+	let a = /^vec(\d)<.+>$/.exec(n);
+	return a ? Y(Number(a[1]), n, r.type, t) : {
+		alignment: 1,
+		size: 1,
+		components: 1,
+		columns: 1,
+		rows: 1,
+		columnStride: 1,
+		shaderType: n,
+		type: r.type
+	};
+}
+function G(e) {
+	return !!e && typeof e == "object" && !Array.isArray(e);
+}
+function K(e, t, n, r, i) {
+	if (typeof n == "string") {
+		let a = W(n, i), o = M(r, a.alignment);
+		return e[t] = {
+			offset: o,
+			...a
+		}, o + a.size;
+	}
+	if (Array.isArray(n)) {
+		if (Array.isArray(n[0])) throw Error(`Nested arrays are not supported for ${t}`);
+		let a = n[0], o = n[1], s = X(a, i), c = M(r, J(n, i));
+		for (let n = 0; n < o; n++) K(e, `${t}[${n}]`, a, c + n * s, i);
+		return c + s * o;
+	}
+	if (G(n)) {
+		let a = J(n, i), o = M(r, a);
+		for (let [r, a] of Object.entries(n)) o = K(e, `${t}.${r}`, a, o, i);
+		return M(o, a);
+	}
+	throw Error(`Unsupported CompositeShaderType for ${t}`);
+}
+function q(e, t) {
+	if (typeof e == "string") return W(e, t).size;
+	if (Array.isArray(e)) {
+		let n = e[0], r = e[1];
+		if (Array.isArray(n)) throw Error("Nested arrays are not supported");
+		return X(n, t) * r;
+	}
+	let n = 0;
+	for (let r of Object.values(e)) {
+		let e = r;
+		n = M(n, J(e, t)), n += q(e, t);
+	}
+	return M(n, J(e, t));
+}
+function J(e, t) {
+	if (typeof e == "string") return W(e, t).alignment;
+	if (Array.isArray(e)) {
+		let n = e[0], r = J(n, t);
+		return Z(t) ? Math.max(r, 4) : r;
+	}
+	let n = 1;
+	for (let r of Object.values(e)) {
+		let e = J(r, t);
+		n = Math.max(n, e);
+	}
+	return Ye(t) ? Math.max(n, 4) : n;
+}
+function Y(e, t, n, r) {
+	return {
+		alignment: e === 2 ? 2 : 4,
+		size: e === 3 ? 3 : e,
+		components: e,
+		columns: 1,
+		rows: e,
+		columnStride: e === 3 ? 3 : e,
+		shaderType: t,
+		type: n
+	};
+}
+function X(e, t) {
+	return qe(q(e, t), J(e, t), t);
+}
+function qe(e, t, n) {
+	return M(e, Z(n) ? 4 : t);
+}
+function Je(e, t, n) {
+	return n === "std140" ? 4 : M(e, t);
+}
+function Z(e) {
+	return e === "std140" || e === "wgsl-uniform";
+}
+function Ye(e) {
+	return e === "std140" || e === "wgsl-uniform";
+}
+//#endregion
+//#region node_modules/@luma.gl/core/dist/utils/array-utils-flat.js
+var Q;
+function $(e) {
+	return (!Q || Q.byteLength < e) && (Q = new ArrayBuffer(e)), Q;
+}
+function Xe(e, t) {
+	return new e($(e.BYTES_PER_ELEMENT * t), 0, t);
+}
+//#endregion
+export { r as C, i as S, ve as _, Ke as a, v as b, Ie as c, Oe as d, we as f, P as g, F as h, G as i, Ne as l, N as m, $ as n, V as o, L as p, W as r, Be as s, Xe as t, R as u, E as v, n as w, _ as x, b as y };