typegpu 0.11.9 → 0.12.1

package/shared/symbols.d.ts

@@ -1,70 +1,76 @@
-//#region src/shared/symbols.d.ts
-declare const $internal: unique symbol;
+export declare const $internal: unique symbol;
+/** A plain record of all definitional state of a resource, surviving transfer between runtimes */
+export declare const $soul: unique symbol;
 /**
  * The getter to the value of this resource, accessible on the GPU
  */
-declare const $gpuValueOf: unique symbol;
+export declare const $gpuValueOf: unique symbol;
 /**
  * If this symbol is present, this means that getName and setName
  * will refer to object behind this property instead.
  */
-declare const $getNameForward: unique symbol;
+export declare const $getNameForward: unique symbol;
 /**
  * Marks an object with slot-value bindings
  */
-declare const $providing: unique symbol;
-declare const $resolve: unique symbol;
+export declare const $providing: unique symbol;
+/**
+ * Objects can provide the snippet that represents them.
+ */
+export declare const $ownSnippet: unique symbol;
+export declare const $resolve: unique symbol;
 /**
  * A way for a schema to provide casting behavior, without the need to be explicitly
  * callable by the end-user (e.g. vertex formats)
  */
-declare const $cast: unique symbol;
+export declare const $cast: unique symbol;
 /**
  * Can be called on the GPU
  */
-declare const $gpuCallable: unique symbol;
+export declare const $gpuCallable: unique symbol;
 /**
  * Type token for the inferred (CPU & GPU) representation of a resource
  */
-declare const $repr: unique symbol;
+export declare const $repr: unique symbol;
 /**
  * Type token for the inferred (GPU-side) representation of a resource
  * If present, it shadows the value of `$repr` for GPU-side inference.
  */
-declare const $gpuRepr: unique symbol;
+export declare const $gpuRepr: unique symbol;
 /**
  * Type token for the inferred partial representation of a resource.
  * If present, it shadows the value of `$repr` for use in partial IO.
  */
-declare const $reprPartial: unique symbol;
+export declare const $reprPartial: unique symbol;
 /**
  * Type token for the inferred patch representation of a resource.
  * Used by the `buffer.patch` API with `Record<number, T>` sparse arrays.
  */
-declare const $reprPatch: unique symbol;
+export declare const $reprPatch: unique symbol;
 /**
  * Type token for the write-side (input) representation of a resource.
  */
-declare const $inRepr: unique symbol;
+export declare const $inRepr: unique symbol;
 /**
  * Type token holding schemas that are identical in memory layout.
  */
-declare const $memIdent: unique symbol;
+export declare const $memIdent: unique symbol;
 /**
  * Type token, signaling that a schema can be used in a storage buffer.
  */
-declare const $validStorageSchema: unique symbol;
+export declare const $validStorageSchema: unique symbol;
 /**
  * Type token, signaling that a schema can be used in a uniform buffer.
  */
-declare const $validUniformSchema: unique symbol;
+export declare const $validUniformSchema: unique symbol;
 /**
  * Type token, signaling that a schema can be used in a vertex buffer.
  */
-declare const $validVertexSchema: unique symbol;
+export declare const $validVertexSchema: unique symbol;
 /**
  * Type token, containing a reason for why the schema is invalid (if it is).
  */
-declare const $invalidSchemaReason: unique symbol;
-//#endregion
-export { $cast, $getNameForward, $gpuCallable, $gpuRepr, $gpuValueOf, $inRepr, $internal, $invalidSchemaReason, $memIdent, $providing, $repr, $reprPartial, $reprPatch, $resolve, $validStorageSchema, $validUniformSchema, $validVertexSchema };
+export declare const $invalidSchemaReason: unique symbol;
+export declare function isMarkedInternal(value: unknown): value is {
+    [$internal]: Record<string, unknown> | true;
+};

package/shared/symbols.js

