typegpu 0.10.1 → 0.10.2

package/core/vertexLayout/vertexLayout.js

@@ -0,0 +1,103 @@
+import { $internal } from "../../shared/symbols.js";
+import { setName } from "../../shared/meta.js";
+import { kindToDefaultFormatMap, vertexFormats } from "../../shared/vertexFormat.js";
+import { isDecorated, isWgslStruct } from "../../data/wgslTypes.js";
+import { getCustomLocation, isLooseDecorated, isUnstruct } from "../../data/dataTypes.js";
+import { alignmentOf, customAlignmentOf } from "../../data/alignmentOf.js";
+import { roundUp } from "../../mathUtils.js";
+import { sizeOf } from "../../data/sizeOf.js";
+
+//#region src/core/vertexLayout/vertexLayout.ts
+function vertexLayout(schemaForCount, stepMode = "vertex") {
+	return new TgpuVertexLayoutImpl(schemaForCount, stepMode);
+}
+function isVertexLayout(value) {
+	return value?.resourceType === "vertex-layout";
+}
+const defaultAttribEntry = Symbol("defaultAttribEntry");
+function dataToContainedAttribs(layout, data, offset, customLocationMap, key) {
+	if (isDecorated(data) || isLooseDecorated(data)) {
+		const customLocation = getCustomLocation(data);
+		if (customLocation !== void 0) customLocationMap[key ?? defaultAttribEntry] = customLocation;
+		return dataToContainedAttribs(layout, data.inner, roundUp(offset, customAlignmentOf(data)), customLocationMap);
+	}
+	if (isWgslStruct(data)) {
+		let memberOffset = offset;
+		const propTypes = data.propTypes;
+		return Object.fromEntries(Object.entries(propTypes).map(([key, value]) => {
+			memberOffset = roundUp(memberOffset, alignmentOf(value));
+			const attrib = [key, dataToContainedAttribs(layout, value, memberOffset, customLocationMap, key)];
+			memberOffset += sizeOf(value);
+			return attrib;
+		}));
+	}
+	if (isUnstruct(data)) {
+		let memberOffset = offset;
+		const propTypes = data.propTypes;
+		return Object.fromEntries(Object.entries(propTypes).map(([key, value]) => {
+			memberOffset = roundUp(memberOffset, customAlignmentOf(value));
+			const attrib = [key, dataToContainedAttribs(layout, value, memberOffset, customLocationMap, key)];
+			memberOffset += sizeOf(value);
+			return attrib;
+		}));
+	}
+	if ("type" in data && typeof data.type === "string") {
+		if (vertexFormats.includes(data.type)) return {
+			_layout: layout,
+			format: data.type,
+			offset
+		};
+		const format = kindToDefaultFormatMap[data.type];
+		if (format) return {
+			_layout: layout,
+			format,
+			offset
+		};
+	}
+	throw new Error(`Unsupported data used in vertex layout: ${String(data)}`);
+}
+var TgpuVertexLayoutImpl = class {
+	[$internal] = true;
+	resourceType = "vertex-layout";
+	stride;
+	attrib;
+	_customLocationMap = {};
+	constructor(schemaForCount, stepMode) {
+		this.schemaForCount = schemaForCount;
+		this.stepMode = stepMode;
+		const arraySchema = schemaForCount(0);
+		this.stride = roundUp(sizeOf(arraySchema.elementType), alignmentOf(arraySchema));
+		this.attrib = dataToContainedAttribs(this, arraySchema.elementType, 0, this._customLocationMap);
+	}
+	get vertexLayout() {
+		if (this._customLocationMap[defaultAttribEntry] !== void 0) {
+			if (typeof this.attrib.format !== "string" || typeof this.attrib.offset !== "number") throw new Error("Single attribute vertex layouts must have a format and offset.");
+			return {
+				arrayStride: this.stride,
+				stepMode: this.stepMode,
+				attributes: [{
+					format: this.attrib.format,
+					offset: this.attrib.offset,
+					shaderLocation: this._customLocationMap[defaultAttribEntry]
+				}]
+			};
+		}
+		if (!Object.keys(this.attrib).every((key) => this._customLocationMap[key] !== void 0)) throw new Error("All attributes must have custom locations in order to unwrap a vertex layout.");
+		return {
+			arrayStride: this.stride,
+			stepMode: this.stepMode,
+			attributes: Object.entries(this.attrib).map(([key, attrib]) => ({
+				format: attrib.format,
+				offset: attrib.offset,
+				shaderLocation: this._customLocationMap[key]
+			}))
+		};
+	}
+	$name(label) {
+		setName(this, label);
+		return this;
+	}
+};
+
+//#endregion
+export { isVertexLayout, vertexLayout };

