typegpu 0.10.2 → 0.11.0

package/data/autoStruct.d.ts

@@ -1,3 +1 @@
-import "./snippet.js";
-import "../types.js";
-import "./wgslTypes.js";
+export { };

package/data/autoStruct.js

@@ -2,7 +2,6 @@ import { $internal, $resolve } from "../shared/symbols.js";
 import { getName, setName } from "../shared/meta.js";
 import { isValidProp } from "../nameRegistry.js";
 import { createIoSchema } from "../core/function/ioSchema.js";
-
 //#region src/data/autoStruct.ts
 /**
 * A requirement for the generated struct is that non-builtin properties need to
@@ -78,6 +77,5 @@ var AutoStruct = class {
 };
 AutoStruct.prototype[$internal] = {};
 AutoStruct.prototype.type = "auto-struct";
-
 //#endregion
-export { AutoStruct };
+export { AutoStruct };

package/data/compiledIO.js

@@ -5,7 +5,6 @@ import { alignmentOf } from "./alignmentOf.js";
 import { roundUp } from "../mathUtils.js";
 import { sizeOf } from "./sizeOf.js";
 import { offsetsForProps } from "./offsets.js";
-
 //#region src/data/compiledIO.ts
 const EVAL_ALLOWED_IN_ENV = (() => {
 	try {
@@ -115,117 +114,115 @@ const specialPackedFormats = {
 	"unorm8x4-bgra": {
 		writeFunction: "setUint8",
 		generator: (offsetExpr, valueExpr) => {
-			const bgraComponents = [
+			return [
 				"z",
 				"y",
 				"x",
 				"w"
-			];
-			let code = "";
-			for (let idx = 0; idx < 4; idx++) code += `output.setUint8((${offsetExpr} + ${idx}), Math.round(${valueExpr}.${bgraComponents[idx]} * 255), littleEndian);\n`;
-			return code;
+			].map((c, idx) => `output.setUint8((${offsetExpr} + ${idx}), Math.round(${valueExpr}.${c} * 255), littleEndian);\n`).join("");
 		}
 	}
 };
-function buildWriter(node, offsetExpr, valueExpr, depth = 0) {
-	const loopVar = [
-		"i",
-		"j",
-		"k"
-	][depth] || `i${depth}`;
-	if (isAtomic(node) || isDecorated(node)) return buildWriter(node.inner, offsetExpr, valueExpr, depth);
-	if (isWgslStruct(node) || isUnstruct(node)) {
-		const propOffsets = offsetsForProps(node);
-		let code = "";
-		for (const [key, propOffset] of Object.entries(propOffsets)) {
+function buildWriter(node, offsetExpr, valueExpr, depth = 0, partial = false) {
+	const emitWrite = (writeFunc, addr, value) => partial ? `if (${addr} < endOffset) { output.${writeFunc}(${addr}, ${value}, littleEndian); }\n` : `output.${writeFunc}(${addr}, ${value}, littleEndian);\n`;
+	const emitBlock = (addr, block) => partial ? `if (${addr} < endOffset) {\n${block}}\n` : block;
+	function go(node, offsetExpr, valueExpr, depth) {
+		const loopVar = [
+			"i",
+			"j",
+			"k"
+		][depth] || `i${depth}`;
+		if (isAtomic(node) || isDecorated(node)) return go(node.inner, offsetExpr, valueExpr, depth);
+		if (isWgslStruct(node) || isUnstruct(node)) return Object.entries(offsetsForProps(node)).map(([key, propOffset]) => {
 			const subSchema = node.propTypes[key];
-			if (!subSchema) continue;
-			code += buildWriter(subSchema, `(${offsetExpr} + ${propOffset.offset})`, `${valueExpr}.${key}`, depth);
+			return subSchema ? go(subSchema, `(${offsetExpr} + ${propOffset.offset})`, `${valueExpr}.${key}`, depth) : "";
+		}).join("");
+		if (isWgslArray(node) || isDisarray(node)) {
+			const elementSize = roundUp(sizeOf(node.elementType), alignmentOf(node));
+			const totalSize = node.elementCount * elementSize;
+			const copyLen = partial ? `Math.min(${valueExpr}.byteLength, Math.max(0, endOffset - (${offsetExpr})))` : `Math.min(${valueExpr}.byteLength, ${totalSize})`;
+			let code = `if (ArrayBuffer.isView(${valueExpr})) {\n`;
+			code += `  new Uint8Array(output.buffer).set(new Uint8Array(${valueExpr}.buffer, ${valueExpr}.byteOffset, ${copyLen}), output.byteOffset + (${offsetExpr}));\n`;
+			code += `} else {\n`;
+			code += `for (let ${loopVar} = 0; ${loopVar} < ${node.elementCount}; ${loopVar}++) {\n`;
+			if (partial) code += `if ((${offsetExpr} + ${loopVar} * ${elementSize}) >= endOffset) return;\n`;
+			code += go(node.elementType, `(${offsetExpr} + ${loopVar} * ${elementSize})`, `${valueExpr}[${loopVar}]`, depth + 1);
+			code += "}\n";
+			code += "}\n";
+			return code;
 		}
-		return code;
-	}
-	if (isWgslArray(node) || isDisarray(node)) {
-		const elementSize = roundUp(sizeOf(node.elementType), alignmentOf(node));
-		let code = "";
-		code += `for (let ${loopVar} = 0; ${loopVar} < ${node.elementCount}; ${loopVar}++) {\n`;
-		code += buildWriter(node.elementType, `(${offsetExpr} + ${loopVar} * ${elementSize})`, `${valueExpr}[${loopVar}]`, depth + 1);
-		code += "}\n";
-		return code;
-	}
-	if (isVec(node)) {
-		if (isVecBool(node)) throw new Error("Compiled writers do not support boolean vectors");
-		const primitive = typeToPrimitive[node.type];
-		let code = "";
-		const writeFunc = primitiveToWriteFunction[primitive];
-		const components = [
-			"x",
-			"y",
-			"z",
-			"w"
-		];
-		for (let i = 0; i < node.componentCount; i++) code += `output.${writeFunc}((${offsetExpr} + ${i * 4}), ${valueExpr}.${components[i]}, littleEndian);\n`;
-		return code;
-	}
-	if (isMat(node)) {
-		const writeFunc = primitiveToWriteFunction[typeToPrimitive[node.type]];
-		const matSize = isMat2x2f(node) ? 2 : isMat3x3f(node) ? 3 : 4;
-		const elementCount = matSize * matSize;
-		const rowStride = roundUp(matSize * 4, 8);
-		let code = "";
-		for (let idx = 0; idx < elementCount; idx++) {
-			const colIndex = Math.floor(idx / matSize);
-			const rowIndex = idx % matSize;
-			const byteOffset = colIndex * rowStride + rowIndex * 4;
-			code += `output.${writeFunc}((${offsetExpr} + ${byteOffset}), ${valueExpr}.columns[${colIndex}].${[
+		if (isVec(node)) {
+			if (isVecBool(node)) throw new Error("Compiled writers do not support boolean vectors");
+			const primitive = typeToPrimitive[node.type];
+			const componentSize = sizeOf(node.primitive);
+			const writeFunc = primitiveToWriteFunction[primitive];
+			return Array.from({ length: node.componentCount }, (_, i) => emitWrite(writeFunc, `(${offsetExpr} + ${i * componentSize})`, `${valueExpr}[${i}]`)).join("");
+		}
+		if (isMat(node)) {
+			const writeFunc = primitiveToWriteFunction[typeToPrimitive[node.type]];
+			const matSize = isMat2x2f(node) ? 2 : isMat3x3f(node) ? 3 : 4;
+			const rowStride = roundUp(matSize * 4, 8);
+			const components = [
 				"x",
 				"y",
 				"z",
 				"w"
-			][rowIndex]}, littleEndian);\n`;
+			];
+			const wgslElementStride = rowStride / 4;
+			return Array.from({ length: matSize * matSize }, (_, idx) => {
+				const col = Math.floor(idx / matSize);
+				const row = idx % matSize;
+				const packedIndex = col * matSize + row;
+				const wgslIndex = col * wgslElementStride + row;
+				return emitWrite(writeFunc, `(${offsetExpr} + ${col * rowStride + row * 4})`, `ArrayBuffer.isView(${valueExpr}) ? ${valueExpr}[${wgslIndex}] : Array.isArray(${valueExpr}) ? ${valueExpr}[${packedIndex}] : ${valueExpr}.columns[${col}].${components[row]}`);
+			}).join("");
 		}
-		return code;
-	}
-	if (isPackedData(node)) {
-		const formatName = node.type;
-		if (formatName in specialPackedFormats) return specialPackedFormats[formatName].generator(offsetExpr, valueExpr);
-		const primitive = vertexFormatToPrimitive[formatName];
-		const writeFunc = primitiveToWriteFunction[primitive];
-		const wgslType = formatToWGSLType[formatName];
-		const componentCount = isVec(wgslType) ? wgslType.componentCount : 1;
-		const componentSize = primitive === "u8" || primitive === "i8" ? 1 : primitive === "u16" || primitive === "i16" || primitive === "f16" ? 2 : 4;
-		const components = [
-			"x",
-			"y",
-			"z",
-			"w"
-		];
-		const transform = vertexFormatValueTransform[formatName];
-		let code = "";
-		for (let idx = 0; idx < componentCount; idx++) {
-			const accessor = componentCount === 1 ? valueExpr : `${valueExpr}.${components[idx]}`;
-			const value = transform ? transform(accessor) : accessor;
-			code += `output.${writeFunc}((${offsetExpr} + ${idx * componentSize}), ${value}, littleEndian);\n`;
+		if (isPackedData(node)) {
+			const formatName = node.type;
+			if (formatName in specialPackedFormats) {
+				const handler = specialPackedFormats[formatName];
+				return emitBlock(`(${offsetExpr})`, handler.generator(offsetExpr, valueExpr));
+			}
+			const primitive = vertexFormatToPrimitive[formatName];
+			const writeFunc = primitiveToWriteFunction[primitive];
+			const wgslType = formatToWGSLType[formatName];
+			const componentCount = isVec(wgslType) ? wgslType.componentCount : 1;
+			const componentSize = primitive === "u8" || primitive === "i8" ? 1 : primitive === "u16" || primitive === "i16" || primitive === "f16" ? 2 : 4;
+			const components = [
+				"x",
+				"y",
+				"z",
+				"w"
+			];
+			const transform = vertexFormatValueTransform[formatName];
+			return Array.from({ length: componentCount }, (_, idx) => {
+				const accessor = componentCount === 1 ? valueExpr : `${valueExpr}.${components[idx]}`;
+				const value = transform ? transform(accessor) : accessor;
+				return emitWrite(writeFunc, `(${offsetExpr} + ${idx * componentSize})`, value);
+			}).join("");
 		}
-		return code;
+		if (!Object.hasOwn(typeToPrimitive, node.type)) throw new Error(`Primitive ${node.type} is unsupported by compiled writer`);
+		const primitive = typeToPrimitive[node.type];
+		return emitWrite(primitiveToWriteFunction[primitive], offsetExpr, valueExpr);
 	}
-	if (!Object.hasOwn(typeToPrimitive, node.type)) throw new Error(`Primitive ${node.type} is unsupported by compiled writer`);
-	return `output.${primitiveToWriteFunction[typeToPrimitive[node.type]]}(${offsetExpr}, ${valueExpr}, littleEndian);\n`;
+	return go(node, offsetExpr, valueExpr, depth);
 }
-function getCompiledWriterForSchema(schema) {
+function getCompiledWriter(schema) {
 	if (!EVAL_ALLOWED_IN_ENV) {
 		console.warn("This environment does not allow eval - using default writer as fallback");
 		return;
 	}
-	if (compiledWriters.has(schema)) return compiledWriters.get(schema);
+	const cached = compiledWriters.get(schema);
+	if (cached) return cached;
 	try {
-		const body = buildWriter(schema, "offset", "value", 0);
-		const fn = new Function("output", "offset", "value", "littleEndian=true", body);
+		const fullBody = buildWriter(schema, "offset", "value", 0, false);
+		const body = `if (offset > 0 || endOffset < output.byteLength) {\n${buildWriter(schema, "offset", "value", 0, true)}} else {\n${fullBody}}\n`;
+		const fn = new Function("output", "offset", "value", "littleEndian=true", "endOffset=output.byteLength", body);
 		compiledWriters.set(schema, fn);
 		return fn;
 	} catch (error) {
 		console.warn(`Failed to compile writer for schema: ${schema}\nReason: ${error instanceof Error ? error.message : String(error)}\nFalling back to default writer`);
 	}
 }
-
 //#endregion
-export { getCompiledWriterForSchema };
+export { getCompiledWriter };

package/data/dataIO.js

@@ -3,7 +3,6 @@ import { alignmentOf, customAlignmentOf } from "./alignmentOf.js";
 import { sizeOf } from "./sizeOf.js";
 import { mat2x2f, mat3x3f, mat4x4f } from "./matrix.js";
 import alignIO from "./alignIO.js";
-
 //#region src/data/dataIO.ts
 const dataWriters = {
 	bool() {
@@ -25,70 +24,70 @@ const dataWriters = {
 		output.writeUint16(value);
 	},
 	vec2f(output, _, value) {
-		output.writeFloat32(value.x);
-		output.writeFloat32(value.y);
+		output.writeFloat32(value[0]);
+		output.writeFloat32(value[1]);
 	},
 	vec2h(output, _, value) {
-		output.writeFloat16(value.x);
-		output.writeFloat16(value.y);
+		output.writeFloat16(value[0]);
+		output.writeFloat16(value[1]);
 	},
 	vec2i(output, _, value) {
-		output.writeInt32(value.x);
-		output.writeInt32(value.y);
+		output.writeInt32(value[0]);
+		output.writeInt32(value[1]);
 	},
 	vec2u(output, _, value) {
-		output.writeUint32(value.x);
-		output.writeUint32(value.y);
+		output.writeUint32(value[0]);
+		output.writeUint32(value[1]);
 	},
 	"vec2<bool>"() {
 		throw new Error("Booleans are not host-shareable");
 	},
 	vec3f(output, _, value) {
-		output.writeFloat32(value.x);
-		output.writeFloat32(value.y);
-		output.writeFloat32(value.z);
+		output.writeFloat32(value[0]);
+		output.writeFloat32(value[1]);
+		output.writeFloat32(value[2]);
 	},
 	vec3h(output, _, value) {
-		output.writeFloat16(value.x);
-		output.writeFloat16(value.y);
-		output.writeFloat16(value.z);
+		output.writeFloat16(value[0]);
+		output.writeFloat16(value[1]);
+		output.writeFloat16(value[2]);
 	},
 	vec3i(output, _, value) {
-		output.writeInt32(value.x);
-		output.writeInt32(value.y);
-		output.writeInt32(value.z);
+		output.writeInt32(value[0]);
+		output.writeInt32(value[1]);
+		output.writeInt32(value[2]);
 	},
 	vec3u(output, _, value) {
-		output.writeUint32(value.x);
-		output.writeUint32(value.y);
-		output.writeUint32(value.z);
+		output.writeUint32(value[0]);
+		output.writeUint32(value[1]);
+		output.writeUint32(value[2]);
 	},
 	"vec3<bool>"() {
 		throw new Error("Booleans are not host-shareable");
 	},
 	vec4f(output, _, value) {
-		output.writeFloat32(value.x);
-		output.writeFloat32(value.y);
-		output.writeFloat32(value.z);
-		output.writeFloat32(value.w);
+		output.writeFloat32(value[0]);
+		output.writeFloat32(value[1]);
+		output.writeFloat32(value[2]);
+		output.writeFloat32(value[3]);
 	},
 	vec4h(output, _, value) {
-		output.writeFloat16(value.x);
-		output.writeFloat16(value.y);
-		output.writeFloat16(value.z);
-		output.writeFloat16(value.w);
+		output.writeFloat16(value[0]);
+		output.writeFloat16(value[1]);
+		output.writeFloat16(value[2]);
+		output.writeFloat16(value[3]);
 	},
 	vec4i(output, _, value) {
-		output.writeInt32(value.x);
-		output.writeInt32(value.y);
-		output.writeInt32(value.z);
-		output.writeInt32(value.w);
+		output.writeInt32(value[0]);
+		output.writeInt32(value[1]);
+		output.writeInt32(value[2]);
+		output.writeInt32(value[3]);
 	},
 	vec4u(output, _, value) {
-		output.writeUint32(value.x);
-		output.writeUint32(value.y);
-		output.writeUint32(value.z);
-		output.writeUint32(value.w);
+		output.writeUint32(value[0]);
+		output.writeUint32(value[1]);
+		output.writeUint32(value[2]);
+		output.writeUint32(value[3]);
 	},
 	"vec4<bool>"() {
 		throw new Error("Booleans are not host-shareable");
@@ -343,6 +342,15 @@ const dataWriters = {
 	}
 };
 function writeData(output, schema, value) {
+	if (ArrayBuffer.isView(value)) {
+		const src = value;
+		const expected = sizeOf(schema);
+		if (src.byteLength !== expected) console.warn(`TypedArray size mismatch: schema expects ${expected} bytes, got ${src.byteLength}. ` + (src.byteLength < expected ? "Data truncated." : "Excess ignored."));
+		const start = output.currentByteOffset;
+		output.writeSlice(new Uint8Array(src.buffer, src.byteOffset, Math.min(src.byteLength, expected)));
+		output.seekTo(start + expected);
+		return;
+	}
 	const writer = dataWriters[schema.type];
 	if (!writer) throw new Error(`Cannot write data of type '${schema.type}'.`);
 	writer(output, schema, value);
@@ -544,6 +552,5 @@ function readData(input, schema) {
 	if (!reader) throw new Error(`Cannot read data of type '${schema.type}'.`);
 	return reader(input, schema);
 }
-
 //#endregion
-export { readData, writeData };
+export { readData, writeData };

package/data/dataTypes.d.ts

@@ -1,13 +1,9 @@
 import { TgpuNamable } from "../shared/meta.js";
-import { $gpuRepr, $invalidSchemaReason, $memIdent, $repr, $reprPartial, $validVertexSchema } from "../shared/symbols.js";
+import { $gpuRepr, $inRepr, $invalidSchemaReason, $memIdent, $repr, $reprPartial, $reprPatch, $validVertexSchema } from "../shared/symbols.js";
 import { Prettify } from "../shared/utilityTypes.js";
-import "./sampler.js";
-import "./snippet.js";
 import { PackedData } from "./vertexFormatData.js";
-import "../types.js";
-import { AnyWgslData, BaseData } from "./wgslTypes.js";
-import "./texture.js";
-import { Infer, InferGPURecord, InferPartial, InferPartialRecord, InferRecord, IsValidVertexSchema, MemIdentityRecord } from "../shared/repr.js";
+import { AnyWgslData, BaseData, TypedArrayFor } from "./wgslTypes.js";
+import { Infer, InferGPURecord, InferInput, InferInputRecord, InferPartial, InferPartialRecord, InferPatch, InferPatchRecord, InferRecord, IsValidVertexSchema, MemIdentityRecord } from "../shared/repr.js";
 
 //#region src/data/dataTypes.d.ts
 /**
@@ -25,10 +21,12 @@ interface Disarray<out TElement extends BaseData = BaseData> extends BaseData {
   readonly elementCount: number;
   readonly elementType: TElement;
   readonly [$repr]: Infer<TElement>[];
+  readonly [$inRepr]: InferInput<TElement>[] | TypedArrayFor<TElement>;
   readonly [$reprPartial]: {
     idx: number;
     value: InferPartial<TElement>;
   }[] | undefined;
+  readonly [$reprPatch]: Record<number, InferPatch<TElement>> | InferInput<TElement>[] | TypedArrayFor<TElement> | undefined;
   readonly [$validVertexSchema]: IsValidVertexSchema<TElement>;
   readonly [$invalidSchemaReason]: 'Disarrays are not host-shareable, use arrays instead';
 }
@@ -46,9 +44,11 @@ interface Unstruct<out TProps extends Record<string, BaseData> = Record<string,
   readonly type: 'unstruct';
   readonly propTypes: TProps;
   readonly [$repr]: Prettify<InferRecord<TProps>>;
+  readonly [$inRepr]: Prettify<InferInputRecord<TProps>>;
   readonly [$gpuRepr]: Prettify<InferGPURecord<TProps>>;
   readonly [$memIdent]: Unstruct<Prettify<MemIdentityRecord<TProps>>>;
   readonly [$reprPartial]: Prettify<Partial<InferPartialRecord<TProps>>> | undefined;
+  readonly [$reprPatch]: Prettify<Partial<InferPatchRecord<TProps>>> | undefined;
   readonly [$validVertexSchema]: { [K in keyof TProps]: IsValidVertexSchema<TProps[K]> }[keyof TProps] extends true ? true : false;
   readonly [$invalidSchemaReason]: 'Unstructs are not host-shareable, use structs instead';
 }

package/data/dataTypes.js

@@ -2,7 +2,6 @@ import { $internal, isMarkedInternal } from "../shared/symbols.js";
 import { setName } from "../shared/meta.js";
 import { vertexFormats } from "../shared/vertexFormat.js";
 import { isAlignAttrib, isDecorated, isLocationAttrib, isPtr, isSizeAttrib, isWgslData } from "./wgslTypes.js";
-
 //#region src/data/dataTypes.ts
 /**
 * Runtime function to extract the inner data type from decorated types.
@@ -74,6 +73,9 @@ function isData(value) {
 }
 const UnknownData = Symbol("UNKNOWN");
 var InfixDispatch = class {
+	name;
+	lhs;
+	operator;
 	constructor(name, lhs, operator) {
 		this.name = name;
 		this.lhs = lhs;
@@ -81,17 +83,18 @@ var InfixDispatch = class {
 	}
 };
 var MatrixColumnsAccess = class {
+	matrix;
 	constructor(matrix) {
 		this.matrix = matrix;
 	}
 };
 var ConsoleLog = class {
 	[$internal] = true;
+	op;
 	constructor(op) {
 		this.op = op;
 		setName(this, "consoleLog");
 	}
 };
-
 //#endregion
-export { ConsoleLog, InfixDispatch, MatrixColumnsAccess, UnknownData, getCustomAlignment, getCustomLocation, getCustomSize, isData, isDisarray, isLooseData, isLooseDecorated, isUnstruct, undecorate, unptr };
+export { ConsoleLog, InfixDispatch, MatrixColumnsAccess, UnknownData, getCustomAlignment, getCustomLocation, getCustomSize, isData, isDisarray, isLooseData, isLooseDecorated, isUnstruct, undecorate, unptr };

package/data/deepEqual.js

@@ -1,6 +1,5 @@
 import { isAtomic, isDecorated, isPtr, isWgslArray, isWgslStruct } from "./wgslTypes.js";
 import { isDisarray, isLooseDecorated, isUnstruct } from "./dataTypes.js";
-
 //#region src/data/deepEqual.ts
 /**
 * Performs a deep comparison of two TypeGPU data schemas.
@@ -53,6 +52,5 @@ function deepEqual(a, b) {
 	}
 	return true;
 }
-
 //#endregion
-export { deepEqual };
+export { deepEqual };

package/data/disarray.d.ts

@@ -1,7 +1,5 @@
 import { AnyData, Disarray } from "./dataTypes.js";
 import { TgpuComptime } from "../core/function/comptime.js";
-import "../indexNamedExports.js";
-
 //#region src/data/disarray.d.ts
 interface DisarrayConstructor {
   <TElement extends AnyData>(elementType: TElement): (elementCount: number) => Disarray<TElement>;
@@ -29,6 +27,6 @@ interface DisarrayConstructor {
  * @param elementType The type of elements in the array.
  * @param elementCount The number of elements in the array.
  */