@@ -1,80 +1,80 @@
-import { version } from "../package.js";
-
-//#region src/shared/symbols.ts
-const $internal = Symbol(`typegpu:${version}:$internal`);
-/**
-* The getter to the value of this resource, accessible on the GPU
-*/
-const $gpuValueOf = Symbol(`typegpu:${version}:$gpuValueOf`);
-/**
-* If this symbol is present, this means that getName and setName
-* will refer to object behind this property instead.
-*/
-const $getNameForward = Symbol(`typegpu:${version}:$getNameForward`);
-/**
-* Marks an object with slot-value bindings
-*/
-const $providing = Symbol(`typegpu:${version}:$providing`);
-/**
-* Objects can provide the snippet that represents them.
-*/
-const $ownSnippet = Symbol(`typegpu:${version}:$ownSnippet`);
-const $resolve = Symbol(`typegpu:${version}:$resolve`);
-/**
-* A way for a schema to provide casting behavior, without the need to be explicitly
-* callable by the end-user (e.g. vertex formats)
-*/
-const $cast = Symbol(`typegpu:${version}:$cast`);
-/**
-* Can be called on the GPU
-*/
-const $gpuCallable = Symbol(`typegpu:${version}:$gpuCallable`);
-/**
-* Type token for the inferred (CPU & GPU) representation of a resource
-*/
-const $repr = Symbol(`typegpu:${version}:$repr`);
-/**
-* Type token for the inferred (GPU-side) representation of a resource
-* If present, it shadows the value of `$repr` for GPU-side inference.
-*/
-const $gpuRepr = Symbol(`typegpu:${version}:$gpuRepr`);
-/**
-* Type token for the inferred partial representation of a resource.
-* If present, it shadows the value of `$repr` for use in partial IO.
-*/
-const $reprPartial = Symbol(`typegpu:${version}:$reprPartial`);
-/**
-* Type token for the inferred patch representation of a resource.
-* Used by the `buffer.patch` API with `Record<number, T>` sparse arrays.
-*/
-const $reprPatch = Symbol(`typegpu:${version}:$reprPatch`);
-/**
-* Type token for the write-side (input) representation of a resource.
-*/
-const $inRepr = Symbol(`typegpu:${version}:$inRepr`);
-/**
-* Type token holding schemas that are identical in memory layout.
-*/
-const $memIdent = Symbol(`typegpu:${version}:$memIdent`);
-/**
-* Type token, signaling that a schema can be used in a storage buffer.
-*/
-const $validStorageSchema = Symbol(`typegpu:${version}:$invalidStorageSchema`);
-/**
-* Type token, signaling that a schema can be used in a uniform buffer.
-*/
-const $validUniformSchema = Symbol(`typegpu:${version}:$validUniformSchema`);
-/**
-* Type token, signaling that a schema can be used in a vertex buffer.
-*/
-const $validVertexSchema = Symbol(`typegpu:${version}:$validVertexSchema`);
-/**
-* Type token, containing a reason for why the schema is invalid (if it is).
-*/
-const $invalidSchemaReason = Symbol(`typegpu:${version}:$invalidSchemaReason`);
-function isMarkedInternal(value) {
-	return !!value?.[$internal];
+const version = "0.12.1";
+export const $internal = Symbol(`typegpu:${version}:$internal`);
+/** A plain record of all definitional state of a resource, surviving transfer between runtimes */
+export const $soul = Symbol(`typegpu:${version}:$soul`);
+/**
+ * The getter to the value of this resource, accessible on the GPU
+ */
+export const $gpuValueOf = Symbol(`typegpu:${version}:$gpuValueOf`);
+/**
+ * If this symbol is present, this means that getName and setName
+ * will refer to object behind this property instead.
+ */
+export const $getNameForward = Symbol(`typegpu:${version}:$getNameForward`);
+/**
+ * Marks an object with slot-value bindings
+ */
+export const $providing = Symbol(`typegpu:${version}:$providing`);
+/**
+ * Objects can provide the snippet that represents them.
+ */
+export const $ownSnippet = Symbol(`typegpu:${version}:$ownSnippet`);
+export const $resolve = Symbol(`typegpu:${version}:$resolve`);
+/**
+ * A way for a schema to provide casting behavior, without the need to be explicitly
+ * callable by the end-user (e.g. vertex formats)
+ */
+export const $cast = Symbol(`typegpu:${version}:$cast`);
+/**
+ * Can be called on the GPU
+ */
+export const $gpuCallable = Symbol(`typegpu:${version}:$gpuCallable`);
+//
+// Type tokens
+//
+/**
+ * Type token for the inferred (CPU & GPU) representation of a resource
+ */
+export const $repr = Symbol(`typegpu:${version}:$repr`);
+/**
+ * Type token for the inferred (GPU-side) representation of a resource
+ * If present, it shadows the value of `$repr` for GPU-side inference.
+ */
+export const $gpuRepr = Symbol(`typegpu:${version}:$gpuRepr`);
+/**
+ * Type token for the inferred partial representation of a resource.
+ * If present, it shadows the value of `$repr` for use in partial IO.
+ */
+export const $reprPartial = Symbol(`typegpu:${version}:$reprPartial`);
+/**
+ * Type token for the inferred patch representation of a resource.
+ * Used by the `buffer.patch` API with `Record<number, T>` sparse arrays.
+ */
+export const $reprPatch = Symbol(`typegpu:${version}:$reprPatch`);
+/**
+ * Type token for the write-side (input) representation of a resource.
+ */
+export const $inRepr = Symbol(`typegpu:${version}:$inRepr`);
+/**
+ * Type token holding schemas that are identical in memory layout.
+ */
+export const $memIdent = Symbol(`typegpu:${version}:$memIdent`);
+/**
+ * Type token, signaling that a schema can be used in a storage buffer.
+ */
+export const $validStorageSchema = Symbol(`typegpu:${version}:$invalidStorageSchema`);
+/**
+ * Type token, signaling that a schema can be used in a uniform buffer.
+ */
+export const $validUniformSchema = Symbol(`typegpu:${version}:$validUniformSchema`);
+/**
+ * Type token, signaling that a schema can be used in a vertex buffer.
+ */
+export const $validVertexSchema = Symbol(`typegpu:${version}:$validVertexSchema`);
+/**
+ * Type token, containing a reason for why the schema is invalid (if it is).
+ */
+export const $invalidSchemaReason = Symbol(`typegpu:${version}:$invalidSchemaReason`);
+export function isMarkedInternal(value) {
+    return !!value?.[$internal];
 }
-
-//#endregion
-export { $cast, $getNameForward, $gpuCallable, $gpuValueOf, $internal, $ownSnippet, $providing, $repr, $resolve, isMarkedInternal };

package/shared/tseynit.d.ts

@@ -0,0 +1,2 @@
+import * as tinyest from 'tinyest';
+export declare function stringifyNode(node: tinyest.AnyNode): string;

package/shared/tseynit.js

@@ -1,90 +1,175 @@
-import * as tinyest from "tinyest";
-
-//#region src/shared/tseynit.ts
+import * as tinyest from 'tinyest';
 const { NodeTypeCatalog: NODE } = tinyest;
-function stringifyNode(node) {
-	if (isExpression(node)) return stringifyExpression(node, "");
-	return stringifyStatement(node, "");
+export function stringifyNode(node) {
+    if (isExpression(node)) {
+        return stringifyExpression(node, '');
+    }
+    return stringifyStatement(node, '');
 }
 function stringifyStatement(node, ident) {
-	if (isExpression(node)) return `${ident}${stringifyExpression(node, ident)};`;
-	if (node[0] === NODE.block) return `{\n${node[1].map((n) => stringifyStatement(n, ident + "  ")).join("\n")}\n${ident}}`;
-	if (node[0] === NODE.return) return `${ident}return${node[1] === void 0 ? "" : ` ${stringifyExpression(node[1], "")}`};`;
-	if (node[0] === NODE.if) {
-		const base = `${ident}if (${stringifyExpression(node[1], ident)}) ${stringifyStatement(node[2], ident)}`;
-		if (node[3] !== void 0) return `${base} else ${stringifyStatement(node[3], ident)}`;
-		return base;
-	}
-	if (node[0] === NODE.let) {
-		if (node[2] !== void 0) return `${ident}let ${node[1]} = ${stringifyExpression(node[2], ident)};`;
-		return `${ident}let ${node[1]};`;
-	}
-	if (node[0] === NODE.const) {
-		if (node[2] !== void 0) return `${ident}const ${node[1]} = ${stringifyExpression(node[2], ident)};`;
-		return `${ident}const ${node[1]};`;
-	}
-	if (node[0] === NODE.for) {
-		const init = node[1] ? stringifyStatement(node[1], "") : ";";
-		const cond = node[2] ? stringifyExpression(node[2], ident) : "";
-		const update = node[3] ? stringifyStatement(node[3], "") : "";
-		const body = stringifyStatement(node[4], ident);
-		return `${ident}for (${init} ${cond}; ${update.slice(0, -1)}) ${body}`;
-	}
-	if (node[0] === NODE.while) return `${ident}while (${stringifyExpression(node[1], ident)}) ${stringifyStatement(node[2], ident)}`;
-	if (node[0] === NODE.continue) return `${ident}continue;`;
-	if (node[0] === NODE.break) return `${ident}break;`;
-	if (node[0] === NODE.forOf) return `${ident}for (${node[1][0] === NODE.const ? "const" : "let"} ${node[1][1]} of ${stringifyExpression(node[2], ident)}) ${stringifyStatement(node[3], ident)}`;
-	assertExhaustive(node);
+    if (isExpression(node)) {
+        return `${ident}${stringifyExpression(node, ident)};`;
+    }
+    if (node[0] === NODE.block) {
+        const statements = node[1].map((n) => stringifyStatement(n, ident + '  '));
+        return `{\n${statements.join('\n')}\n${ident}}`;
+    }
+    if (node[0] === NODE.return) {
+        const expr = node[1] === undefined ? '' : ` ${stringifyExpression(node[1], '')}`;
+        return `${ident}return${expr};`;
+    }
+    if (node[0] === NODE.if) {
+        const cond = stringifyExpression(node[1], ident);
+        const then = stringifyStatement(node[2], ident);
+        const base = `${ident}if (${cond}) ${then}`;
+        if (node[3] !== undefined) {
+            return `${base} else ${stringifyStatement(node[3], ident)}`;
+        }
+        return base;
+    }
+    if (node[0] === NODE.let) {
+        if (node[2] !== undefined) {
+            return `${ident}let ${node[1]} = ${stringifyExpression(node[2], ident)};`;
+        }
+        return `${ident}let ${node[1]};`;
+    }
+    if (node[0] === NODE.const) {
+        if (node[2] !== undefined) {
+            return `${ident}const ${node[1]} = ${stringifyExpression(node[2], ident)};`;
+        }
+        return `${ident}const ${node[1]};`;
+    }
+    if (node[0] === NODE.for) {
+        const init = node[1] ? stringifyStatement(node[1], '') : ';';
+        const cond = node[2] ? stringifyExpression(node[2], ident) : '';
+        const update = node[3] ? stringifyStatement(node[3], '') : '';
+        const body = stringifyStatement(node[4], ident);
+        return `${ident}for (${init} ${cond}; ${update.slice(0, -1) /* trim the ';' */}) ${body}`;
+    }
+    if (node[0] === NODE.while) {
+        const cond = stringifyExpression(node[1], ident);
+        const body = stringifyStatement(node[2], ident);
+        return `${ident}while (${cond}) ${body}`;
+    }
+    if (node[0] === NODE.continue) {
+        return `${ident}continue;`;
+    }
+    if (node[0] === NODE.break) {
+        return `${ident}break;`;
+    }
+    if (node[0] === NODE.forOf) {
+        const leftKind = node[1][0] === NODE.const ? 'const' : 'let';
+        const leftName = node[1][1];
+        const right = stringifyExpression(node[2], ident);
+        const body = stringifyStatement(node[3], ident);
+        return `${ident}for (${leftKind} ${leftName} of ${right}) ${body}`;
+    }
+    assertExhaustive(node);
 }
 function stringifyExpression(node, ident) {
-	if (typeof node === "string") return node;
-	if (typeof node === "boolean") return `${node}`;
-	if (node[0] === NODE.numericLiteral) return node[1];
-	if (node[0] === NODE.stringLiteral) return JSON.stringify(node[1]);
-	if (node[0] === NODE.arrayExpr) return `[${node[1].map((n) => stringifyExpression(n, ident)).join(", ")}]`;
-	if (node[0] === NODE.binaryExpr) return `${wrapIfComplex(node[1], ident)} ${node[2]} ${wrapIfComplex(node[3], ident)}`;
-	if (node[0] === NODE.assignmentExpr) return `${stringifyExpression(node[1], ident)} ${node[2]} ${stringifyExpression(node[3], ident)}`;
-	if (node[0] === NODE.logicalExpr) return `${wrapIfComplex(node[1], ident)} ${node[2]} ${wrapIfComplex(node[3], ident)}`;
-	if (node[0] === NODE.unaryExpr) {
-		const sep = node[1].length > 1 ? " " : "";
-		return `${node[1]}${sep}${wrapIfComplex(node[2], ident)}`;
-	}
-	if (node[0] === NODE.call) return `${wrapIfComplex(node[1], ident)}(${node[2].map((n) => stringifyExpression(n, ident)).join(", ")})`;
-	if (node[0] === NODE.memberAccess) {
-		if (Array.isArray(node[1]) && node[1][0] === NODE.numericLiteral) return `(${stringifyExpression(node[1], ident)}).${node[2]}`;
-		return `${wrapIfComplex(node[1], ident)}.${node[2]}`;
-	}
-	if (node[0] === NODE.indexAccess) return `${wrapIfComplex(node[1], ident)}[${stringifyExpression(node[2], ident)}]`;
-	if (node[0] === NODE.preUpdate) return `${node[1]}${wrapIfComplex(node[2], ident)}`;
-	if (node[0] === NODE.postUpdate) return `${wrapIfComplex(node[2], ident)}${node[1]}`;
-	if (node[0] === NODE.objectExpr) return `{ ${Object.entries(node[1]).map(([key, val]) => `${key}: ${stringifyExpression(val, ident)}`).join(", ")} }`;
-	if (node[0] === NODE.conditionalExpr) return `${wrapIfComplex(node[1], ident)} ? ${wrapIfComplex(node[2], ident)} : ${wrapIfComplex(node[3], ident)}`;
-	assertExhaustive(node);
+    if (typeof node === 'string') {
+        return node;
+    }
+    if (typeof node === 'boolean') {
+        return `${node}`;
+    }
+    if (node[0] === NODE.numericLiteral) {
+        return node[1];
+    }
+    if (node[0] === NODE.stringLiteral) {
+        return JSON.stringify(node[1]);
+    }
+    if (node[0] === NODE.arrayExpr) {
+        const elements = node[1].map((n) => stringifyExpression(n, ident));
+        return `[${elements.join(', ')}]`;
+    }
+    if (node[0] === NODE.binaryExpr) {
+        return `${wrapIfComplex(node[1], ident)} ${node[2]} ${wrapIfComplex(node[3], ident)}`;
+    }
+    if (node[0] === NODE.assignmentExpr) {
+        return `${stringifyExpression(node[1], ident)} ${node[2]} ${stringifyExpression(node[3], ident)}`;
+    }
+    if (node[0] === NODE.logicalExpr) {
+        return `${wrapIfComplex(node[1], ident)} ${node[2]} ${wrapIfComplex(node[3], ident)}`;
+    }
+    if (node[0] === NODE.unaryExpr) {
+        // Unary word operators like void, instanceof and delete require a space
+        const sep = node[1].length > 1 ? ' ' : '';
+        return `${node[1]}${sep}${wrapIfComplex(node[2], ident)}`;
+    }
+    if (node[0] === NODE.call) {
+        const callee = wrapIfComplex(node[1], ident);
+        const args = node[2].map((n) => stringifyExpression(n, ident)).join(', ');
+        return `${callee}(${args})`;
+    }
+    if (node[0] === NODE.memberAccess) {
+        if (Array.isArray(node[1]) && node[1][0] === NODE.numericLiteral) {
+            return `(${stringifyExpression(node[1], ident)}).${node[2]}`;
+        }
+        return `${wrapIfComplex(node[1], ident)}.${node[2]}`;
+    }
+    if (node[0] === NODE.indexAccess) {
+        return `${wrapIfComplex(node[1], ident)}[${stringifyExpression(node[2], ident)}]`;
+    }
+    if (node[0] === NODE.preUpdate) {
+        return `${node[1]}${wrapIfComplex(node[2], ident)}`;
+    }
+    if (node[0] === NODE.postUpdate) {
+        return `${wrapIfComplex(node[2], ident)}${node[1]}`;
+    }
+    if (node[0] === NODE.objectExpr) {
+        const entries = Object.entries(node[1]).map(([key, val]) => `${key}: ${stringifyExpression(val, ident)}`);
+        return `{ ${entries.join(', ')} }`;
+    }
+    if (node[0] === NODE.conditionalExpr) {
+        return `${wrapIfComplex(node[1], ident)} ? ${wrapIfComplex(node[2], ident)} : ${wrapIfComplex(node[3], ident)}`;
+    }
+    assertExhaustive(node);
 }
 function assertExhaustive(value) {
-	throw new Error(`'${JSON.stringify(value)}' was not handled by the stringify function.`);
+    throw new Error(`'${JSON.stringify(value)}' was not handled by the stringify function.`);
 }
 function isExpression(node) {
-	if (typeof node === "string" || typeof node === "boolean" || node[0] === NODE.numericLiteral || node[0] === NODE.stringLiteral || node[0] === NODE.arrayExpr || node[0] === NODE.binaryExpr || node[0] === NODE.assignmentExpr || node[0] === NODE.logicalExpr || node[0] === NODE.unaryExpr || node[0] === NODE.call || node[0] === NODE.memberAccess || node[0] === NODE.indexAccess || node[0] === NODE.preUpdate || node[0] === NODE.postUpdate || node[0] === NODE.objectExpr || node[0] === NODE.conditionalExpr) return true;
-	return false;
+    if (typeof node === 'string' ||
+        typeof node === 'boolean' ||
+        node[0] === NODE.numericLiteral ||
+        node[0] === NODE.stringLiteral ||
+        node[0] === NODE.arrayExpr ||
+        node[0] === NODE.binaryExpr ||
+        node[0] === NODE.assignmentExpr ||
+        node[0] === NODE.logicalExpr ||
+        node[0] === NODE.unaryExpr ||
+        node[0] === NODE.call ||
+        node[0] === NODE.memberAccess ||
+        node[0] === NODE.indexAccess ||
+        node[0] === NODE.preUpdate ||
+        node[0] === NODE.postUpdate ||
+        node[0] === NODE.objectExpr ||
+        node[0] === NODE.conditionalExpr) {
+        node;
+        return true;
+    }
+    node;
+    return false;
 }
 const SIMPLE_NODES = [
-	NODE.memberAccess,
-	NODE.indexAccess,
-	NODE.call,
-	NODE.arrayExpr,
-	NODE.stringLiteral,
-	NODE.numericLiteral
+    NODE.memberAccess, // highest precedence
+    NODE.indexAccess, // highest precedence
+    NODE.call, // highest precedence
+    NODE.arrayExpr, // [] make things not ambiguous
+    NODE.stringLiteral,
+    NODE.numericLiteral,
 ];
 /**
-* Stringifies expression, and wraps it in parentheses if they cannot be trivially omitted
-*/
+ * Stringifies expression, and wraps it in parentheses if they cannot be trivially omitted
+ */
 function wrapIfComplex(node, ident) {
-	const s = stringifyExpression(node, ident);
-	if (typeof node === "string" || typeof node === "boolean") return s;
-	if (SIMPLE_NODES.includes(node[0])) return s;
-	return `(${s})`;
+    const s = stringifyExpression(node, ident);
+    if (typeof node === 'string' || typeof node === 'boolean') {
+        return s;
+    }
+    if (SIMPLE_NODES.includes(node[0])) {
+        return s;
+    }
+    return `(${s})`;
 }
-
-//#endregion
-export { stringifyNode };

package/shared/utilityTypes.d.ts

@@ -1,33 +1,49 @@
-//#region src/shared/utilityTypes.d.ts
-type Default<T, TDefault> = unknown extends T ? TDefault : T extends undefined ? TDefault : T;
-type SwapNever<T, Replacement> = [T] extends [never] ? Replacement : T;
-type UnionToIntersection<U> = (U extends any ? (x: U) => void : never) extends ((x: infer I) => void) ? I : never;
-type Prettify<T> = { [K in keyof T]: T[K] } & {};
+export type Default<T, TDefault> = unknown extends T ? TDefault : T extends undefined ? TDefault : T;
+export type SwapNever<T, Replacement> = [T] extends [never] ? Replacement : T;
+export type UnionToIntersection<U> = (U extends any ? (x: U) => void : never) extends (x: infer I) => void ? I : never;
+export type Prettify<T> = {
+    [K in keyof T]: T[K];
+} & {};
 /**
  * Utility type that merges a partial type with defaults, where defaults are used
  * for properties not present in the partial type.
  */
-type WithDefaults<TPartial, TDefaults> = Omit<TDefaults, keyof TPartial> & TPartial;
+export type WithDefaults<TPartial, TDefaults> = Omit<TDefaults, keyof TPartial> & TPartial;
 /**
  * Removes properties from record type that extend `Prop`
  */
-type OmitProps<T extends Record<string, unknown>, Prop> = Pick<T, { [Key in keyof T]: T[Key] extends Prop ? never : Key }[keyof T]>;
-type NullableToOptional<T> = { [K in keyof T as T[K] extends null ? K : never]?: T[K] } & { [K in keyof T as T[K] extends null ? never : K]: T[K] };
+export type OmitProps<T extends Record<string, unknown>, Prop> = Pick<T, {
+    [Key in keyof T]: T[Key] extends Prop ? never : Key;
+}[keyof T]>;
+/**
+ * Removes properties from record type that equal `Prop`
+ */
+export type OmitPropsExact<T extends Record<string, unknown>, Prop> = Pick<T, {
+    [Key in keyof T]: [T[Key], Prop] extends [Prop, T[Key]] ? never : Key;
+}[keyof T]>;
+export type NullableToOptional<T> = {
+    [K in keyof T as T[K] extends null ? K : never]?: T[K];
+} & {
+    [K in keyof T as T[K] extends null ? never : K]: T[K];
+};
 /**
  * The opposite of Readonly<T>
  */
-type Mutable<T> = { -readonly [P in keyof T]: T[P] };
+export type Mutable<T> = {
+    -readonly [P in keyof T]: T[P];
+};
 /**
  * Source: https://code.lol/post/programming/higher-kinded-types
  */
-type Assume<T, U> = T extends U ? T : U;
+export type Assume<T, U> = T extends U ? T : U;
 /**
  * Any typed array
  */
-type TypedArray = Uint8Array | Uint16Array | Uint32Array | Int32Array | Float32Array | Float64Array;
+export type TypedArray = Uint8Array | Uint16Array | Uint32Array | Int32Array | Float32Array | Float64Array;
+export declare function assertExhaustive(x: never, location: string): never;
 /**
  * Source: https://futurestud.io/tutorials/typescript-how-to-remove-index-signature-from-a-type
  */
-type RemoveIndexSignature<T> = { [K in keyof T as string extends K ? never : number extends K ? never : symbol extends K ? never : K]: T[K] };
-//#endregion
-export { Assume, Default, Mutable, NullableToOptional, OmitProps, Prettify, RemoveIndexSignature, SwapNever, TypedArray, UnionToIntersection, WithDefaults };
+export type RemoveIndexSignature<T> = {
+    [K in keyof T as string extends K ? never : number extends K ? never : symbol extends K ? never : K]: T[K];
+};

package/shared/utilityTypes.js

@@ -1,7 +1,3 @@
-//#region src/shared/utilityTypes.ts
-function assertExhaustive(x, location) {
-	throw new Error(`Failed to handle ${x} at ${location}`);
+export function assertExhaustive(x, location) {
+    throw new Error(`Failed to handle ${x} at ${location}`);
 }
-
-//#endregion
-export { assertExhaustive };