package/data/alignIO.js

@@ -0,0 +1,15 @@
+//#region src/data/alignIO.ts
+/**
+* @param io the IO to align
+* @param baseAlignment must be power of 2
+*/
+function alignIO(io, baseAlignment) {
+	const currentPos = "size" in io ? io.size : io.currentByteOffset;
+	const bitMask = baseAlignment - 1;
+	const offset = currentPos & bitMask;
+	if ("skipBytes" in io) io.skipBytes(baseAlignment - offset & bitMask);
+	else io.add(baseAlignment - offset & bitMask);
+}
+
+//#endregion
+export { alignIO as default };

package/data/alignmentOf.d.ts

@@ -0,0 +1,10 @@
+import "./wgslTypes.js";
+import { AnyData } from "./dataTypes.js";
+
+//#region src/data/alignmentOf.d.ts
+/**
+ * Returns the alignment (in bytes) of data represented by the `schema`.
+ */
+declare function PUBLIC_alignmentOf(schema: AnyData): number;
+//#endregion
+export { PUBLIC_alignmentOf };

package/data/alignmentOf.js

@@ -0,0 +1,88 @@
+import { isDecorated, isWgslArray, isWgslStruct } from "./wgslTypes.js";
+import { getCustomAlignment, isDisarray, isLooseDecorated, isUnstruct } from "./dataTypes.js";
+import { safeStringify } from "../shared/stringify.js";
+import { packedFormats } from "./vertexFormatData.js";
+
+//#region src/data/alignmentOf.ts
+const knownAlignmentMap = {
+	f32: 4,
+	f16: 2,
+	i32: 4,
+	u32: 4,
+	bool: 4,
+	u16: 2,
+	vec2f: 8,
+	vec2h: 4,
+	vec2i: 8,
+	vec2u: 8,
+	"vec2<bool>": 8,
+	vec3f: 16,
+	vec3h: 8,
+	vec3i: 16,
+	vec3u: 16,
+	"vec3<bool>": 16,
+	vec4f: 16,
+	vec4h: 8,
+	vec4i: 16,
+	vec4u: 16,
+	"vec4<bool>": 16,
+	mat2x2f: 8,
+	mat3x3f: 16,
+	mat4x4f: 16,
+	atomic: 4
+};
+function computeAlignment(data) {
+	const dataType = data?.type;
+	const knownAlignment = knownAlignmentMap[dataType];
+	if (knownAlignment !== void 0) return knownAlignment;
+	if (isWgslStruct(data)) return Object.values(data.propTypes).map(alignmentOf).reduce((a, b) => a > b ? a : b);
+	if (isWgslArray(data)) return alignmentOf(data.elementType);
+	if (isUnstruct(data)) {
+		const firstProp = Object.values(data.propTypes)[0];
+		return firstProp ? getCustomAlignment(firstProp) ?? 1 : 1;
+	}
+	if (isDisarray(data)) return getCustomAlignment(data.elementType) ?? 1;
+	if (isDecorated(data) || isLooseDecorated(data)) return getCustomAlignment(data) ?? alignmentOf(data.inner);
+	if (packedFormats.has(dataType)) return 1;
+	throw new Error(`Cannot determine alignment of data: ${safeStringify(data)}`);
+}
+function computeCustomAlignment(data) {
+	if (isUnstruct(data)) {
+		const firstProp = Object.values(data.propTypes)[0];
+		return firstProp ? customAlignmentOf(firstProp) : 1;
+	}
+	if (isDisarray(data)) return customAlignmentOf(data.elementType);
+	if (isLooseDecorated(data)) return getCustomAlignment(data) ?? customAlignmentOf(data.inner);
+	return getCustomAlignment(data) ?? 1;
+}
+/**
+* Since alignments can be inferred from data types, they are not stored on them.
+* Instead, this weak map acts as an extended property of those data types.
+*/
+const cachedAlignments = /* @__PURE__ */ new WeakMap();
+const cachedCustomAlignments = /* @__PURE__ */ new WeakMap();
+function alignmentOf(data) {
+	let alignment = cachedAlignments.get(data);
+	if (alignment === void 0) {
+		alignment = computeAlignment(data);
+		cachedAlignments.set(data, alignment);
+	}
+	return alignment;
+}
+function customAlignmentOf(data) {
+	let alignment = cachedCustomAlignments.get(data);
+	if (alignment === void 0) {
+		alignment = computeCustomAlignment(data);
+		cachedCustomAlignments.set(data, alignment);
+	}
+	return alignment;
+}
+/**
+* Returns the alignment (in bytes) of data represented by the `schema`.
+*/
+function PUBLIC_alignmentOf(schema) {
+	return alignmentOf(schema);
+}
+
+//#endregion
+export { PUBLIC_alignmentOf, alignmentOf, customAlignmentOf };