-declare const disarrayOf: TgpuComptime<DisarrayConstructor>;
+declare const disarrayOf: TgpuComptime;
 //#endregion
 export { disarrayOf };

package/data/disarray.js

@@ -1,7 +1,6 @@
 import { $internal } from "../shared/symbols.js";
 import { schemaCallWrapper } from "./schemaCallWrapper.js";
 import { comptime } from "../core/function/comptime.js";
-
 //#region src/data/disarray.ts
 /**
 * Creates an array schema that can be used to construct vertex buffers.
@@ -47,6 +46,5 @@ const DisarrayImpl = {
 		return `disarrayOf(${this.elementType}, ${this.elementCount})`;
 	}
 };
-
 //#endregion
-export { disarrayOf };
+export { disarrayOf };

package/data/getLongestContiguousPrefix.d.ts

@@ -1,4 +1,3 @@
-import "./wgslTypes.js";
 import { AnyData } from "./dataTypes.js";
 
 //#region src/data/getLongestContiguousPrefix.d.ts

package/data/getLongestContiguousPrefix.js

@@ -1,5 +1,4 @@
 import { getLayoutInfo } from "./schemaMemoryLayout.js";
-
 //#region src/data/getLongestContiguousPrefix.ts
 function getLongestContiguousPrefix(schema) {
 	return getLayoutInfo(schema, "longestContiguousPrefix");
@@ -10,6 +9,5 @@ function getLongestContiguousPrefix(schema) {
 function PUBLIC_getLongestContiguousPrefix(schema) {
 	return getLongestContiguousPrefix(schema);
 }
-
 //#endregion
-export { PUBLIC_getLongestContiguousPrefix, getLongestContiguousPrefix };
+export { PUBLIC_getLongestContiguousPrefix, getLongestContiguousPrefix };

package/data/index.d.ts

@@ -6,7 +6,7 @@ import { FormatToAcceptedData, FormatToWGSLType, PackedData, TgpuVertexFormatDat
 import { _ref } from "./ref.js";
 import { Align, AnyVecInstance, AnyWgslData, AnyWgslStruct, Atomic, BaseData, Bool, Builtin, Decorated, F16, F32, I32, Interpolate, Location, Mat2x2f, Mat3x3f, Mat4x4f, Ptr, Size, StorableData, U16, U32, Vec2b, Vec2f, Vec2h, Vec2i, Vec2u, Vec3b, Vec3f, Vec3h, Vec3i, Vec3u, Vec4b, Vec4f, Vec4h, Vec4i, Vec4u, Void, WgslArray, WgslStruct, atomicI32, atomicU32, isAlignAttrib, isAtomic, isBuiltinAttrib, isDecorated, isInterpolateAttrib, isLocationAttrib, isPtr, isSizeAttrib, isWgslArray, isWgslData, isWgslStruct, m2x2f, m3x3f, m4x4f, matBase, v2b, v2f, v2i, v2u, v3b, v3f, v3i, v3u, v4b, v4f, v4i, v4u, vecBase } from "./wgslTypes.js";
 import { WgslExternalTexture, WgslStorageTexture, WgslStorageTexture1d, WgslStorageTexture2d, WgslStorageTexture2dArray, WgslStorageTexture3d, WgslStorageTextureProps, WgslTexture, WgslTexture1d, WgslTexture2d, WgslTexture2dArray, WgslTexture3d, WgslTextureCube, WgslTextureCubeArray, WgslTextureDepth2d, WgslTextureDepth2dArray, WgslTextureDepthCube, WgslTextureDepthCubeArray, WgslTextureDepthMultisampled2d, WgslTextureMultisampled2d, texture1d, texture2d, texture2dArray, texture3d, textureCube, textureCubeArray, textureDepth2d, textureDepth2dArray, textureDepthCube, textureDepthCubeArray, textureDepthMultisampled2d, textureExternal, textureMultisampled2d, textureStorage1d, textureStorage2d, textureStorage2dArray, textureStorage3d } from "./texture.js";
-import { Infer, InferGPU, InferPartial } from "../shared/repr.js";
+import { Infer, InferGPU, InferInput, InferPartial, InferPatch } from "../shared/repr.js";
 import { AnyData, AnyLooseData, Disarray, LooseDecorated, Unstruct, isData, isDisarray, isLooseData, isLooseDecorated, isUnstruct } from "./dataTypes.js";
 import { bool, f16, f32, i32, u16, u32 } from "./numeric.js";
 import { struct } from "./struct.js";
@@ -25,7 +25,7 @@ import { deepEqual } from "./deepEqual.js";
 
 //#region src/data/index.d.ts
 declare namespace index_d_exports {
-  export { Align, AnyAttribute, AnyBuiltin, AnyData, AnyLooseData, AnyVecInstance, AnyWgslData, AnyWgslStruct, Atomic, BaseData, BaseData as BaseWgslData, Bool, Builtin, BuiltinClipDistances, BuiltinFragDepth, BuiltinFrontFacing, BuiltinGlobalInvocationId, BuiltinInstanceIndex, BuiltinLocalInvocationId, BuiltinLocalInvocationIndex, BuiltinNumWorkgroups, BuiltinPosition, BuiltinSampleIndex, BuiltinSampleMask, BuiltinVertexIndex, BuiltinWorkgroupId, Decorated, Disarray, F16, F32, FormatToAcceptedData, FormatToWGSLType, HasCustomLocation, I32, Infer, InferGPU, InferPartial, Interpolate, IsBuiltin, Location, LooseDecorated, Mat2x2f, Mat3x3f, Mat4x4f, PackedData, Ptr, Size, StorableData, TgpuVertexFormatData, U16, U32, Unstruct, Vec2b, Vec2f, Vec2h, Vec2i, Vec2u, Vec3b, Vec3f, Vec3h, Vec3i, Vec3u, Vec4b, Vec4f, Vec4h, Vec4i, Vec4u, Void, WgslArray, WgslComparisonSampler, WgslExternalTexture, WgslSampler, WgslStorageTexture, WgslStorageTexture1d, WgslStorageTexture2d, WgslStorageTexture2dArray, WgslStorageTexture3d, WgslStorageTextureProps, WgslStruct, WgslTexture, WgslTexture1d, WgslTexture2d, WgslTexture2dArray, WgslTexture3d, WgslTextureCube, WgslTextureCubeArray, WgslTextureDepth2d, WgslTextureDepth2dArray, WgslTextureDepthCube, WgslTextureDepthCubeArray, WgslTextureDepthMultisampled2d, WgslTextureMultisampled2d, align, PUBLIC_alignmentOf as alignmentOf, arrayOf, atomic, atomicI32, atomicU32, bool, builtin, comparisonSampler, deepEqual, disarrayOf, f16, f32, float16, float16x2, float16x4, float32, float32x2, float32x3, float32x4, formatToWGSLType, PUBLIC_getLongestContiguousPrefix as getLongestContiguousPrefix, i32, interpolate, invariant, isAlignAttrib, isAtomic, isBuiltin, isBuiltinAttrib, PUBLIC_isContiguous as isContiguous, isData, isDecorated, isDisarray, isInterpolateAttrib, isLocationAttrib, isLooseData, isLooseDecorated, isPackedData, isPtr, isSizeAttrib, isUnstruct, isWgslArray, isWgslData, isWgslStruct, location, m2x2f, m3x3f, m4x4f, mat2x2f, mat3x3f, mat4x4f, matBase, matToArray, memoryLayoutOf, packedFormats, ptrFn, ptrHandle, ptrPrivate, ptrStorage, ptrUniform, ptrWorkgroup, _ref as ref, sampler, sint16, sint16x2, sint16x4, sint32, sint32x2, sint32x3, sint32x4, sint8, sint8x2, sint8x4, size, PUBLIC_sizeOf as sizeOf, snorm16, snorm16x2, snorm16x4, snorm8, snorm8x2, snorm8x4, struct, texture1d, texture2d, texture2dArray, texture3d, textureCube, textureCubeArray, textureDepth2d, textureDepth2dArray, textureDepthCube, textureDepthCubeArray, textureDepthMultisampled2d, textureExternal, textureMultisampled2d, textureStorage1d, textureStorage2d, textureStorage2dArray, textureStorage3d, u16, u32, uint16, uint16x2, uint16x4, uint32, uint32x2, uint32x3, uint32x4, uint8, uint8x2, uint8x4, unorm10_10_10_2, unorm16, unorm16x2, unorm16x4, unorm8, unorm8x2, unorm8x4, unorm8x4_bgra, unstruct, v2b, v2f, v2i, v2u, v3b, v3f, v3i, v3u, v4b, v4f, v4i, v4u, vec2b, vec2f, vec2h, vec2i, vec2u, vec3b, vec3f, vec3h, vec3i, vec3u, vec4b, vec4f, vec4h, vec4i, vec4u, vecBase };
+  export { Align, AnyAttribute, AnyBuiltin, AnyData, AnyLooseData, AnyVecInstance, AnyWgslData, AnyWgslStruct, Atomic, BaseData, BaseData as BaseWgslData, Bool, Builtin, BuiltinClipDistances, BuiltinFragDepth, BuiltinFrontFacing, BuiltinGlobalInvocationId, BuiltinInstanceIndex, BuiltinLocalInvocationId, BuiltinLocalInvocationIndex, BuiltinNumWorkgroups, BuiltinPosition, BuiltinSampleIndex, BuiltinSampleMask, BuiltinVertexIndex, BuiltinWorkgroupId, Decorated, Disarray, F16, F32, FormatToAcceptedData, FormatToWGSLType, HasCustomLocation, I32, Infer, InferGPU, InferInput, InferPartial, InferPatch, Interpolate, IsBuiltin, Location, LooseDecorated, Mat2x2f, Mat3x3f, Mat4x4f, PackedData, Ptr, Size, StorableData, TgpuVertexFormatData, U16, U32, Unstruct, Vec2b, Vec2f, Vec2h, Vec2i, Vec2u, Vec3b, Vec3f, Vec3h, Vec3i, Vec3u, Vec4b, Vec4f, Vec4h, Vec4i, Vec4u, Void, WgslArray, WgslComparisonSampler, WgslExternalTexture, WgslSampler, WgslStorageTexture, WgslStorageTexture1d, WgslStorageTexture2d, WgslStorageTexture2dArray, WgslStorageTexture3d, WgslStorageTextureProps, WgslStruct, WgslTexture, WgslTexture1d, WgslTexture2d, WgslTexture2dArray, WgslTexture3d, WgslTextureCube, WgslTextureCubeArray, WgslTextureDepth2d, WgslTextureDepth2dArray, WgslTextureDepthCube, WgslTextureDepthCubeArray, WgslTextureDepthMultisampled2d, WgslTextureMultisampled2d, align, PUBLIC_alignmentOf as alignmentOf, arrayOf, atomic, atomicI32, atomicU32, bool, builtin, comparisonSampler, deepEqual, disarrayOf, f16, f32, float16, float16x2, float16x4, float32, float32x2, float32x3, float32x4, formatToWGSLType, PUBLIC_getLongestContiguousPrefix as getLongestContiguousPrefix, i32, interpolate, invariant, isAlignAttrib, isAtomic, isBuiltin, isBuiltinAttrib, PUBLIC_isContiguous as isContiguous, isData, isDecorated, isDisarray, isInterpolateAttrib, isLocationAttrib, isLooseData, isLooseDecorated, isPackedData, isPtr, isSizeAttrib, isUnstruct, isWgslArray, isWgslData, isWgslStruct, location, m2x2f, m3x3f, m4x4f, mat2x2f, mat3x3f, mat4x4f, matBase, matToArray, memoryLayoutOf, packedFormats, ptrFn, ptrHandle, ptrPrivate, ptrStorage, ptrUniform, ptrWorkgroup, _ref as ref, sampler, sint16, sint16x2, sint16x4, sint32, sint32x2, sint32x3, sint32x4, sint8, sint8x2, sint8x4, size, PUBLIC_sizeOf as sizeOf, snorm16, snorm16x2, snorm16x4, snorm8, snorm8x2, snorm8x4, struct, texture1d, texture2d, texture2dArray, texture3d, textureCube, textureCubeArray, textureDepth2d, textureDepth2dArray, textureDepthCube, textureDepthCubeArray, textureDepthMultisampled2d, textureExternal, textureMultisampled2d, textureStorage1d, textureStorage2d, textureStorage2dArray, textureStorage3d, u16, u32, uint16, uint16x2, uint16x4, uint32, uint32x2, uint32x3, uint32x4, uint8, uint8x2, uint8x4, unorm10_10_10_2, unorm16, unorm16x2, unorm16x4, unorm8, unorm8x2, unorm8x4, unorm8x4_bgra, unstruct, v2b, v2f, v2i, v2u, v3b, v3f, v3i, v3u, v4b, v4f, v4i, v4u, vec2b, vec2f, vec2h, vec2i, vec2u, vec3b, vec3f, vec3h, vec3i, vec3u, vec4b, vec4f, vec4h, vec4i, vec4u, vecBase };
 }
 //#endregion
-export { type Align, type AnyAttribute, type AnyBuiltin, type AnyData, type AnyLooseData, type AnyVecInstance, type AnyWgslData, type AnyWgslStruct, type Atomic, type BaseData, type BaseData as BaseWgslData, type Bool, type Builtin, type BuiltinClipDistances, type BuiltinFragDepth, type BuiltinFrontFacing, type BuiltinGlobalInvocationId, type BuiltinInstanceIndex, type BuiltinLocalInvocationId, type BuiltinLocalInvocationIndex, type BuiltinNumWorkgroups, type BuiltinPosition, type BuiltinSampleIndex, type BuiltinSampleMask, type BuiltinVertexIndex, type BuiltinWorkgroupId, type Decorated, type Disarray, type F16, type F32, FormatToAcceptedData, FormatToWGSLType, type HasCustomLocation, type I32, type Infer, type InferGPU, type InferPartial, type Interpolate, type IsBuiltin, type Location, type LooseDecorated, type Mat2x2f, type Mat3x3f, type Mat4x4f, PackedData, type Ptr, type Size, type StorableData, TgpuVertexFormatData, type U16, type U32, type Unstruct, type Vec2b, type Vec2f, type Vec2h, type Vec2i, type Vec2u, type Vec3b, type Vec3f, type Vec3h, type Vec3i, type Vec3u, type Vec4b, type Vec4f, type Vec4h, type Vec4i, type Vec4u, Void, type WgslArray, type WgslComparisonSampler, type WgslExternalTexture, type WgslSampler, type WgslStorageTexture, type WgslStorageTexture1d, type WgslStorageTexture2d, type WgslStorageTexture2dArray, type WgslStorageTexture3d, type WgslStorageTextureProps, type WgslStruct, type WgslTexture, type WgslTexture1d, type WgslTexture2d, type WgslTexture2dArray, type WgslTexture3d, type WgslTextureCube, type WgslTextureCubeArray, type WgslTextureDepth2d, type WgslTextureDepth2dArray, type WgslTextureDepthCube, type WgslTextureDepthCubeArray, type WgslTextureDepthMultisampled2d, type WgslTextureMultisampled2d, align, PUBLIC_alignmentOf as alignmentOf, arrayOf, atomic, type atomicI32, type atomicU32, bool, builtin, comparisonSampler, deepEqual, disarrayOf, f16, f32, float16, float16x2, float16x4, float32, float32x2, float32x3, float32x4, formatToWGSLType, PUBLIC_getLongestContiguousPrefix as getLongestContiguousPrefix, i32, index_d_exports, interpolate, invariant, isAlignAttrib, isAtomic, isBuiltin, isBuiltinAttrib, PUBLIC_isContiguous as isContiguous, isData, isDecorated, isDisarray, isInterpolateAttrib, isLocationAttrib, isLooseData, isLooseDecorated, isPackedData, isPtr, isSizeAttrib, isUnstruct, isWgslArray, isWgslData, isWgslStruct, location, type m2x2f, type m3x3f, type m4x4f, mat2x2f, mat3x3f, mat4x4f, type matBase, matToArray, memoryLayoutOf, packedFormats, ptrFn, ptrHandle, ptrPrivate, ptrStorage, ptrUniform, ptrWorkgroup, _ref as ref, sampler, sint16, sint16x2, sint16x4, sint32, sint32x2, sint32x3, sint32x4, sint8, sint8x2, sint8x4, size, PUBLIC_sizeOf as sizeOf, snorm16, snorm16x2, snorm16x4, snorm8, snorm8x2, snorm8x4, struct, texture1d, texture2d, texture2dArray, texture3d, textureCube, textureCubeArray, textureDepth2d, textureDepth2dArray, textureDepthCube, textureDepthCubeArray, textureDepthMultisampled2d, textureExternal, textureMultisampled2d, textureStorage1d, textureStorage2d, textureStorage2dArray, textureStorage3d, u16, u32, uint16, uint16x2, uint16x4, uint32, uint32x2, uint32x3, uint32x4, uint8, uint8x2, uint8x4, unorm10_10_10_2, unorm16, unorm16x2, unorm16x4, unorm8, unorm8x2, unorm8x4, unorm8x4_bgra, unstruct, type v2b, type v2f, type v2i, type v2u, type v3b, type v3f, type v3i, type v3u, type v4b, type v4f, type v4i, type v4u, vec2b, vec2f, vec2h, vec2i, vec2u, vec3b, vec3f, vec3h, vec3i, vec3u, vec4b, vec4f, vec4h, vec4i, vec4u, type vecBase };
+export { type Align, type AnyAttribute, type AnyBuiltin, type AnyData, type AnyLooseData, type AnyVecInstance, type AnyWgslData, type AnyWgslStruct, type Atomic, type BaseData, type BaseData as BaseWgslData, type Bool, type Builtin, type BuiltinClipDistances, type BuiltinFragDepth, type BuiltinFrontFacing, type BuiltinGlobalInvocationId, type BuiltinInstanceIndex, type BuiltinLocalInvocationId, type BuiltinLocalInvocationIndex, type BuiltinNumWorkgroups, type BuiltinPosition, type BuiltinSampleIndex, type BuiltinSampleMask, type BuiltinVertexIndex, type BuiltinWorkgroupId, type Decorated, type Disarray, type F16, type F32, FormatToAcceptedData, FormatToWGSLType, type HasCustomLocation, type I32, type Infer, type InferGPU, type InferInput, type InferPartial, type InferPatch, type Interpolate, type IsBuiltin, type Location, type LooseDecorated, type Mat2x2f, type Mat3x3f, type Mat4x4f, PackedData, type Ptr, type Size, type StorableData, TgpuVertexFormatData, type U16, type U32, type Unstruct, type Vec2b, type Vec2f, type Vec2h, type Vec2i, type Vec2u, type Vec3b, type Vec3f, type Vec3h, type Vec3i, type Vec3u, type Vec4b, type Vec4f, type Vec4h, type Vec4i, type Vec4u, Void, type WgslArray, type WgslComparisonSampler, type WgslExternalTexture, type WgslSampler, type WgslStorageTexture, type WgslStorageTexture1d, type WgslStorageTexture2d, type WgslStorageTexture2dArray, type WgslStorageTexture3d, type WgslStorageTextureProps, type WgslStruct, type WgslTexture, type WgslTexture1d, type WgslTexture2d, type WgslTexture2dArray, type WgslTexture3d, type WgslTextureCube, type WgslTextureCubeArray, type WgslTextureDepth2d, type WgslTextureDepth2dArray, type WgslTextureDepthCube, type WgslTextureDepthCubeArray, type WgslTextureDepthMultisampled2d, type WgslTextureMultisampled2d, align, PUBLIC_alignmentOf as alignmentOf, arrayOf, atomic, type atomicI32, type atomicU32, bool, builtin, comparisonSampler, deepEqual, disarrayOf, f16, f32, float16, float16x2, float16x4, float32, float32x2, float32x3, float32x4, formatToWGSLType, PUBLIC_getLongestContiguousPrefix as getLongestContiguousPrefix, i32, index_d_exports, interpolate, invariant, isAlignAttrib, isAtomic, isBuiltin, isBuiltinAttrib, PUBLIC_isContiguous as isContiguous, isData, isDecorated, isDisarray, isInterpolateAttrib, isLocationAttrib, isLooseData, isLooseDecorated, isPackedData, isPtr, isSizeAttrib, isUnstruct, isWgslArray, isWgslData, isWgslStruct, location, type m2x2f, type m3x3f, type m4x4f, mat2x2f, mat3x3f, mat4x4f, type matBase, matToArray, memoryLayoutOf, packedFormats, ptrFn, ptrHandle, ptrPrivate, ptrStorage, ptrUniform, ptrWorkgroup, _ref as ref, sampler, sint16, sint16x2, sint16x4, sint32, sint32x2, sint32x3, sint32x4, sint8, sint8x2, sint8x4, size, PUBLIC_sizeOf as sizeOf, snorm16, snorm16x2, snorm16x4, snorm8, snorm8x2, snorm8x4, struct, texture1d, texture2d, texture2dArray, texture3d, textureCube, textureCubeArray, textureDepth2d, textureDepth2dArray, textureDepthCube, textureDepthCubeArray, textureDepthMultisampled2d, textureExternal, textureMultisampled2d, textureStorage1d, textureStorage2d, textureStorage2dArray, textureStorage3d, u16, u32, uint16, uint16x2, uint16x4, uint32, uint32x2, uint32x3, uint32x4, uint8, uint8x2, uint8x4, unorm10_10_10_2, unorm16, unorm16x2, unorm16x4, unorm8, unorm8x2, unorm8x4, unorm8x4_bgra, unstruct, type v2b, type v2f, type v2i, type v2u, type v3b, type v3f, type v3i, type v3u, type v4b, type v4f, type v4i, type v4u, vec2b, vec2f, vec2h, vec2i, vec2u, vec3b, vec3f, vec3h, vec3i, vec3u, vec4b, vec4f, vec4h, vec4i, vec4u, type vecBase };

package/data/index.js

@@ -25,7 +25,6 @@ import { disarrayOf } from "./disarray.js";
 import { unstruct } from "./unstruct.js";
 import { deepEqual } from "./deepEqual.js";
 import { Operator } from "tsover-runtime";
-
 //#region src/data/index.ts
 /**
 * @module typegpu/data
@@ -180,6 +179,14 @@ assignInfixOperator(VecBase, "mod", Operator.percent);
 assignInfixOperator(MatBase, "add", Operator.plus);
 assignInfixOperator(MatBase, "sub", Operator.minus);
 assignInfixOperator(MatBase, "mul", Operator.star);
-
+{
+	const proto = VecBase.prototype;
+	proto.bitShiftLeft = function(other) {
+		return infixOperators.bitShiftLeft(this, other);
+	};
+	proto.bitShiftRight = function(other) {
+		return infixOperators.bitShiftRight(this, other);
+	};
+}
 //#endregion
-export { Void, align, PUBLIC_alignmentOf as alignmentOf, arrayOf, atomic, bool, builtin, comparisonSampler, data_exports, deepEqual, disarrayOf, f16, f32, float16, float16x2, float16x4, float32, float32x2, float32x3, float32x4, formatToWGSLType, PUBLIC_getLongestContiguousPrefix as getLongestContiguousPrefix, i32, interpolate, invariant, isAlignAttrib, isAtomic, isBuiltin, isBuiltinAttrib, PUBLIC_isContiguous as isContiguous, isData, isDecorated, isDisarray, isInterpolateAttrib, isLocationAttrib, isLooseData, isLooseDecorated, isPackedData, isPtr, isSizeAttrib, isUnstruct, isWgslArray, isWgslData, isWgslStruct, location, mat2x2f, mat3x3f, mat4x4f, matToArray, memoryLayoutOf, packedFormats, ptrFn, ptrHandle, ptrPrivate, ptrStorage, ptrUniform, ptrWorkgroup, _ref as ref, sampler, sint16, sint16x2, sint16x4, sint32, sint32x2, sint32x3, sint32x4, sint8, sint8x2, sint8x4, size, PUBLIC_sizeOf as sizeOf, snorm16, snorm16x2, snorm16x4, snorm8, snorm8x2, snorm8x4, struct, texture1d, texture2d, texture2dArray, texture3d, textureCube, textureCubeArray, textureDepth2d, textureDepth2dArray, textureDepthCube, textureDepthCubeArray, textureDepthMultisampled2d, textureExternal, textureMultisampled2d, textureStorage1d, textureStorage2d, textureStorage2dArray, textureStorage3d, u16, u32, uint16, uint16x2, uint16x4, uint32, uint32x2, uint32x3, uint32x4, uint8, uint8x2, uint8x4, unorm10_10_10_2, unorm16, unorm16x2, unorm16x4, unorm8, unorm8x2, unorm8x4, unorm8x4_bgra, unstruct, vec2b, vec2f, vec2h, vec2i, vec2u, vec3b, vec3f, vec3h, vec3i, vec3u, vec4b, vec4f, vec4h, vec4i, vec4u };
+export { Void, align, PUBLIC_alignmentOf as alignmentOf, arrayOf, atomic, bool, builtin, comparisonSampler, data_exports, deepEqual, disarrayOf, f16, f32, float16, float16x2, float16x4, float32, float32x2, float32x3, float32x4, formatToWGSLType, PUBLIC_getLongestContiguousPrefix as getLongestContiguousPrefix, i32, interpolate, invariant, isAlignAttrib, isAtomic, isBuiltin, isBuiltinAttrib, PUBLIC_isContiguous as isContiguous, isData, isDecorated, isDisarray, isInterpolateAttrib, isLocationAttrib, isLooseData, isLooseDecorated, isPackedData, isPtr, isSizeAttrib, isUnstruct, isWgslArray, isWgslData, isWgslStruct, location, mat2x2f, mat3x3f, mat4x4f, matToArray, memoryLayoutOf, packedFormats, ptrFn, ptrHandle, ptrPrivate, ptrStorage, ptrUniform, ptrWorkgroup, _ref as ref, sampler, sint16, sint16x2, sint16x4, sint32, sint32x2, sint32x3, sint32x4, sint8, sint8x2, sint8x4, size, PUBLIC_sizeOf as sizeOf, snorm16, snorm16x2, snorm16x4, snorm8, snorm8x2, snorm8x4, struct, texture1d, texture2d, texture2dArray, texture3d, textureCube, textureCubeArray, textureDepth2d, textureDepth2dArray, textureDepthCube, textureDepthCubeArray, textureDepthMultisampled2d, textureExternal, textureMultisampled2d, textureStorage1d, textureStorage2d, textureStorage2dArray, textureStorage3d, u16, u32, uint16, uint16x2, uint16x4, uint32, uint32x2, uint32x3, uint32x4, uint8, uint8x2, uint8x4, unorm10_10_10_2, unorm16, unorm16x2, unorm16x4, unorm8, unorm8x2, unorm8x4, unorm8x4_bgra, unstruct, vec2b, vec2f, vec2h, vec2i, vec2u, vec3b, vec3f, vec3h, vec3i, vec3u, vec4b, vec4f, vec4h, vec4i, vec4u };

package/data/isContiguous.d.ts

@@ -1,4 +1,3 @@
-import "./wgslTypes.js";
 import { AnyData } from "./dataTypes.js";
 
 //#region src/data/isContiguous.d.ts

package/data/isContiguous.js

@@ -1,5 +1,4 @@
 import { getLayoutInfo } from "./schemaMemoryLayout.js";
-
 //#region src/data/isContiguous.ts
 function isContiguous(schema) {
 	return getLayoutInfo(schema, "isContiguous");
@@ -10,6 +9,5 @@ function isContiguous(schema) {
 function PUBLIC_isContiguous(schema) {
 	return isContiguous(schema);
 }
-
 //#endregion
-export { PUBLIC_isContiguous, isContiguous };
+export { PUBLIC_isContiguous, isContiguous };