typegpu 0.11.1 → 0.11.3

package/data/attributes.js

@@ -3,6 +3,7 @@ import { isAlignAttrib, isBuiltinAttrib, isDecorated, isSizeAttrib, isWgslData }
 import { isLooseData, isLooseDecorated } from "./dataTypes.js";
 import { alignmentOf } from "./alignmentOf.js";
 import { sizeOf } from "./sizeOf.js";
+
 //#region src/data/attributes.ts
 function attribute(data, attrib) {
 	if (isDecorated(data)) return new DecoratedImpl(data.inner, [attrib, ...data.attribs]);
@@ -43,11 +44,11 @@ function align(alignment, data) {
 * @param size The amount of bytes that should be reserved for this data-type.
 * @param data The data-type to wrap.
 */
-function size(size, data) {
+function size(size$1, data) {
 	return attribute(data, {
 		[$internal]: true,
 		type: "@size",
-		params: [size]
+		params: [size$1]
 	});
 }
 /**
@@ -63,11 +64,11 @@ function size(size, data) {
 * @param location The explicit numeric location.
 * @param data The data-type to wrap.
 */
-function location(location, data) {
+function location(location$1, data) {
 	return attribute(data, {
 		[$internal]: true,
 		type: "@location",
-		params: [location]
+		params: [location$1]
 	});
 }
 function interpolate(interpolationType, data) {
@@ -141,5 +142,6 @@ var LooseDecoratedImpl = class extends BaseDecoratedImpl {
 	[$internal] = {};
 	type = "loose-decorated";
 };
+
 //#endregion
-export { align, attribute, getAttributesString, interpolate, invariant, isBuiltin, location, size };
+export { align, attribute, getAttributesString, interpolate, invariant, isBuiltin, location, size };

package/data/autoStruct.d.ts

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

package/data/autoStruct.js

@@ -2,6 +2,7 @@ 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
@@ -77,5 +78,6 @@ var AutoStruct = class {
 };
 AutoStruct.prototype[$internal] = {};
 AutoStruct.prototype.type = "auto-struct";
+
 //#endregion
-export { AutoStruct };
+export { AutoStruct };

package/data/compiledIO.js

@@ -5,6 +5,7 @@ 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 {
@@ -126,41 +127,41 @@ const specialPackedFormats = {
 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) {
+	function go(node$1, offsetExpr$1, valueExpr$1, depth$1) {
 		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];
-			return subSchema ? go(subSchema, `(${offsetExpr} + ${propOffset.offset})`, `${valueExpr}.${key}`, depth) : "";
+		][depth$1] || `i${depth$1}`;
+		if (isAtomic(node$1) || isDecorated(node$1)) return go(node$1.inner, offsetExpr$1, valueExpr$1, depth$1);
+		if (isWgslStruct(node$1) || isUnstruct(node$1)) return Object.entries(offsetsForProps(node$1)).map(([key, propOffset]) => {
+			const subSchema = node$1.propTypes[key];
+			return subSchema ? go(subSchema, `(${offsetExpr$1} + ${propOffset.offset})`, `${valueExpr$1}.${key}`, depth$1) : "";
 		}).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`;
+		if (isWgslArray(node$1) || isDisarray(node$1)) {
+			const elementSize = roundUp(sizeOf(node$1.elementType), alignmentOf(node$1));
+			const totalSize = node$1.elementCount * elementSize;
+			const copyLen = partial ? `Math.min(${valueExpr$1}.byteLength, Math.max(0, endOffset - (${offsetExpr$1})))` : `Math.min(${valueExpr$1}.byteLength, ${totalSize})`;
+			let code = `if (ArrayBuffer.isView(${valueExpr$1})) {\n`;
+			code += `  new Uint8Array(output.buffer).set(new Uint8Array(${valueExpr$1}.buffer, ${valueExpr$1}.byteOffset, ${copyLen}), output.byteOffset + (${offsetExpr$1}));\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 += `for (let ${loopVar} = 0; ${loopVar} < ${node$1.elementCount}; ${loopVar}++) {\n`;
+			if (partial) code += `if ((${offsetExpr$1} + ${loopVar} * ${elementSize}) >= endOffset) return;\n`;
+			code += go(node$1.elementType, `(${offsetExpr$1} + ${loopVar} * ${elementSize})`, `${valueExpr$1}[${loopVar}]`, depth$1 + 1);
 			code += "}\n";
 			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];
-			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 (isVec(node$1)) {
+			if (isVecBool(node$1)) throw new Error("Compiled writers do not support boolean vectors");
+			const primitive$1 = typeToPrimitive[node$1.type];
+			const componentSize = sizeOf(node$1.primitive);
+			const writeFunc = primitiveToWriteFunction[primitive$1];
+			return Array.from({ length: node$1.componentCount }, (_, i) => emitWrite(writeFunc, `(${offsetExpr$1} + ${i * componentSize})`, `${valueExpr$1}[${i}]`)).join("");
 		}
-		if (isMat(node)) {
-			const writeFunc = primitiveToWriteFunction[typeToPrimitive[node.type]];
-			const matSize = isMat2x2f(node) ? 2 : isMat3x3f(node) ? 3 : 4;
+		if (isMat(node$1)) {
+			const writeFunc = primitiveToWriteFunction[typeToPrimitive[node$1.type]];
+			const matSize = isMat2x2f(node$1) ? 2 : isMat3x3f(node$1) ? 3 : 4;
 			const rowStride = roundUp(matSize * 4, 8);
 			const components = [
 				"x",
@@ -174,20 +175,20 @@ function buildWriter(node, offsetExpr, valueExpr, depth = 0, partial = false) {
 				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]}`);
+				return emitWrite(writeFunc, `(${offsetExpr$1} + ${col * rowStride + row * 4})`, `ArrayBuffer.isView(${valueExpr$1}) ? ${valueExpr$1}[${wgslIndex}] : Array.isArray(${valueExpr$1}) ? ${valueExpr$1}[${packedIndex}] : ${valueExpr$1}.columns[${col}].${components[row]}`);
 			}).join("");
 		}
-		if (isPackedData(node)) {
-			const formatName = node.type;
+		if (isPackedData(node$1)) {
+			const formatName = node$1.type;
 			if (formatName in specialPackedFormats) {
 				const handler = specialPackedFormats[formatName];
-				return emitBlock(`(${offsetExpr})`, handler.generator(offsetExpr, valueExpr));
+				return emitBlock(`(${offsetExpr$1})`, handler.generator(offsetExpr$1, valueExpr$1));
 			}
-			const primitive = vertexFormatToPrimitive[formatName];
-			const writeFunc = primitiveToWriteFunction[primitive];
+			const primitive$1 = vertexFormatToPrimitive[formatName];
+			const writeFunc = primitiveToWriteFunction[primitive$1];
 			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 componentSize = primitive$1 === "u8" || primitive$1 === "i8" ? 1 : primitive$1 === "u16" || primitive$1 === "i16" || primitive$1 === "f16" ? 2 : 4;
 			const components = [
 				"x",
 				"y",
@@ -196,14 +197,14 @@ function buildWriter(node, offsetExpr, valueExpr, depth = 0, partial = false) {
 			];
 			const transform = vertexFormatValueTransform[formatName];
 			return Array.from({ length: componentCount }, (_, idx) => {
-				const accessor = componentCount === 1 ? valueExpr : `${valueExpr}.${components[idx]}`;
+				const accessor = componentCount === 1 ? valueExpr$1 : `${valueExpr$1}.${components[idx]}`;
 				const value = transform ? transform(accessor) : accessor;
-				return emitWrite(writeFunc, `(${offsetExpr} + ${idx * componentSize})`, value);
+				return emitWrite(writeFunc, `(${offsetExpr$1} + ${idx * componentSize})`, value);
 			}).join("");
 		}
-		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$1.type)) throw new Error(`Primitive ${node$1.type} is unsupported by compiled writer`);
+		const primitive = typeToPrimitive[node$1.type];
+		return emitWrite(primitiveToWriteFunction[primitive], offsetExpr$1, valueExpr$1);
 	}
 	return go(node, offsetExpr, valueExpr, depth);
 }
@@ -224,5 +225,6 @@ function getCompiledWriter(schema) {
 		console.warn(`Failed to compile writer for schema: ${schema}\nReason: ${error instanceof Error ? error.message : String(error)}\nFalling back to default writer`);
 	}
 }
+
 //#endregion
-export { getCompiledWriter };
+export { getCompiledWriter };

package/data/dataIO.js

@@ -2,7 +2,8 @@ import { vec2f, vec2h, vec2i, vec2u, vec3f, vec3h, vec3i, vec3u, vec4f, vec4h, v
 import { alignmentOf, customAlignmentOf } from "./alignmentOf.js";
 import { sizeOf } from "./sizeOf.js";
 import { mat2x2f, mat3x3f, mat4x4f } from "./matrix.js";
-import alignIO from "./alignIO.js";
+import alignIO_default from "./alignIO.js";
+
 //#region src/data/dataIO.ts
 const dataWriters = {
 	bool() {
@@ -103,20 +104,20 @@ const dataWriters = {
 	},
 	struct(output, schema, value) {
 		const alignment = alignmentOf(schema);
-		alignIO(output, alignment);
+		alignIO_default(output, alignment);
 		for (const [key, property] of Object.entries(schema.propTypes)) {
-			alignIO(output, alignmentOf(property));
+			alignIO_default(output, alignmentOf(property));
 			writeData(output, property, value[key]);
 		}
-		alignIO(output, alignment);
+		alignIO_default(output, alignment);
 	},
 	array(output, schema, value) {
 		if (schema.elementCount === 0) throw new Error("Cannot write using a runtime-sized schema.");
 		const alignment = alignmentOf(schema);
-		alignIO(output, alignment);
+		alignIO_default(output, alignment);
 		const beginning = output.currentByteOffset;
 		for (let i = 0; i < Math.min(schema.elementCount, value.length); i++) {
-			alignIO(output, alignment);
+			alignIO_default(output, alignment);
 			writeData(output, schema.elementType, value[i]);
 		}
 		output.seekTo(beginning + sizeOf(schema));
@@ -128,7 +129,7 @@ const dataWriters = {
 		dataWriters[schema.inner.type]?.(output, schema, value);
 	},
 	decorated(output, schema, value) {
-		alignIO(output, customAlignmentOf(schema));
+		alignIO_default(output, customAlignmentOf(schema));
 		const beginning = output.currentByteOffset;
 		dataWriters[schema.inner?.type]?.(output, schema.inner, value);
 		output.seekTo(beginning + sizeOf(schema));
@@ -320,10 +321,10 @@ const dataWriters = {
 	},
 	disarray(output, schema, value) {
 		const alignment = alignmentOf(schema);
-		alignIO(output, alignment);
+		alignIO_default(output, alignment);
 		const beginning = output.currentByteOffset;
 		for (let i = 0; i < Math.min(schema.elementCount, value.length); i++) {
-			alignIO(output, alignment);
+			alignIO_default(output, alignment);
 			dataWriters[schema.elementType?.type]?.(output, schema.elementType, value[i]);
 		}
 		output.seekTo(beginning + sizeOf(schema));
@@ -333,7 +334,7 @@ const dataWriters = {
 		for (const [key, property] of Object.entries(propTypes)) dataWriters[property.type]?.(output, property, value[key]);
 	},
 	"loose-decorated"(output, schema, value) {
-		alignIO(output, customAlignmentOf(schema));
+		alignIO_default(output, customAlignmentOf(schema));
 		const beginning = output.currentByteOffset;
 		const writer = dataWriters[schema.inner?.type];
 		writer?.(output, schema.inner, value);
@@ -435,14 +436,14 @@ const dataReaders = {
 	},
 	struct(input, schema) {
 		const alignment = alignmentOf(schema);
-		alignIO(input, alignment);
+		alignIO_default(input, alignment);
 		const result = {};
 		const propTypes = schema.propTypes;
 		for (const [key, property] of Object.entries(propTypes)) {
-			alignIO(input, alignmentOf(property));
+			alignIO_default(input, alignmentOf(property));
 			result[key] = readData(input, property);
 		}
-		alignIO(input, alignment);
+		alignIO_default(input, alignment);
 		return result;
 	},
 	array(input, schema) {
@@ -450,12 +451,12 @@ const dataReaders = {
 		const alignment = alignmentOf(schema);
 		const elements = [];
 		for (let i = 0; i < schema.elementCount; i++) {
-			alignIO(input, alignment);
+			alignIO_default(input, alignment);
 			const elementType = schema.elementType;
 			const value = readData(input, elementType);
 			elements.push(value);
 		}
-		alignIO(input, alignment);
+		alignIO_default(input, alignment);
 		return elements;
 	},
 	ptr() {
@@ -465,7 +466,7 @@ const dataReaders = {
 		return readData(input, schema.inner);
 	},
 	decorated(input, schema) {
-		alignIO(input, customAlignmentOf(schema));
+		alignIO_default(input, customAlignmentOf(schema));
 		const beginning = input.currentByteOffset;
 		const value = readData(input, schema.inner);
 		input.seekTo(beginning + sizeOf(schema));
@@ -533,14 +534,14 @@ const dataReaders = {
 		const alignment = alignmentOf(schema);
 		const elements = [];
 		for (let i = 0; i < schema.elementCount; i++) {
-			alignIO(input, alignment);
+			alignIO_default(input, alignment);
 			elements.push(readData(input, schema.elementType));
 		}
-		alignIO(input, alignment);
+		alignIO_default(input, alignment);
 		return elements;
 	},
 	"loose-decorated"(input, schema) {
-		alignIO(input, customAlignmentOf(schema));
+		alignIO_default(input, customAlignmentOf(schema));
 		const beginning = input.currentByteOffset;
 		const value = readData(input, schema.inner);
 		input.seekTo(beginning + sizeOf(schema));
@@ -552,5 +553,6 @@ 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,11 +1,16 @@
 import { TgpuNamable } from "../shared/meta.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, TypedArrayFor } from "./wgslTypes.js";
+import "./texture.js";
 import { Infer, InferGPURecord, InferInput, InferInputRecord, InferPartial, InferPartialRecord, InferPatch, InferPatchRecord, InferRecord, IsValidVertexSchema, MemIdentityRecord } from "../shared/repr.js";
 
 //#region src/data/dataTypes.d.ts
+
 /**
  * Array schema constructed via `d.disarrayOf` function.
  *
@@ -52,13 +57,13 @@ interface Unstruct<out TProps extends Record<string, BaseData> = Record<string,
   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';
 }
-interface LooseDecorated<out TInner extends BaseData = BaseData, out TAttribs extends unknown[] = unknown[]> extends BaseData {
+interface LooseDecorated<out TInner$1 extends BaseData = BaseData, out TAttribs extends unknown[] = unknown[]> extends BaseData {
   readonly type: 'loose-decorated';
-  readonly inner: TInner;
+  readonly inner: TInner$1;
   readonly attribs: TAttribs;
-  readonly [$repr]: Infer<TInner>;
+  readonly [$repr]: Infer<TInner$1>;
   readonly [$invalidSchemaReason]: 'Loosely decorated schemas are not host-shareable';
-  readonly [$validVertexSchema]: IsValidVertexSchema<TInner>;
+  readonly [$validVertexSchema]: IsValidVertexSchema<TInner$1>;
 }
 /**
  * Type utility to extract the inner type from decorated types.

package/data/dataTypes.js

@@ -2,6 +2,7 @@ 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.
@@ -96,5 +97,6 @@ var ConsoleLog = class {
 		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.d.ts

@@ -1,6 +1,7 @@
 import { AnyData } from "./dataTypes.js";
 
 //#region src/data/deepEqual.d.ts
+
 /**
  * Performs a deep comparison of two TypeGPU data schemas.
  *

package/data/deepEqual.js

@@ -1,5 +1,6 @@
 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.
@@ -52,5 +53,6 @@ function deepEqual(a, b) {
 	}
 	return true;
 }
+
 //#endregion
-export { deepEqual };
+export { deepEqual };

package/data/disarray.d.ts

@@ -1,5 +1,7 @@
 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>;
@@ -27,6 +29,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;
+declare const disarrayOf: TgpuComptime<DisarrayConstructor>;
 //#endregion
 export { disarrayOf };

package/data/disarray.js

@@ -1,6 +1,7 @@
 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.
@@ -46,5 +47,6 @@ const DisarrayImpl = {
 		return `disarrayOf(${this.elementType}, ${this.elementCount})`;
 	}
 };
+
 //#endregion
-export { disarrayOf };
+export { disarrayOf };

package/data/getLongestContiguousPrefix.d.ts

@@ -1,6 +1,8 @@
+import "./wgslTypes.js";
 import { AnyData } from "./dataTypes.js";
 
 //#region src/data/getLongestContiguousPrefix.d.ts
+
 /**
  * Returns the size (in bytes) of the longest contiguous memory prefix of data represented by the `schema`.
  */

package/data/getLongestContiguousPrefix.js

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

package/data/index.d.ts

@@ -4,7 +4,7 @@ import { AnyAttribute, HasCustomLocation, IsBuiltin, align, interpolate, invaria
 import { memoryLayoutOf } from "./offsetUtils.js";
 import { FormatToAcceptedData, FormatToWGSLType, PackedData, TgpuVertexFormatData, float16, float16x2, float16x4, float32, float32x2, float32x3, float32x4, formatToWGSLType, isPackedData, packedFormats, sint16, sint16x2, sint16x4, sint32, sint32x2, sint32x3, sint32x4, sint8, sint8x2, sint8x4, snorm16, snorm16x2, snorm16x4, snorm8, snorm8x2, snorm8x4, uint16, uint16x2, uint16x4, uint32, uint32x2, uint32x3, uint32x4, uint8, uint8x2, uint8x4, unorm10_10_10_2, unorm16, unorm16x2, unorm16x4, unorm8, unorm8x2, unorm8x4, unorm8x4_bgra } from "./vertexFormatData.js";
 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 { 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, v2h, v2i, v2u, v3b, v3f, v3h, v3i, v3u, v4b, v4f, v4h, 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, InferInput, InferPartial, InferPatch } from "../shared/repr.js";
 import { AnyData, AnyLooseData, Disarray, LooseDecorated, Unstruct, isData, isDisarray, isLooseData, isLooseDecorated, isUnstruct } from "./dataTypes.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, 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 };
+  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, v2h, v2i, v2u, v3b, v3f, v3h, v3i, v3u, v4b, v4f, v4h, 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 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 };
+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 v2h, type v2i, type v2u, type v3b, type v3f, type v3h, type v3i, type v3u, type v4b, type v4f, type v4h, 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

@@ -1,4 +1,4 @@
-import { __exportAll } from "../_virtual/_rolldown/runtime.js";
+import { __export } from "../_virtual/rolldown_runtime.js";
 import { Void, isAlignAttrib, isAtomic, isBuiltinAttrib, isDecorated, isInterpolateAttrib, isLocationAttrib, isPtr, isSizeAttrib, isWgslArray, isWgslData, isWgslStruct } from "./wgslTypes.js";
 import { isData, isDisarray, isLooseData, isLooseDecorated, isUnstruct } from "./dataTypes.js";
 import { ptrFn, ptrHandle, ptrPrivate, ptrStorage, ptrUniform, ptrWorkgroup } from "./ptr.js";
@@ -25,11 +25,9 @@ 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
-*/
-var data_exports = /* @__PURE__ */ __exportAll({
+var data_exports = /* @__PURE__ */ __export({
 	Void: () => Void,
 	align: () => align,
 	alignmentOf: () => PUBLIC_alignmentOf,
@@ -188,5 +186,6 @@ assignInfixOperator(MatBase, "mul", Operator.star);
 		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,6 +1,8 @@
+import "./wgslTypes.js";
 import { AnyData } from "./dataTypes.js";
 
 //#region src/data/isContiguous.d.ts
+
 /**
  * Returns `true` if data represented by the `schema` doesn't have padding.
  */

package/data/isContiguous.js

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

package/data/matrix.d.ts

@@ -1,52 +1,55 @@
 import { DualFn } from "../types.js";
 import { Mat2x2f, Mat3x3f, Mat4x4f, m2x2f, m3x3f, m4x4f, v3f } from "./wgslTypes.js";
 import { TgpuComptime } from "../core/function/comptime.js";
+import "../indexNamedExports.js";
+
 //#region src/data/matrix.d.ts
+
 /**
  * Returns a 2-by-2 identity matrix.
  * @returns {m2x2f} The result matrix.
  */
-declare const identity2: TgpuComptime;
+declare const identity2: TgpuComptime<() => m2x2f>;
 /**
  * Returns a 3-by-3 identity matrix.
  * @returns {m3x3f} The result matrix.
  */
-declare const identity3: TgpuComptime;
+declare const identity3: TgpuComptime<() => m3x3f>;
 /**
  * Returns a 4-by-4 identity matrix.
  * @returns {m4x4f} The result matrix.
  */
-declare const identity4: TgpuComptime;
+declare const identity4: TgpuComptime<() => m4x4f>;
 /**
  * Creates a 4-by-4 matrix which translates by the given vector v.
  * @param {v3f} vector - The vector by which to translate.
  * @returns {m4x4f} The translation matrix.
  */
-declare const translation4: DualFn;
+declare const translation4: DualFn<(vector: v3f) => m4x4f>;
 /**
  * Creates a 4-by-4 matrix which scales in each dimension by an amount given by the corresponding entry in the given vector.
  * @param {v3f} vector - A vector of three entries specifying the factor by which to scale in each dimension.
  * @returns {m4x4f} The scaling matrix.
  */
-declare const scaling4: DualFn;
+declare const scaling4: DualFn<(vector: v3f) => m4x4f>;
 /**
  * Creates a 4-by-4 matrix which rotates around the x-axis by the given angle.
  * @param {number} angle - The angle by which to rotate (in radians).
  * @returns {m4x4f} The rotation matrix.
  */
-declare const rotationX4: DualFn;
+declare const rotationX4: DualFn<(a: number) => m4x4f>;
 /**
  * Creates a 4-by-4 matrix which rotates around the y-axis by the given angle.
  * @param {number} angle - The angle by which to rotate (in radians).
  * @returns {m4x4f} The rotation matrix.
  */
-declare const rotationY4: DualFn;
+declare const rotationY4: DualFn<(a: number) => m4x4f>;
 /**
  * Creates a 4-by-4 matrix which rotates around the z-axis by the given angle.
  * @param {number} angle - The angle by which to rotate (in radians).
  * @returns {m4x4f} The rotation matrix.
  */
-declare const rotationZ4: DualFn;
+declare const rotationZ4: DualFn<(a: number) => m4x4f>;
 /**
  * Schema representing mat2x2f - a matrix with 2 rows and 2 columns, with elements of type f32.
  * Also a constructor function for this matrix type.