package/data/array.d.ts

@@ -0,0 +1,28 @@
+import { AnyWgslData, WgslArray } from "./wgslTypes.js";
+import { TgpuComptime } from "../core/function/comptime.js";
+import "../indexNamedExports.js";
+
+//#region src/data/array.d.ts
+interface WgslArrayConstructor {
+  <TElement extends AnyWgslData>(elementType: TElement): (elementCount: number) => WgslArray<TElement>;
+  <TElement extends AnyWgslData>(elementType: TElement, elementCount: number): WgslArray<TElement>;
+}
+/**
+ * Creates an array schema that can be used to construct gpu buffers.
+ * Describes arrays with fixed-size length, storing elements of the same type.
+ *
+ * @example
+ * const LENGTH = 3;
+ * const array = d.arrayOf(d.u32, LENGTH);
+ *
+ * If `elementCount` is not specified, a partially applied function is returned.
+ * @example
+ * const array = d.arrayOf(d.vec3f);
+ * //    ^? (n: number) => WgslArray<d.Vec3f>
+ *
+ * @param elementType The type of elements in the array.
+ * @param elementCount The number of elements in the array.
+ */
+declare const arrayOf: TgpuComptime<WgslArrayConstructor>;
+//#endregion
+export { arrayOf };

package/data/array.js

