easycomponentstools 1.2.3 → 1.2.5

package/dist/get-attribute-from-layouts-CW53R-qj.js

@@ -0,0 +1,936 @@
+import { b as e, f as t, p as n, s as r, v as i } from "./array-utils-flat-BeGpfCVx.js";
+//#region node_modules/@luma.gl/core/dist/shadertypes/texture-types/texture-format-table.js
+var a = "texture-compression-bc", o = "texture-compression-astc", s = "texture-compression-etc2", c = "texture-compression-etc1-webgl", l = "texture-compression-pvrtc-webgl", u = "texture-compression-atc-webgl", d = "float32-renderable-webgl", f = "float16-renderable-webgl", p = "rgb9e5ufloat-renderable-webgl", m = "snorm8-renderable-webgl", h = "norm16-webgl", g = "norm16-renderable-webgl", _ = "snorm16-renderable-webgl", v = "float32-filterable", y = "float16-filterable-webgl", b = 3, x = 5, S = 15, C = 19, w = 31, T = 992, E = 15360;
+function D(e) {
+	let t = j[e];
+	if (!t) throw Error(`Unsupported texture format ${e}`);
+	return t;
+}
+function O() {
+	return j;
+}
+var k = {
+	r8unorm: { webgpu: 527 },
+	rg8unorm: { webgpu: 527 },
+	"rgb8unorm-webgl": {},
+	rgba8unorm: { webgpu: w },
+	"rgba8unorm-srgb": { webgpu: S },
+	r8snorm: {
+		render: m,
+		webgpu: 837
+	},
+	rg8snorm: {
+		render: m,
+		webgpu: 837
+	},
+	"rgb8snorm-webgl": {},
+	rgba8snorm: {
+		render: m,
+		webgpu: 341
+	},
+	r8uint: { webgpu: 515 },
+	rg8uint: { webgpu: 515 },
+	rgba8uint: { webgpu: C },
+	r8sint: { webgpu: 515 },
+	rg8sint: { webgpu: 515 },
+	rgba8sint: { webgpu: C },
+	bgra8unorm: { webgpu: S },
+	"bgra8unorm-srgb": { webgpu: E },
+	r16unorm: {
+		f: h,
+		render: g,
+		webgpu: T
+	},
+	rg16unorm: {
+		f: h,
+		render: g,
+		webgpu: T
+	},
+	"rgb16unorm-webgl": {
+		f: h,
+		render: !1
+	},
+	rgba16unorm: {
+		f: h,
+		render: g,
+		webgpu: T
+	},
+	r16snorm: {
+		f: h,
+		render: _,
+		webgpu: T
+	},
+	rg16snorm: {
+		f: h,
+		render: _,
+		webgpu: T
+	},
+	"rgb16snorm-webgl": {
+		f: h,
+		render: !1
+	},
+	rgba16snorm: {
+		f: h,
+		render: _,
+		webgpu: T
+	},
+	r16uint: { webgpu: 515 },
+	rg16uint: { webgpu: 515 },
+	rgba16uint: { webgpu: C },
+	r16sint: { webgpu: 515 },
+	rg16sint: { webgpu: 515 },
+	rgba16sint: { webgpu: C },
+	r16float: {
+		render: f,
+		filter: "float16-filterable-webgl",
+		webgpu: 527
+	},
+	rg16float: {
+		render: f,
+		filter: y,
+		webgpu: 527
+	},
+	rgba16float: {
+		render: f,
+		filter: y,
+		webgpu: w
+	},
+	r32uint: { webgpu: C },
+	rg32uint: { webgpu: 16387 },
+	rgba32uint: { webgpu: C },
+	r32sint: { webgpu: C },
+	rg32sint: { webgpu: 16387 },
+	rgba32sint: { webgpu: C },
+	r32float: {
+		render: d,
+		filter: v,
+		webgpu: C
+	},
+	rg32float: {
+		render: !1,
+		filter: v,
+		webgpu: 16387
+	},
+	"rgb32float-webgl": {
+		render: d,
+		filter: v
+	},
+	rgba32float: {
+		render: d,
+		filter: v,
+		webgpu: C
+	},
+	"rgba4unorm-webgl": {
+		channels: "rgba",
+		bitsPerChannel: [
+			4,
+			4,
+			4,
+			4
+		],
+		packed: !0
+	},
+	"rgb565unorm-webgl": {
+		channels: "rgb",
+		bitsPerChannel: [
+			5,
+			6,
+			5,
+			0
+		],
+		packed: !0
+	},
+	"rgb5a1unorm-webgl": {
+		channels: "rgba",
+		bitsPerChannel: [
+			5,
+			5,
+			5,
+			1
+		],
+		packed: !0
+	},
+	rgb9e5ufloat: {
+		channels: "rgb",
+		packed: !0,
+		render: p,
+		webgpu: x
+	},
+	rg11b10ufloat: {
+		channels: "rgb",
+		bitsPerChannel: [
+			11,
+			11,
+			10,
+			0
+		],
+		packed: !0,
+		p: 1,
+		render: d,
+		webgpu: 517
+	},
+	rgb10a2unorm: {
+		channels: "rgba",
+		bitsPerChannel: [
+			10,
+			10,
+			10,
+			2
+		],
+		packed: !0,
+		p: 1,
+		webgpu: 527
+	},
+	rgb10a2uint: {
+		channels: "rgba",
+		bitsPerChannel: [
+			10,
+			10,
+			10,
+			2
+		],
+		packed: !0,
+		p: 1,
+		webgpu: 515
+	},
+	stencil8: {
+		attachment: "stencil",
+		bitsPerChannel: [
+			8,
+			0,
+			0,
+			0
+		],
+		dataType: "uint8",
+		webgpu: b
+	},
+	depth16unorm: {
+		attachment: "depth",
+		bitsPerChannel: [
+			16,
+			0,
+			0,
+			0
+		],
+		dataType: "uint16",
+		webgpu: b
+	},
+	depth24plus: {
+		attachment: "depth",
+		bitsPerChannel: [
+			24,
+			0,
+			0,
+			0
+		],
+		dataType: "uint32",
+		webgpu: b
+	},
+	depth32float: {
+		attachment: "depth",
+		bitsPerChannel: [
+			32,
+			0,
+			0,
+			0
+		],
+		dataType: "float32",
+		webgpu: b
+	},
+	"depth24plus-stencil8": {
+		attachment: "depth-stencil",
+		bitsPerChannel: [
+			24,
+			8,
+			0,
+			0
+		],
+		packed: !0,
+		webgpu: b
+	},
+	"depth32float-stencil8": {
+		attachment: "depth-stencil",
+		bitsPerChannel: [
+			32,
+			8,
+			0,
+			0
+		],
+		packed: !0,
+		f: "depth32float-stencil8",
+		webgpu: b
+	}
+}, A = {
+	"bc1-rgb-unorm-webgl": { f: a },
+	"bc1-rgb-unorm-srgb-webgl": { f: a },
+	"bc1-rgba-unorm": { f: a },
+	"bc1-rgba-unorm-srgb": { f: a },
+	"bc2-rgba-unorm": { f: a },
+	"bc2-rgba-unorm-srgb": { f: a },
+	"bc3-rgba-unorm": { f: a },
+	"bc3-rgba-unorm-srgb": { f: a },
+	"bc4-r-unorm": { f: a },
+	"bc4-r-snorm": { f: a },
+	"bc5-rg-unorm": { f: a },
+	"bc5-rg-snorm": { f: a },
+	"bc6h-rgb-ufloat": { f: a },
+	"bc6h-rgb-float": { f: a },
+	"bc7-rgba-unorm": { f: a },
+	"bc7-rgba-unorm-srgb": { f: a },
+	"etc2-rgb8unorm": { f: s },
+	"etc2-rgb8unorm-srgb": { f: s },
+	"etc2-rgb8a1unorm": { f: s },
+	"etc2-rgb8a1unorm-srgb": { f: s },
+	"etc2-rgba8unorm": { f: s },
+	"etc2-rgba8unorm-srgb": { f: s },
+	"eac-r11unorm": { f: s },
+	"eac-r11snorm": { f: s },
+	"eac-rg11unorm": { f: s },
+	"eac-rg11snorm": { f: s },
+	"astc-4x4-unorm": { f: o },
+	"astc-4x4-unorm-srgb": { f: o },
+	"astc-5x4-unorm": { f: o },
+	"astc-5x4-unorm-srgb": { f: o },
+	"astc-5x5-unorm": { f: o },
+	"astc-5x5-unorm-srgb": { f: o },
+	"astc-6x5-unorm": { f: o },
+	"astc-6x5-unorm-srgb": { f: o },
+	"astc-6x6-unorm": { f: o },
+	"astc-6x6-unorm-srgb": { f: o },
+	"astc-8x5-unorm": { f: o },
+	"astc-8x5-unorm-srgb": { f: o },
+	"astc-8x6-unorm": { f: o },
+	"astc-8x6-unorm-srgb": { f: o },
+	"astc-8x8-unorm": { f: o },
+	"astc-8x8-unorm-srgb": { f: o },
+	"astc-10x5-unorm": { f: o },
+	"astc-10x5-unorm-srgb": { f: o },
+	"astc-10x6-unorm": { f: o },
+	"astc-10x6-unorm-srgb": { f: o },
+	"astc-10x8-unorm": { f: o },
+	"astc-10x8-unorm-srgb": { f: o },
+	"astc-10x10-unorm": { f: o },
+	"astc-10x10-unorm-srgb": { f: o },
+	"astc-12x10-unorm": { f: o },
+	"astc-12x10-unorm-srgb": { f: o },
+	"astc-12x12-unorm": { f: o },
+	"astc-12x12-unorm-srgb": { f: o },
+	"pvrtc-rgb4unorm-webgl": { f: l },
+	"pvrtc-rgba4unorm-webgl": { f: l },
+	"pvrtc-rgb2unorm-webgl": { f: l },
+	"pvrtc-rgba2unorm-webgl": { f: l },
+	"etc1-rbg-unorm-webgl": { f: c },
+	"atc-rgb-unorm-webgl": { f: u },
+	"atc-rgba-unorm-webgl": { f: u },
+	"atc-rgbai-unorm-webgl": { f: u }
+}, j = {
+	...k,
+	...A
+}, M = /^(r|rg|rgb|rgba|bgra)([0-9]*)([a-z]*)(-srgb)?(-webgl)?$/, N = [
+	"rgb",
+	"rgba",
+	"bgra"
+], P = ["depth", "stencil"], F = 5, I = [
+	"bc1",
+	"bc2",
+	"bc3",
+	"bc4",
+	"bc5",
+	"bc6",
+	"bc7",
+	"etc1",
+	"etc2",
+	"eac",
+	"atc",
+	"astc",
+	"pvrtc"
+], L = new class {
+	isColor(e) {
+		return N.some((t) => e.startsWith(t));
+	}
+	isDepthStencil(e) {
+		return P.some((t) => e.startsWith(t));
+	}
+	isCompressed(e) {
+		return I.some((t) => e.startsWith(t));
+	}
+	getInfo(e) {
+		return B(e);
+	}
+	getCapabilities(e) {
+		return z(e);
+	}
+	getWebGPUCapabilities(e) {
+		let t = D(e);
+		return t.webgpu === void 0 ? this.isCompressed(e) && !e.endsWith("-webgl") ? F : 0 : t.webgpu;
+	}
+	computeMemoryLayout(e) {
+		return R(e);
+	}
+}();
+function R({ format: e, width: t, height: n, depth: r, byteAlignment: i }) {
+	let { bytesPerPixel: a, bytesPerBlock: o = a, blockWidth: s = 1, blockHeight: c = 1, compressed: l = !1 } = L.getInfo(e), u = l ? Math.ceil(t / s) : t, d = l ? Math.ceil(n / c) : n, f = u * o, p = Math.ceil(f / i) * i, m = d, h = p * m * r;
+	return {
+		bytesPerPixel: a,
+		bytesPerRow: p,
+		rowsPerImage: m,
+		depthOrArrayLayers: r,
+		bytesPerImage: p * m,
+		byteLength: h
+	};
+}
+function z(e) {
+	let t = D(e), n = {
+		format: e,
+		create: t.f ?? !0,
+		render: t.render ?? !0,
+		filter: t.filter ?? !0,
+		blend: t.blend ?? !0,
+		store: t.store ?? !0
+	}, r = B(e), i = e.startsWith("depth") || e.startsWith("stencil"), a = r?.signed, o = r?.integer, s = r?.webgl, c = !!r?.compressed;
+	return n.render &&= !i && !c, n.filter &&= !i && !a && !o && !s, n;
+}
+function B(e) {
+	let t = V(e);
+	if (L.isCompressed(e)) {
+		t.channels = "rgb", t.components = 3, t.bytesPerPixel = 1, t.srgb = !1, t.compressed = !0, t.bytesPerBlock = U(e);
+		let n = H(e);
+		n && (t.blockWidth = n.blockWidth, t.blockHeight = n.blockHeight);
+	}
+	let r = t.packed ? null : M.exec(e);
+	if (r) {
+		let [, i, a, o, s, c] = r, l = `${o}${a}`, u = n.getDataTypeInfo(l), d = u.byteLength * 8, f = i?.length ?? 1, p = [
+			d,
+			f >= 2 ? d : 0,
+			f >= 3 ? d : 0,
+			f >= 4 ? d : 0
+		];
+		t = {
+			format: e,
+			attachment: t.attachment,
+			dataType: u.signedType,
+			components: f,
+			channels: i,
+			integer: u.integer,
+			signed: u.signed,
+			normalized: u.normalized,
+			bitsPerChannel: p,
+			bytesPerPixel: u.byteLength * f,
+			packed: t.packed,
+			srgb: t.srgb
+		}, c === "-webgl" && (t.webgl = !0), s === "-srgb" && (t.srgb = !0);
+	}
+	return e.endsWith("-webgl") && (t.webgl = !0), e.endsWith("-srgb") && (t.srgb = !0), t;
+}
+function V(e) {
+	let t = { ...D(e) }, n = t.bytesPerPixel || 1, r = t.bitsPerChannel || [
+		8,
+		8,
+		8,
+		8
+	];
+	return delete t.bitsPerChannel, delete t.bytesPerPixel, delete t.f, delete t.render, delete t.filter, delete t.blend, delete t.store, delete t.webgpu, {
+		...t,
+		format: e,
+		attachment: t.attachment || "color",
+		channels: t.channels || "r",
+		components: t.components || t.channels?.length || 1,
+		bytesPerPixel: n,
+		bitsPerChannel: r,
+		dataType: t.dataType || "uint8",
+		srgb: t.srgb ?? !1,
+		packed: t.packed ?? !1,
+		webgl: t.webgl ?? !1,
+		integer: t.integer ?? !1,
+		signed: t.signed ?? !1,
+		normalized: t.normalized ?? !1,
+		compressed: t.compressed ?? !1
+	};
+}
+function H(e) {
+	let t = /.*-(\d+)x(\d+)-.*/.exec(e);
+	if (t) {
+		let [, e, n] = t;
+		return {
+			blockWidth: Number(e),
+			blockHeight: Number(n)
+		};
+	}
+	return e.startsWith("bc") || e.startsWith("etc1") || e.startsWith("etc2") || e.startsWith("eac") || e.startsWith("atc") || e.startsWith("pvrtc-rgb4") || e.startsWith("pvrtc-rgba4") ? {
+		blockWidth: 4,
+		blockHeight: 4
+	} : e.startsWith("pvrtc-rgb2") || e.startsWith("pvrtc-rgba2") ? {
+		blockWidth: 8,
+		blockHeight: 4
+	} : null;
+}
+function U(e) {
+	return e.startsWith("bc1") || e.startsWith("bc4") || e.startsWith("etc1") || e.startsWith("etc2-rgb8") || e.startsWith("etc2-rgb8a1") || e.startsWith("eac-r11") || e === "atc-rgb-unorm-webgl" ? 8 : e.startsWith("bc2") || e.startsWith("bc3") || e.startsWith("bc5") || e.startsWith("bc6h") || e.startsWith("bc7") || e.startsWith("etc2-rgba8") || e.startsWith("eac-rg11") || e.startsWith("astc") || e === "atc-rgba-unorm-webgl" || e === "atc-rgbai-unorm-webgl" ? 16 : e.startsWith("pvrtc") ? 8 : 16;
+}
+//#endregion
+//#region node_modules/@luma.gl/core/dist/adapter/resources/sampler.js
+var W = class e extends i {
+	static defaultProps = {
+		...i.defaultProps,
+		type: "color-sampler",
+		addressModeU: "clamp-to-edge",
+		addressModeV: "clamp-to-edge",
+		addressModeW: "clamp-to-edge",
+		magFilter: "nearest",
+		minFilter: "nearest",
+		mipmapFilter: "none",
+		lodMinClamp: 0,
+		lodMaxClamp: 32,
+		compare: "less-equal",
+		maxAnisotropy: 1
+	};
+	get [Symbol.toStringTag]() {
+		return "Sampler";
+	}
+	constructor(t, n) {
+		n = e.normalizeProps(t, n), super(t, n, e.defaultProps);
+	}
+	static normalizeProps(e, t) {
+		return t;
+	}
+}, G = {
+	"1d": "1d",
+	"2d": "2d",
+	"2d-array": "2d",
+	cube: "2d",
+	"cube-array": "2d",
+	"3d": "3d"
+}, K = class t extends i {
+	static SAMPLE = 4;
+	static STORAGE = 8;
+	static RENDER = 16;
+	static COPY_SRC = 1;
+	static COPY_DST = 2;
+	static TEXTURE = 4;
+	static RENDER_ATTACHMENT = 16;
+	dimension;
+	baseDimension;
+	format;
+	width;
+	height;
+	depth;
+	mipLevels;
+	samples;
+	byteAlignment;
+	ready = Promise.resolve(this);
+	isReady = !0;
+	updateTimestamp;
+	get [Symbol.toStringTag]() {
+		return "Texture";
+	}
+	toString() {
+		return `Texture(${this.id},${this.format},${this.width}x${this.height})`;
+	}
+	constructor(n, r, i) {
+		if (r = t.normalizeProps(n, r), super(n, r, t.defaultProps), this.dimension = this.props.dimension, this.baseDimension = G[this.dimension], this.format = this.props.format, this.width = this.props.width, this.height = this.props.height, this.depth = this.props.depth, this.mipLevels = this.props.mipLevels, this.samples = this.props.samples || 1, this.dimension === "cube" && (this.depth = 6), this.props.width === void 0 || this.props.height === void 0) {
+			if (n.isExternalImage(r.data)) {
+				let e = n.getExternalImageSize(r.data);
+				this.width = e?.width || 1, this.height = e?.height || 1;
+			} else this.width = 1, this.height = 1, (this.props.width === void 0 || this.props.height === void 0) && e.warn(`${this} created with undefined width or height. This is deprecated. Use DynamicTexture instead.`)();
+		}
+		this.byteAlignment = i?.byteAlignment || 1, this.updateTimestamp = n.incrementTimestamp();
+	}
+	clone(e) {
+		return this.device.createTexture({
+			...this.props,
+			...e
+		});
+	}
+	setSampler(e) {
+		this.sampler = e instanceof W ? e : this.device.createSampler(e);
+	}
+	copyImageData(e) {
+		let { data: t, depth: n, ...r } = e;
+		this.writeData(t, {
+			...r,
+			depthOrArrayLayers: r.depthOrArrayLayers ?? n
+		});
+	}
+	computeMemoryLayout(e = {}) {
+		let { width: t = this.width, height: n = this.height, depthOrArrayLayers: r = this.depth } = this._normalizeTextureReadOptions(e), { format: i, byteAlignment: a } = this;
+		return L.computeMemoryLayout({
+			format: i,
+			width: t,
+			height: n,
+			depth: r,
+			byteAlignment: a
+		});
+	}
+	readBuffer(e, t) {
+		throw Error("readBuffer not implemented");
+	}
+	readDataAsync(e) {
+		throw Error("readBuffer not implemented");
+	}
+	writeBuffer(e, t) {
+		throw Error("readBuffer not implemented");
+	}
+	writeData(e, t) {
+		throw Error("readBuffer not implemented");
+	}
+	readDataSyncWebGL(e) {
+		throw Error("readDataSyncWebGL not available");
+	}
+	generateMipmapsWebGL() {
+		throw Error("generateMipmapsWebGL not available");
+	}
+	static normalizeProps(e, t) {
+		let n = { ...t }, { width: r, height: i } = n;
+		return typeof r == "number" && (n.width = Math.max(1, Math.ceil(r))), typeof i == "number" && (n.height = Math.max(1, Math.ceil(i))), n;
+	}
+	_initializeData(e) {
+		this.device.isExternalImage(e) ? this.copyExternalImage({
+			image: e,
+			width: this.width,
+			height: this.height,
+			depth: this.depth,
+			mipLevel: 0,
+			x: 0,
+			y: 0,
+			z: 0,
+			aspect: "all",
+			colorSpace: "srgb",
+			premultipliedAlpha: !1,
+			flipY: !1
+		}) : e && this.copyImageData({
+			data: e,
+			mipLevel: 0,
+			x: 0,
+			y: 0,
+			z: 0,
+			aspect: "all"
+		});
+	}
+	_normalizeCopyImageDataOptions(e) {
+		let { data: t, depth: n, ...r } = e, i = this._normalizeTextureWriteOptions({
+			...r,
+			depthOrArrayLayers: r.depthOrArrayLayers ?? n
+		});
+		return {
+			data: t,
+			depth: i.depthOrArrayLayers,
+			...i
+		};
+	}
+	_normalizeCopyExternalImageOptions(e) {
+		let n = t._omitUndefined(e), r = n.mipLevel ?? 0, i = this._getMipLevelSize(r), a = this.device.getExternalImageSize(e.image), o = {
+			...t.defaultCopyExternalImageOptions,
+			...i,
+			...a,
+			...n
+		};
+		return o.width = Math.min(o.width, i.width - o.x), o.height = Math.min(o.height, i.height - o.y), o.depth = Math.min(o.depth, i.depthOrArrayLayers - o.z), o;
+	}
+	_normalizeCopyElementImageOptions(e) {
+		let n = t._omitUndefined(e), r = n.mipLevel ?? 0, i = this._getMipLevelSize(r), a = {
+			...t.defaultCopyElementImageOptions,
+			...i,
+			...n
+		};
+		return a.width = Math.min(a.width, i.width - a.x), a.height = Math.min(a.height, i.height - a.y), a.depth = Math.min(a.depth, i.depthOrArrayLayers - a.z), a;
+	}
+	_normalizeTextureReadOptions(e) {
+		let n = t._omitUndefined(e), r = n.mipLevel ?? 0, i = this._getMipLevelSize(r), a = {
+			...t.defaultTextureReadOptions,
+			...i,
+			...n
+		};
+		return a.width = Math.min(a.width, i.width - a.x), a.height = Math.min(a.height, i.height - a.y), a.depthOrArrayLayers = Math.min(a.depthOrArrayLayers, i.depthOrArrayLayers - a.z), a;
+	}
+	_getSupportedColorReadOptions(e) {
+		let t = this._normalizeTextureReadOptions(e), n = L.getInfo(this.format);
+		switch (this._validateColorReadAspect(t), this._validateColorReadFormat(n), this.dimension) {
+			case "2d":
+			case "cube":
+			case "cube-array":
+			case "2d-array":
+			case "3d": return t;
+			default: throw Error(`${this} color readback does not support ${this.dimension} textures`);
+		}
+	}
+	_validateColorReadAspect(e) {
+		if (e.aspect !== "all") throw Error(`${this} color readback only supports aspect 'all'`);
+	}
+	_validateColorReadFormat(e) {
+		if (e.compressed) throw Error(`${this} color readback does not support compressed formats (${this.format})`);
+		switch (e.attachment) {
+			case "color": return;
+			case "depth": throw Error(`${this} color readback does not support depth formats (${this.format})`);
+			case "stencil": throw Error(`${this} color readback does not support stencil formats (${this.format})`);
+			case "depth-stencil": throw Error(`${this} color readback does not support depth-stencil formats (${this.format})`);
+			default: throw Error(`${this} color readback does not support format ${this.format}`);
+		}
+	}
+	_normalizeTextureWriteOptions(e) {
+		let n = t._omitUndefined(e), r = n.mipLevel ?? 0, i = this._getMipLevelSize(r), a = {
+			...t.defaultTextureWriteOptions,
+			...i,
+			...n
+		};
+		a.width = Math.min(a.width, i.width - a.x), a.height = Math.min(a.height, i.height - a.y), a.depthOrArrayLayers = Math.min(a.depthOrArrayLayers, i.depthOrArrayLayers - a.z);
+		let o = L.computeMemoryLayout({
+			format: this.format,
+			width: a.width,
+			height: a.height,
+			depth: a.depthOrArrayLayers,
+			byteAlignment: this.byteAlignment
+		}), s = o.bytesPerPixel * a.width;
+		if (a.bytesPerRow = n.bytesPerRow ?? o.bytesPerRow, a.rowsPerImage = n.rowsPerImage ?? a.height, a.bytesPerRow < s) throw Error(`bytesPerRow (${a.bytesPerRow}) must be at least ${s} for ${this.format}`);
+		if (a.rowsPerImage < a.height) throw Error(`rowsPerImage (${a.rowsPerImage}) must be at least ${a.height} for ${this.format}`);
+		let c = this.device.getTextureFormatInfo(this.format).bytesPerPixel;
+		if (c && a.bytesPerRow % c !== 0) throw Error(`bytesPerRow (${a.bytesPerRow}) must be a multiple of bytesPerPixel (${c}) for ${this.format}`);
+		return a;
+	}
+	_getMipLevelSize(e) {
+		return {
+			width: Math.max(1, this.width >> e),
+			height: this.baseDimension === "1d" ? 1 : Math.max(1, this.height >> e),
+			depthOrArrayLayers: this.dimension === "3d" ? Math.max(1, this.depth >> e) : this.depth
+		};
+	}
+	getAllocatedByteLength() {
+		let e = 0;
+		for (let t = 0; t < this.mipLevels; t++) {
+			let { width: n, height: r, depthOrArrayLayers: i } = this._getMipLevelSize(t);
+			e += L.computeMemoryLayout({
+				format: this.format,
+				width: n,
+				height: r,
+				depth: i,
+				byteAlignment: 1
+			}).byteLength;
+		}
+		return e * this.samples;
+	}
+	static _omitUndefined(e) {
+		return Object.fromEntries(Object.entries(e).filter(([, e]) => e !== void 0));
+	}
+	static defaultProps = {
+		...i.defaultProps,
+		data: null,
+		dimension: "2d",
+		format: "rgba8unorm",
+		usage: t.SAMPLE | t.RENDER | t.COPY_DST,
+		width: void 0,
+		height: void 0,
+		depth: 1,
+		mipLevels: 1,
+		samples: void 0,
+		sampler: {},
+		view: void 0
+	};
+	static defaultCopyDataOptions = {
+		data: void 0,
+		byteOffset: 0,
+		bytesPerRow: void 0,
+		rowsPerImage: void 0,
+		width: void 0,
+		height: void 0,
+		depthOrArrayLayers: void 0,
+		depth: 1,
+		mipLevel: 0,
+		x: 0,
+		y: 0,
+		z: 0,
+		aspect: "all"
+	};
+	static defaultCopyExternalImageOptions = {
+		image: void 0,
+		sourceX: 0,
+		sourceY: 0,
+		width: void 0,
+		height: void 0,
+		depth: 1,
+		mipLevel: 0,
+		x: 0,
+		y: 0,
+		z: 0,
+		aspect: "all",
+		colorSpace: "srgb",
+		premultipliedAlpha: !1,
+		flipY: !1
+	};
+	static defaultCopyElementImageOptions = {
+		element: void 0,
+		width: void 0,
+		height: void 0,
+		sourceX: 0,
+		sourceY: 0,
+		sourceWidth: void 0,
+		sourceHeight: void 0,
+		depth: 1,
+		mipLevel: 0,
+		x: 0,
+		y: 0,
+		z: 0,
+		aspect: "all",
+		colorSpace: "srgb",
+		premultipliedAlpha: !1,
+		flipY: !1
+	};
+	static defaultTextureReadOptions = {
+		x: 0,
+		y: 0,
+		z: 0,
+		width: void 0,
+		height: void 0,
+		depthOrArrayLayers: 1,
+		mipLevel: 0,
+		aspect: "all"
+	};
+	static defaultTextureWriteOptions = {
+		byteOffset: 0,
+		bytesPerRow: void 0,
+		rowsPerImage: void 0,
+		x: 0,
+		y: 0,
+		z: 0,
+		width: void 0,
+		height: void 0,
+		depthOrArrayLayers: 1,
+		mipLevel: 0,
+		aspect: "all"
+	};
+}, q = class e extends i {
+	get [Symbol.toStringTag]() {
+		return "TextureView";
+	}
+	constructor(t, n) {
+		super(t, n, e.defaultProps);
+	}
+	static defaultProps = {
+		...i.defaultProps,
+		format: void 0,
+		dimension: void 0,
+		aspect: "all",
+		baseMipLevel: 0,
+		mipLevelCount: void 0,
+		baseArrayLayer: 0,
+		arrayLayerCount: void 0
+	};
+};
+//#endregion
+//#region node_modules/@luma.gl/core/dist/adapter-utils/bind-groups.js
+function J(t, n, r) {
+	let i = t.bindings.find((e) => e.name === n || `${e.name.toLocaleLowerCase()}uniforms` === n.toLocaleLowerCase());
+	return !i && !r?.ignoreWarnings && e.warn(`Binding ${n} not set: Not found in shader layout.`)(), i || null;
+}
+function Y(e, t) {
+	if (!t) return {};
+	if (Z(t)) return Object.fromEntries(Object.entries(t).map(([e, t]) => [Number(e), { ...t }]));
+	let n = {};
+	for (let [r, i] of Object.entries(t)) {
+		let t = J(e, r)?.group ?? 0;
+		n[t] ||= {}, n[t][r] = i;
+	}
+	return n;
+}
+function X(e) {
+	let t = {};
+	for (let n of Object.values(e)) Object.assign(t, n);
+	return t;
+}
+function Z(e) {
+	let t = Object.keys(e);
+	return t.length > 0 && t.every((e) => /^\d+$/.test(e));
+}
+//#endregion
+//#region node_modules/@luma.gl/core/dist/adapter-utils/buffer-layout-utils.js
+function Q(e) {
+	return e.attributes ? e.attributes.map((e) => e.attribute) : [e.name];
+}
+function $(e) {
+	return Object.fromEntries(e.attributes.map((e) => [e.name, e.location]));
+}
+function ee(e) {
+	let t = Infinity;
+	for (let n of e) n !== void 0 && (t = Math.min(t, n));
+	return t;
+}
+function te(n, i, a) {
+	ne(i);
+	let o = /* @__PURE__ */ new Map();
+	for (let e of i) {
+		let t = re(e);
+		if (e.attributes) for (let n of e.attributes) o.has(n.attribute) || o.set(n.attribute, {
+			bufferName: e.name,
+			stepMode: e.stepMode,
+			vertexFormat: n.format,
+			byteOffset: n.byteOffset,
+			byteStride: t
+		});
+		else e.format && !o.has(e.name) && o.set(e.name, {
+			bufferName: e.name,
+			stepMode: e.stepMode,
+			vertexFormat: e.format,
+			byteOffset: 0,
+			byteStride: t
+		});
+	}
+	return n.attributes.map((n) => {
+		let i = o.get(n.name);
+		!i && a?.warnOnMissingBufferLayout && e.warn(`layout for attribute "${n.name}" not present in buffer layout`)();
+		let s = r.getAttributeShaderTypeInfo(n.type), c = i?.vertexFormat || t.getCompatibleVertexFormat(s);
+		return {
+			attributeName: n.name,
+			bufferName: i?.bufferName || n.name,
+			location: n.location,
+			vertexFormat: c,
+			byteOffset: i?.byteOffset ?? 0,
+			byteStride: i?.byteStride ?? t.getVertexFormatInfo(c).byteLength,
+			stepMode: i?.stepMode || n.stepMode || (n.name.startsWith("instance") ? "instance" : "vertex")
+		};
+	}).sort((e, t) => e.location - t.location);
+}
+function ne(t) {
+	for (let n of t) (n.attributes && n.format || !n.attributes && !n.format) && e.warn(`BufferLayout ${n.name} must have either 'attributes' or 'format' field`)();
+}
+function re(e) {
+	if (typeof e.byteStride == "number") return e.byteStride;
+	if (e.attributes) {
+		let n = 0;
+		for (let r of e.attributes) n += t.getVertexFormatInfo(r.format).byteLength;
+		return n;
+	}
+	return t.getVertexFormatInfo(e.format).byteLength;
+}
+//#endregion
+//#region node_modules/@luma.gl/core/dist/adapter-utils/get-attribute-from-layouts.js
+function ie(e, t) {
+	let n = {}, r = te(e, t, { warnOnMissingBufferLayout: !0 });
+	for (let t of r) {
+		let r = ae(e, t);
+		n[t.attributeName] = r;
+	}
+	return n;
+}
+function ae(e, n) {
+	let i = oe(e, n.attributeName), a = r.getAttributeShaderTypeInfo(i.type), o = n.vertexFormat, s = t.getVertexFormatInfo(o);
+	return {
+		attributeName: n.attributeName,
+		bufferName: n.bufferName,
+		location: i.location,
+		shaderType: i.type,
+		primitiveType: a.primitiveType,
+		shaderComponents: a.components,
+		vertexFormat: o,
+		bufferDataType: s.type,
+		bufferComponents: s.components,
+		normalized: s.normalized,
+		integer: a.integer,
+		stepMode: n.stepMode,
+		byteOffset: n.byteOffset,
+		byteStride: n.byteStride
+	};
+}
+function oe(t, n) {
+	let r = t.attributes.find((e) => e.name === n);
+	return r || e.warn(`shader layout attribute "${n}" not present in shader`)(), r || null;
+}
+//#endregion
+export { X as a, q as c, L as d, O as f, $ as i, K as l, Q as n, J as o, ee as r, Y as s, ie as t, W as u };