@@ -0,0 +1,48 @@
+import { $internal } from "../shared/symbols.js";
+import { schemaCallWrapper } from "./schemaCallWrapper.js";
+import { sizeOf } from "./sizeOf.js";
+import { comptime } from "../core/function/comptime.js";
+
+//#region src/data/array.ts
+/**
+* Creates an array schema that can be used to construct gpu buffers.
+* Describes arrays with fixed-size length, storing elements of the same type.
+*
+* @example
+* const LENGTH = 3;
+* const array = d.arrayOf(d.u32, LENGTH);
+*
+* If `elementCount` is not specified, a partially applied function is returned.
+* @example
+* const array = d.arrayOf(d.vec3f);
+* //    ^? (n: number) => WgslArray<d.Vec3f>
+*
+* @param elementType The type of elements in the array.
+* @param elementCount The number of elements in the array.
+*/
+const arrayOf = comptime(((elementType, elementCount) => {
+	if (elementCount === void 0) return comptime((count) => cpu_arrayOf(elementType, count));
+	return cpu_arrayOf(elementType, elementCount);
+})).$name("arrayOf");
+function cpu_arrayOf(elementType, elementCount) {
+	const arraySchema = (elements) => {
+		if (elements && elements.length !== elementCount) throw new Error(`Array schema of ${elementCount} elements of type ${elementType.type} called with ${elements.length} argument(s).`);
+		return Array.from({ length: elementCount }, (_, i) => schemaCallWrapper(elementType, elements?.[i]));
+	};
+	Object.setPrototypeOf(arraySchema, WgslArrayImpl);
+	if (Number.isNaN(sizeOf(elementType))) throw new Error("Cannot nest runtime sized arrays.");
+	arraySchema.elementType = elementType;
+	if (!Number.isInteger(elementCount) || elementCount < 0) throw new Error(`Cannot create array schema with invalid element count: ${elementCount}.`);
+	arraySchema.elementCount = elementCount;
+	return arraySchema;
+}
+const WgslArrayImpl = {
+	[$internal]: true,
+	type: "array",
+	toString() {
+		return `arrayOf(${this.elementType}, ${this.elementCount})`;
+	}
+};
+
+//#endregion
+export { arrayOf };

package/data/atomic.d.ts

@@ -0,0 +1,15 @@
+import { Atomic, I32, U32 } from "./wgslTypes.js";
+
+//#region src/data/atomic.d.ts
+/**
+ * Marks a concrete integer scalar type schema (u32 or i32) as a WGSL atomic.
+ *
+ * @example
+ * const atomicU32 = d.atomic(d.u32);
+ * const atomicI32 = d.atomic(d.i32);
+ *
+ * @param data Underlying type schema.
+ */
+declare function atomic<TSchema extends U32 | I32>(data: TSchema): Atomic<TSchema>;
+//#endregion
+export { atomic };

package/data/atomic.js

@@ -0,0 +1,25 @@
+import { $internal } from "../shared/symbols.js";
+
+//#region src/data/atomic.ts
+/**
+* Marks a concrete integer scalar type schema (u32 or i32) as a WGSL atomic.
+*
+* @example
+* const atomicU32 = d.atomic(d.u32);
+* const atomicI32 = d.atomic(d.i32);
+*
+* @param data Underlying type schema.
+*/
+function atomic(data) {
+	return new AtomicImpl(data);
+}
+var AtomicImpl = class {
+	[$internal] = {};
+	type = "atomic";
+	constructor(inner) {
+		this.inner = inner;
+	}
+};
+
+//#endregion
+export { atomic };

package/data/attributes.d.ts

@@ -0,0 +1,121 @@
+import { Align, AnyWgslData, BaseData, Builtin, Decorated, FlatInterpolatableData, FlatInterpolationType, Interpolate, Invariant, IsWgslData, Location, PerspectiveOrLinearInterpolatableData, PerspectiveOrLinearInterpolationType, Size, Vec4f } from "./wgslTypes.js";
+import { AnyData, AnyLooseData, IsLooseData, LooseDecorated, Undecorate } from "./dataTypes.js";
+
+//#region src/data/attributes.d.ts
+declare const builtinNames: readonly ["vertex_index", "instance_index", "clip_distances", "position", "front_facing", "frag_depth", "primitive_index", "sample_index", "sample_mask", "fragment", "local_invocation_id", "local_invocation_index", "global_invocation_id", "workgroup_id", "num_workgroups", "subgroup_invocation_id", "subgroup_size", "subgroup_id", "num_subgroups"];
+type BuiltinName = (typeof builtinNames)[number];
+type AnyAttribute<AllowedBuiltins extends Builtin<BuiltinName> = Builtin<BuiltinName>> = Align<number> | Size<number> | Location | Interpolate | Invariant | AllowedBuiltins;
+type ExtractAttributes<T> = T extends {
+  readonly attribs: unknown[];
+} ? T['attribs'] : [];
+/**
+ * Decorates a data-type `TData` with an attribute `TAttrib`.
+ *
+ * - if `TData` is loose
+ *   - if `TData` is already `LooseDecorated`
+ *     - Prepend `TAttrib` to the existing attribute tuple.
+ *   - else
+ *     - Wrap `TData` with `LooseDecorated` and a single attribute `[TAttrib]`
+ * - else
+ *   - if `TData` is already `Decorated`
+ *     - Prepend `TAttrib` to the existing attribute tuple.
+ *   - else
+ *     - Wrap `TData` with `Decorated` and a single attribute `[TAttrib]`
+ */
+type Decorate<TData extends BaseData, TAttrib extends AnyAttribute> = IsWgslData<TData> extends true ? Decorated<Undecorate<TData>, [TAttrib, ...ExtractAttributes<TData>]> : IsLooseData<TData> extends true ? LooseDecorated<Undecorate<TData>, [TAttrib, ...ExtractAttributes<TData>]> : never;
+type IsBuiltin<T> = ExtractAttributes<T>[number] extends [] ? false : ExtractAttributes<T>[number] extends Builtin<BuiltinName> ? true : false;
+type HasCustomLocation<T> = ExtractAttributes<T>[number] extends [] ? false : ExtractAttributes<T>[number] extends Location ? true : false;
+/**
+ * Gives the wrapped data-type a custom byte alignment. Useful in order to
+ * fulfill uniform alignment requirements.
+ *
+ * @example
+ * const Data = d.struct({
+ *   a: u32, // takes up 4 bytes
+ *   // 12 bytes of padding, because `b` is custom aligned to multiples of 16 bytes
+ *   b: d.align(16, u32),
+ * });
+ *
+ * @param alignment The multiple of bytes this data should align itself to.
+ * @param data The data-type to align.
+ */
+declare function align<TAlign extends number, TData extends AnyData>(alignment: TAlign, data: TData): Decorate<TData, Align<TAlign>>;
+/**
+ * Adds padding bytes after the wrapped data-type, until the whole value takes up `size` bytes.
+ *
+ * @example
+ * const Data = d.struct({
+ *   a: d.size(16, u32), // takes up 16 bytes, instead of 4
+ *   b: u32, // starts at byte 16, because `a` has a custom size
+ * });
+ *
+ * @param size The amount of bytes that should be reserved for this data-type.
+ * @param data The data-type to wrap.
+ */
+declare function size<TSize extends number, TData extends AnyData>(size: TSize, data: TData): Decorate<TData, Size<TSize>>;
+/**
+ * Assigns an explicit numeric location to a struct member or a parameter that has this type.
+ *
+ * @example
+ * const VertexOutput = {
+ *   a: d.u32, // has implicit location 0
+ *   b: d.location(5, d.u32),
+ *   c: d.u32, // has implicit location 6
+ * };
+ *
+ * @param location The explicit numeric location.
+ * @param data The data-type to wrap.
+ */
+declare function location<TLocation extends number, TData extends BaseData>(location: TLocation, data: TData): Decorate<TData, Location<TLocation>>;
+/**
+ * Specifies how user-defined vertex shader output (fragment shader input)
+ * must be interpolated.
+ *
+ * Tip: Integer outputs cannot be interpolated.
+ *
+ * @example
+ * const VertexOutput = {
+ *   a: d.f32, // has implicit 'perspective, center' interpolation
+ *   b: d.interpolate('linear, sample', d.f32),
+ * };
+ *
+ * @param interpolationType How data should be interpolated.
+ * @param data The data-type to wrap.
+ */
+declare function interpolate<TInterpolation extends PerspectiveOrLinearInterpolationType, TData extends PerspectiveOrLinearInterpolatableData>(interpolationType: TInterpolation, data: TData): Decorate<TData, Interpolate<TInterpolation>>;
+/**
+ * Specifies how user-defined vertex shader output (fragment shader input)
+ * must be interpolated.
+ *
+ * Tip: Default sampling method of `flat` is `first`. Unless you specifically
+ * need deterministic behavior provided by `'flat, first'`, prefer explicit
+ * `'flat, either'` as it could be slightly faster in hardware.
+ *
+ * @example
+ * const VertexOutput = {
+ *   a: d.f32, // has implicit 'perspective, center' interpolation
+ *   b: d.interpolate('flat, either', d.u32), // integer outputs cannot interpolate
+ * };
+ *
+ * @param interpolationType How data should be interpolated.
+ * @param data The data-type to wrap.
+ */
+declare function interpolate<TInterpolation extends FlatInterpolationType, TData extends FlatInterpolatableData>(interpolationType: TInterpolation, data: TData): Decorate<TData, Interpolate<TInterpolation>>;
+/**
+ * Marks a position built-in output value as invariant in vertex shaders.
+ * If the data and control flow match for two position outputs in different
+ * entry points, then the result values are guaranteed to be the same.
+ *
+ * Must only be applied to the position built-in value.
+ *
+ * @example
+ * const VertexOutput = {
+ *   pos: d.invariant(d.builtin.position),
+ * };
+ *
+ * @param data The position built-in data-type to mark as invariant.
+ */
+declare function invariant(data: Decorated<Vec4f, [Builtin<'position'>]>): Decorated<Vec4f, [Builtin<'position'>, Invariant]>;
+declare function isBuiltin(value: unknown): value is Decorated<AnyWgslData, AnyAttribute[]> | LooseDecorated<AnyLooseData, AnyAttribute[]>;
+//#endregion
+export { AnyAttribute, Decorate, HasCustomLocation, IsBuiltin, align, interpolate, invariant, isBuiltin, location, size };

package/data/attributes.js

@@ -0,0 +1,145 @@
+import { $internal } from "../shared/symbols.js";
+import { isAlignAttrib, isBuiltinAttrib, isDecorated, isSizeAttrib, isWgslData } from "./wgslTypes.js";
+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]);
+	if (isLooseDecorated(data)) return new LooseDecoratedImpl(data.inner, [attrib, ...data.attribs]);
+	if (isLooseData(data)) return new LooseDecoratedImpl(data, [attrib]);
+	return new DecoratedImpl(data, [attrib]);
+}
+/**
+* Gives the wrapped data-type a custom byte alignment. Useful in order to
+* fulfill uniform alignment requirements.
+*
+* @example
+* const Data = d.struct({
+*   a: u32, // takes up 4 bytes
+*   // 12 bytes of padding, because `b` is custom aligned to multiples of 16 bytes
+*   b: d.align(16, u32),
+* });
+*
+* @param alignment The multiple of bytes this data should align itself to.
+* @param data The data-type to align.
+*/
+function align(alignment, data) {
+	return attribute(data, {
+		[$internal]: true,
+		type: "@align",
+		params: [alignment]
+	});
+}
+/**
+* Adds padding bytes after the wrapped data-type, until the whole value takes up `size` bytes.
+*
+* @example
+* const Data = d.struct({
+*   a: d.size(16, u32), // takes up 16 bytes, instead of 4
+*   b: u32, // starts at byte 16, because `a` has a custom size
+* });
+*
+* @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) {
+	return attribute(data, {
+		[$internal]: true,
+		type: "@size",
+		params: [size]
+	});
+}
+/**
+* Assigns an explicit numeric location to a struct member or a parameter that has this type.
+*
+* @example
+* const VertexOutput = {
+*   a: d.u32, // has implicit location 0
+*   b: d.location(5, d.u32),
+*   c: d.u32, // has implicit location 6
+* };
+*
+* @param location The explicit numeric location.
+* @param data The data-type to wrap.
+*/
+function location(location, data) {
+	return attribute(data, {
+		[$internal]: true,
+		type: "@location",
+		params: [location]
+	});
+}
+function interpolate(interpolationType, data) {
+	return attribute(data, {
+		[$internal]: true,
+		type: "@interpolate",
+		params: [interpolationType]
+	});
+}
+/**
+* Marks a position built-in output value as invariant in vertex shaders.
+* If the data and control flow match for two position outputs in different
+* entry points, then the result values are guaranteed to be the same.
+*
+* Must only be applied to the position built-in value.
+*
+* @example
+* const VertexOutput = {
+*   pos: d.invariant(d.builtin.position),
+* };
+*
+* @param data The position built-in data-type to mark as invariant.
+*/
+function invariant(data) {
+	if (!isBuiltin(data)) throw new Error("The @invariant attribute must only be applied to the position built-in value.");
+	const builtinAttrib = isDecorated(data) || isLooseDecorated(data) ? data.attribs.find(isBuiltinAttrib) : void 0;
+	if (!builtinAttrib || builtinAttrib.params[0] !== "position") throw new Error("The @invariant attribute must only be applied to the position built-in value.");
+	return attribute(data, {
+		[$internal]: true,
+		type: "@invariant",
+		params: []
+	});
+}
+function isBuiltin(value) {
+	return (isDecorated(value) || isLooseDecorated(value)) && value.attribs.find(isBuiltinAttrib) !== void 0;
+}
+function getAttributesString(field) {
+	if (!isDecorated(field) && !isLooseDecorated(field)) return "";
+	return field.attribs.map((attrib) => {
+		if (attrib.params.length === 0) return `${attrib.type} `;
+		return `${attrib.type}(${attrib.params.join(", ")}) `;
+	}).join("");
+}
+var BaseDecoratedImpl = class {
+	[$internal] = {};
+	constructor(inner, attribs) {
+		this.inner = inner;
+		this.attribs = attribs;
+		const alignAttrib = attribs.find(isAlignAttrib)?.params[0];
+		const sizeAttrib = attribs.find(isSizeAttrib)?.params[0];
+		if (alignAttrib !== void 0) {
+			if (alignAttrib <= 0) throw new Error(`Custom data alignment must be a positive number, got: ${alignAttrib}.`);
+			if (Math.log2(alignAttrib) % 1 !== 0) throw new Error(`Alignment has to be a power of 2, got: ${alignAttrib}.`);
+			if (isWgslData(this.inner)) {
+				if (alignAttrib % alignmentOf(this.inner) !== 0) throw new Error(`Custom alignment has to be a multiple of the standard data alignment. Got: ${alignAttrib}, expected multiple of: ${alignmentOf(this.inner)}.`);
+			}
+		}
+		if (sizeAttrib !== void 0) {
+			if (sizeAttrib < sizeOf(this.inner)) throw new Error(`Custom data size cannot be smaller then the standard data size. Got: ${sizeAttrib}, expected at least: ${sizeOf(this.inner)}.`);
+			if (sizeAttrib <= 0) throw new Error(`Custom data size must be a positive number. Got: ${sizeAttrib}.`);
+		}
+	}
+};
+var DecoratedImpl = class extends BaseDecoratedImpl {
+	[$internal] = {};
+	type = "decorated";
+};
+var LooseDecoratedImpl = class extends BaseDecoratedImpl {
+	[$internal] = {};
+	type = "loose-decorated";
+};
+
+//#endregion
+export { align, attribute, getAttributesString, interpolate, invariant, isBuiltin, location, size };

package/data/autoStruct.d.ts

@@ -0,0 +1,3 @@
+import "./snippet.js";
+import "../types.js";
+import "./wgslTypes.js";