typegpu 0.11.9 → 0.12.1

package/core/resolve/namespace.d.ts

@@ -1,29 +1,26 @@
-import { $internal } from "../../shared/symbols.js";
-import { ResolvedSnippet } from "../../data/snippet.js";
-import { ShelllessRepository } from "../../tgsl/shellless.js";
-import { TgpuLazy, TgpuSlot } from "../slot/slotTypes.js";
-
-//#region src/core/resolve/namespace.d.ts
+import type { ResolvedSnippet } from '../../data/snippet.ts';
+import { $internal } from '../../shared/symbols.ts';
+import { ShelllessRepository } from '../../tgsl/shellless.ts';
+import type { TgpuLazy, TgpuSlot } from '../slot/slotTypes.ts';
 type SlotToValueMap = Map<TgpuSlot<unknown>, unknown>;
-interface NamespaceInternal {
-  readonly takenGlobalIdentifiers: Set<string>;
-  readonly shelllessRepo: ShelllessRepository;
-  readonly strategy: 'random' | 'strict';
-  memoizedResolves: WeakMap<object, {
-    slotToValueMap: SlotToValueMap;
-    result: ResolvedSnippet;
-  }[]>;
-  memoizedLazy: WeakMap<TgpuLazy<unknown>, {
-    slotToValueMap: SlotToValueMap;
-    result: unknown;
-  }[]>;
+export interface NamespaceInternal {
+    readonly takenGlobalIdentifiers: Set<string>;
+    readonly shelllessRepo: ShelllessRepository;
+    readonly strategy: 'random' | 'strict';
+    memoizedResolves: WeakMap<object, {
+        slotToValueMap: SlotToValueMap;
+        result: ResolvedSnippet;
+    }[]>;
+    memoizedLazy: WeakMap<TgpuLazy<unknown>, {
+        slotToValueMap: SlotToValueMap;
+        result: unknown;
+    }[]>;
 }
-interface Namespace {
-  readonly [$internal]: NamespaceInternal;
+export interface Namespace {
+    readonly [$internal]: NamespaceInternal;
 }
-interface NamespaceOptions {
-  names?: 'random' | 'strict' | undefined;
+export interface NamespaceOptions {
+    names?: 'random' | 'strict' | undefined;
 }
-declare function namespace(options?: NamespaceOptions): Namespace;
-//#endregion
-export { Namespace, namespace };
+export declare function namespace(options?: NamespaceOptions): Namespace;
+export {};

package/core/resolve/namespace.js

@@ -1,24 +1,19 @@
-import { $internal } from "../../shared/symbols.js";
 import { bannedTokens, builtins } from "../../nameUtils.js";
+import { $internal } from "../../shared/symbols.js";
 import { ShelllessRepository } from "../../tgsl/shellless.js";
-
-//#region src/core/resolve/namespace.ts
-var NamespaceImpl = class {
-	[$internal];
-	constructor(strategy) {
-		this[$internal] = {
-			strategy,
-			takenGlobalIdentifiers: new Set([...bannedTokens, ...builtins]),
-			shelllessRepo: new ShelllessRepository(),
-			memoizedResolves: /* @__PURE__ */ new WeakMap(),
-			memoizedLazy: /* @__PURE__ */ new WeakMap()
-		};
-	}
-};
-function namespace(options) {
-	const { names = "strict" } = options ?? {};
-	return new NamespaceImpl(names);
+class NamespaceImpl {
+    [$internal];
+    constructor(strategy) {
+        this[$internal] = {
+            strategy,
+            takenGlobalIdentifiers: new Set([...bannedTokens, ...builtins]),
+            shelllessRepo: new ShelllessRepository(),
+            memoizedResolves: new WeakMap(),
+            memoizedLazy: new WeakMap(),
+        };
+    }
+}
+export function namespace(options) {
+    const { names = 'strict' } = options ?? {};
+    return new NamespaceImpl(names);
 }
-
-//#endregion
-export { namespace };

package/core/resolve/resolvableString.d.ts

@@ -0,0 +1,7 @@
+import { $internal, $resolve } from '../../shared/symbols.ts';
+export declare class ResolvableString {
+    #private;
+    [$internal]: boolean;
+    constructor(value: string);
+    [$resolve](): import("../../internal.ts").Snippet;
+}

package/core/resolve/resolvableString.js

@@ -0,0 +1,13 @@
+import { UnknownData } from "../../data/dataTypes.js";
+import { snip } from "../../data/snippet.js";
+import { $internal, $resolve } from "../../shared/symbols.js";
+export class ResolvableString {
+    [$internal] = true;
+    #value;
+    constructor(value) {
+        this.#value = value;
+    }
+    [$resolve]() {
+        return snip(this.#value, UnknownData, 'runtime', true);
+    }
+}

package/core/resolve/resolveData.d.ts

@@ -0,0 +1,10 @@
+import { type AnyData } from '../../data/dataTypes.ts';
+import type { ResolutionCtx } from '../../types.ts';
+/**
+ * Resolves a WGSL data-type schema to a string.
+ * @param ctx - The resolution context.
+ * @param data - The data-type to resolve.
+ *
+ * @returns The resolved data-type string.
+ */
+export declare function resolveData(ctx: ResolutionCtx, data: AnyData): string;

package/core/resolve/resolveData.js

@@ -1,147 +1,188 @@
-import { $internal } from "../../shared/symbols.js";
-import { getName } from "../../shared/meta.js";
-import { isLooseData } from "../../data/dataTypes.js";
-import { assertExhaustive } from "../../shared/utilityTypes.js";
-import { formatToWGSLType } from "../../data/vertexFormatData.js";
 import { getAttributesString } from "../../data/attributes.js";
+import { isLooseData } from "../../data/dataTypes.js";
 import { isWgslComparisonSampler, isWgslSampler } from "../../data/sampler.js";
-import { accessModeMap, isWgslStorageTexture, isWgslTexture } from "../../data/texture.js";
+import { accessModeMap, isWgslStorageTexture, isWgslTexture, } from "../../data/texture.js";
+import { formatToWGSLType } from "../../data/vertexFormatData.js";
+import { getName } from "../../shared/meta.js";
+import { $internal } from "../../shared/symbols.js";
+import { assertExhaustive } from "../../shared/utilityTypes.js";
 import { isAttribute } from "../vertexLayout/connectAttributesToShader.js";
-
-//#region src/core/resolve/resolveData.ts
 /**
-* Schemas for which their `type` property directly
-* translates to the resulting WGSL code.
-*/
+ * Schemas for which their `type` property directly
+ * translates to the resulting WGSL code.
+ */
 const identityTypes = [
-	"bool",
-	"f32",
-	"f16",
-	"i32",
-	"u32",
-	"vec2f",
-	"vec3f",
-	"vec4f",
-	"vec2h",
-	"vec3h",
-	"vec4h",
-	"vec2i",
-	"vec3i",
-	"vec4i",
-	"vec2u",
-	"vec3u",
-	"vec4u",
-	"vec2<bool>",
-	"vec3<bool>",
-	"vec4<bool>",
-	"mat2x2f",
-	"mat3x3f",
-	"mat4x4f",
-	"texture_external"
+    'bool',
+    'f32',
+    'f16',
+    'i32',
+    'u32',
+    'vec2f',
+    'vec3f',
+    'vec4f',
+    'vec2h',
+    'vec3h',
+    'vec4h',
+    'vec2i',
+    'vec3i',
+    'vec4i',
+    'vec2u',
+    'vec3u',
+    'vec4u',
+    'vec2<bool>',
+    'vec3<bool>',
+    'vec4<bool>',
+    'mat2x2f',
+    'mat3x3f',
+    'mat4x4f',
+    'texture_external',
 ];
 function isIdentityType(data) {
-	return identityTypes.includes(data.type);
+    return identityTypes.includes(data.type);
 }
 /**
-* Resolves a single property of a struct.
-* @param ctx - The resolution context.
-* @param key - The key of the property.
-* @param property - The property itself.
-*
-* @returns The resolved property string.
-*/
+ * Resolves a single property of a struct.
+ * @param ctx - The resolution context.
+ * @param key - The key of the property.
+ * @param property - The property itself.
+ *
+ * @returns The resolved property string.
+ */
 function resolveStructProperty(ctx, [key, property]) {
-	return `  ${getAttributesString(property)}${key}: ${ctx.resolve(property).value},\n`;
+    return `  ${getAttributesString(property)}${key}: ${ctx.resolve(property).value},\n`;
 }
 /**
-* Resolves a struct and adds its declaration to the resolution context.
-* @param ctx - The resolution context.
-* @param struct - The struct to resolve.
-*
-* @returns The resolved struct name.
-*/
+ * Resolves a struct and adds its declaration to the resolution context.
+ * @param ctx - The resolution context.
+ * @param struct - The struct to resolve.
+ *
+ * @returns The resolved struct name.
+ */
 function resolveStruct(ctx, struct) {
-	if (struct[$internal].isAbstruct) throw new Error("Cannot resolve abstract struct types to WGSL.");
-	const id = ctx.makeUniqueIdentifier(getName(struct), "global");
-	ctx.addDeclaration(`\
+    if (struct[$internal].isAbstruct) {
+        throw new Error('Cannot resolve abstract struct types to WGSL.');
+    }
+    const id = ctx.makeUniqueIdentifier(getName(struct), 'global');
+    ctx.addDeclaration(`\
 struct ${id} {
-${Object.entries(struct.propTypes).map((prop) => resolveStructProperty(ctx, prop)).join("")}\
-}`);
-	return id;
+${Object.entries(struct.propTypes)
+        .map((prop) => resolveStructProperty(ctx, prop))
+        .join('')}\
+}`, id);
+    return id;
 }
 /**
-* Resolves an unstruct (struct that does not align data by default) to its struct data counterpart.
-* @param ctx - The resolution context.
-* @param unstruct - The unstruct to resolve.
-*
-* @returns The resolved unstruct name.
-*
-* @example
-* ```ts
-* resolveUnstruct(ctx, {
-*   uv: d.float16x2, // -> d.vec2f after resolution
-*   color: d.snorm8x4, -> d.vec4f after resolution
-* });
-* ```
-*/
+ * Resolves an unstruct (struct that does not align data by default) to its struct data counterpart.
+ * @param ctx - The resolution context.
+ * @param unstruct - The unstruct to resolve.
+ *
+ * @returns The resolved unstruct name.
+ *
+ * @example
+ * ```ts
+ * resolveUnstruct(ctx, {
+ *   uv: d.float16x2, // -> d.vec2f after resolution
+ *   color: d.snorm8x4, -> d.vec4f after resolution
+ * });
+ * ```
+ */
 function resolveUnstruct(ctx, unstruct) {
-	const id = ctx.makeUniqueIdentifier(getName(unstruct), "global");
-	ctx.addDeclaration(`\
+    const id = ctx.makeUniqueIdentifier(getName(unstruct), 'global');
+    ctx.addDeclaration(`\
 struct ${id} {
-${Object.entries(unstruct.propTypes).map((prop) => isAttribute(prop[1]) ? resolveStructProperty(ctx, [prop[0], formatToWGSLType[prop[1].format]]) : resolveStructProperty(ctx, prop)).join("")}
-}`);
-	return id;
+${Object.entries(unstruct.propTypes)
+        .map((prop) => isAttribute(prop[1])
+        ? resolveStructProperty(ctx, [prop[0], formatToWGSLType[prop[1].format]])
+        : resolveStructProperty(ctx, prop))
+        .join('')}
+}`, id);
+    return id;
 }
 /**
-* Resolves an array.
-* @param ctx - The resolution context.
-* @param array - The array to resolve.
-*
-* @returns The resolved array name along with its element type and count (if not runtime-sized).
-*
-* @example
-* ```ts
-* resolveArray(ctx, d.arrayOf(d.u32, 0)); // 'array<u32>' (not a real pattern, a function is preferred)
-* resolveArray(ctx, d.arrayOf(d.u32, 5)); // 'array<u32, 5>'
-* ```
-*/
+ * Resolves an array.
+ * @param ctx - The resolution context.
+ * @param array - The array to resolve.
+ *
+ * @returns The resolved array name along with its element type and count (if not runtime-sized).
+ *
+ * @example
+ * ```ts
+ * resolveArray(ctx, d.arrayOf(d.u32, 0)); // 'array<u32>' (not a real pattern, a function is preferred)
+ * resolveArray(ctx, d.arrayOf(d.u32, 5)); // 'array<u32, 5>'
+ * ```
+ */
 function resolveArray(ctx, array) {
-	const element = ctx.resolve(array.elementType).value;
-	return array.elementCount === 0 ? `array<${element}>` : `array<${element}, ${array.elementCount}>`;
+    const element = ctx.resolve(array.elementType).value;
+    return array.elementCount === 0
+        ? `array<${element}>`
+        : `array<${element}, ${array.elementCount}>`;
 }
 function resolveDisarray(ctx, disarray) {
-	const element = ctx.resolve(isAttribute(disarray.elementType) ? formatToWGSLType[disarray.elementType.format] : disarray.elementType).value;
-	return disarray.elementCount === 0 ? `array<${element}>` : `array<${element}, ${disarray.elementCount}>`;
+    const element = ctx.resolve(isAttribute(disarray.elementType)
+        ? formatToWGSLType[disarray.elementType.format]
+        : disarray.elementType).value;
+    return disarray.elementCount === 0
+        ? `array<${element}>`
+        : `array<${element}, ${disarray.elementCount}>`;
 }
 /**
-* Resolves a WGSL data-type schema to a string.
-* @param ctx - The resolution context.
-* @param data - The data-type to resolve.
-*
-* @returns The resolved data-type string.
-*/
-function resolveData(ctx, data) {
-	if (isLooseData(data)) {
-		if (data.type === "unstruct") return resolveUnstruct(ctx, data);
-		if (data.type === "disarray") return resolveDisarray(ctx, data);
-		if (data.type === "loose-decorated") return ctx.resolve(isAttribute(data.inner) ? formatToWGSLType[data.inner.format] : data.inner).value;
-		return ctx.resolve(formatToWGSLType[data.type]).value;
-	}
-	if (isIdentityType(data)) return data.type;
-	if (data.type === "struct") return resolveStruct(ctx, data);
-	if (data.type === "array") return resolveArray(ctx, data);
-	if (data.type === "atomic") return `atomic<${resolveData(ctx, data.inner)}>`;
-	if (data.type === "decorated") return ctx.resolve(data.inner).value;
-	if (data.type === "ptr") {
-		if (data.addressSpace === "storage") return `ptr<storage, ${ctx.resolve(data.inner).value}, ${data.access === "read-write" ? "read_write" : data.access}>`;
-		return `ptr<${data.addressSpace}, ${ctx.resolve(data.inner).value}>`;
-	}
-	if (data.type === "abstractInt" || data.type === "abstractFloat" || data.type === "void" || data.type === "u16") throw new Error(`${data.type} has no representation in WGSL`);
-	if (isWgslStorageTexture(data)) return `${data.type}<${data.format}, ${accessModeMap[data.access]}>`;
-	if (isWgslTexture(data)) return data.type.startsWith("texture_depth") ? data.type : `${data.type}<${data.sampleType.type}>`;
-	if (isWgslComparisonSampler(data) || isWgslSampler(data)) return data.type;
-	assertExhaustive(data, "resolveData");
+ * Resolves a WGSL data-type schema to a string.
+ * @param ctx - The resolution context.
+ * @param data - The data-type to resolve.
+ *
+ * @returns The resolved data-type string.
+ */
+export function resolveData(ctx, data) {
+    if (isLooseData(data)) {
+        if (data.type === 'unstruct') {
+            return resolveUnstruct(ctx, data);
+        }
+        if (data.type === 'disarray') {
+            return resolveDisarray(ctx, data);
+        }
+        if (data.type === 'loose-decorated') {
+            return ctx.resolve(isAttribute(data.inner) ? formatToWGSLType[data.inner.format] : data.inner)
+                .value;
+        }
+        return ctx.resolve(formatToWGSLType[data.type]).value;
+    }
+    if (isIdentityType(data)) {
+        return data.type;
+    }
+    if (data.type === 'struct') {
+        return resolveStruct(ctx, data);
+    }
+    if (data.type === 'array') {
+        return resolveArray(ctx, data);
+    }
+    if (data.type === 'atomic') {
+        return `atomic<${resolveData(ctx, data.inner)}>`;
+    }
+    if (data.type === 'decorated') {
+        return ctx.resolve(data.inner).value;
+    }
+    if (data.type === 'ptr') {
+        if (data.addressSpace === 'storage') {
+            return `ptr<storage, ${ctx.resolve(data.inner).value}, ${data.access === 'read-write' ? 'read_write' : data.access}>`;
+        }
+        return `ptr<${data.addressSpace}, ${ctx.resolve(data.inner).value}>`;
+    }
+    if (data.type === 'abstractInt' ||
+        data.type === 'abstractFloat' ||
+        data.type === 'void' ||
+        data.type === 'u16') {
+        throw new Error(`${data.type} has no representation in WGSL`);
+    }
+    if (isWgslStorageTexture(data)) {
+        return `${data.type}<${data.format}, ${accessModeMap[data.access]}>`;
+    }
+    if (isWgslTexture(data)) {
+        return data.type.startsWith('texture_depth')
+            ? data.type
+            : `${data.type}<${data.sampleType.type}>`;
+    }
+    if (isWgslComparisonSampler(data) || isWgslSampler(data)) {
+        return data.type;
+    }
+    assertExhaustive(data, 'resolveData');
 }
-
-//#endregion
-export { resolveData };

package/core/resolve/stitch.d.ts

@@ -0,0 +1,8 @@
+import { type Snippet } from '../../data/snippet.ts';
+type ValueOrArray<T> = T | readonly T[];
+/**
+ * "The reverse of snipping"
+ * Injects resolved snippets into a template string.
+ */
+export declare function stitch(strings: TemplateStringsArray, ...snippets: ValueOrArray<Snippet | string | number | undefined>[]): string;
+export {};

package/core/resolve/stitch.js

@@ -1,25 +1,27 @@
 import { isSnippet } from "../../data/snippet.js";
 import { getResolutionCtx } from "../../execMode.js";
-
-//#region src/core/resolve/stitch.ts
 /**
-* "The reverse of snipping"
-* Injects resolved snippets into a template string.
-*/
-function stitch(strings, ...snippets) {
-	const ctx = getResolutionCtx();
-	function resolveSnippet(maybeSnippet) {
-		return isSnippet(maybeSnippet) ? ctx.resolve(maybeSnippet.value, maybeSnippet.dataType).value : maybeSnippet;
-	}
-	let result = "";
-	for (let i = 0; i < strings.length; ++i) {
-		result += strings[i];
-		const snippet = snippets[i];
-		if (Array.isArray(snippet)) result += snippet.filter((s) => s !== void 0).map(resolveSnippet).join(", ");
-		else if (snippet) result += resolveSnippet(snippet);
-	}
-	return result;
+ * "The reverse of snipping"
+ * Injects resolved snippets into a template string.
+ */
+export function stitch(strings, ...snippets) {
+    const ctx = getResolutionCtx();
+    function resolveSnippet(maybeSnippet) {
+        return isSnippet(maybeSnippet) ? ctx.resolveSnippet(maybeSnippet).value : maybeSnippet;
+    }
+    let result = '';
+    for (let i = 0; i < strings.length; ++i) {
+        result += strings[i];
+        const snippet = snippets[i];
+        if (Array.isArray(snippet)) {
+            result += snippet
+                .filter((s) => s !== undefined)
+                .map(resolveSnippet)
+                .join(', ');
+        }
+        else if (snippet) {
+            result += resolveSnippet(snippet);
+        }
+    }
+    return result;
 }
-
-//#endregion
-export { stitch };

package/core/resolve/tgpuResolve.d.ts

@@ -1,51 +1,55 @@
-import { ShaderGenerator } from "../../tgsl/shaderGenerator.js";
-import { Configurable } from "../root/rootTypes.js";
-import { WgslEnableExtension } from "../../wgslExtensions.js";
-import { ResolvableObject, Wgsl } from "../../types.js";
-import { Namespace } from "./namespace.js";
-import { ResolutionResult } from "../../resolutionCtx.js";
-
-//#region src/core/resolve/tgpuResolve.d.ts
-interface TgpuResolveOptions {
-  /**
-   * The naming strategy used for generating identifiers for resolved externals and their dependencies.
-   *
-   * ## Namespaces
-   * Each call to `tgpu.resolve` uses it's own namespace by default, but a
-   * custom namespace can be created with `tgpu.namespace` and passed in.
-   *
-   * This allows tracking the behavior of the resolution process, as well as
-   * sharing state between calls to `tgpu.resolve`.
-   *
-   * @default 'random'
-   */
-  names?: 'strict' | 'random' | Namespace | undefined;
-  /**
-   * A function to configure the resolution context.
-   */
-  config?: ((cfg: Configurable) => Configurable) | undefined;
-  /**
-   * List of WGSL shader extensions to enable.
-   */
-  enableExtensions?: WgslEnableExtension[] | undefined;
-  /**
-   * **NOTE: This is an unstable API and may change in the future.**
-   *
-   * A custom shader code generator, used when resolving TypeGPU functions.
-   * If not provided, the default WGSL generator will be used.
-   */
-  unstable_shaderGenerator?: ShaderGenerator | undefined;
+import { type ResolutionResult } from '../../resolutionCtx.ts';
+import type { ShaderGenerator } from '../../tgsl/shaderGenerator.ts';
+import { type ResolvableObject, type Wgsl } from '../../types.ts';
+import type { WgslEnableExtension } from '../../wgslExtensions.ts';
+import type { Configurable } from '../root/rootTypes.ts';
+import { type Namespace } from './namespace.ts';
+export interface TgpuResolveOptions {
+    /**
+     * The naming strategy used for generating identifiers for resolved externals and their dependencies.
+     *
+     * ## Namespaces
+     * Each call to `tgpu.resolve` uses its own namespace by default, but a
+     * custom namespace can be created with `tgpu['~unstable'].namespace` and passed in.
+     *
+     * This allows tracking the behavior of the resolution process, as well as
+     * sharing state between calls to `tgpu.resolve`.
+     *
+     * @default 'strict'
+     */
+    names?: 'strict' | 'random' | Namespace | undefined;
+    /**
+     * When set to true, the resulting shaders will be stripped from all unnecessary whitespace.
+     *
+     * @default false
+     */
+    unstable_minify?: boolean;
+    /**
+     * A function to configure the resolution context.
+     */
+    config?: ((cfg: Configurable) => Configurable) | undefined;
+    /**
+     * List of WGSL shader extensions to enable.
+     */
+    enableExtensions?: WgslEnableExtension[] | undefined;
+    /**
+     * **NOTE: This is an unstable API and may change in the future.**
+     *
+     * A custom shader code generator, used when resolving TypeGPU functions.
+     * If not provided, the default WGSL generator will be used.
+     */
+    unstable_shaderGenerator?: ShaderGenerator | undefined;
 }
-interface TgpuExtendedResolveOptions extends TgpuResolveOptions {
-  /**
-   * Map of external names to their resolvable values.
-   */
-  externals: Record<string, Wgsl | object>;
-  /**
-   * The code template to use for the resolution. All external names will be replaced with their resolved values.
-   * @default ''
-   */
-  template?: string | undefined;
+export interface TgpuExtendedResolveOptions extends TgpuResolveOptions {
+    /**
+     * Map of external names to their resolvable values.
+     */
+    externals: Record<string, Wgsl | object>;
+    /**
+     * The code template to use for the resolution. All external names will be replaced with their resolved values.
+     * @default ''
+     */
+    template?: string | undefined;
 }
 /**
  * Resolves a template with external values. Each external that is used will get resolved to a code string and replaced in the template.
@@ -79,7 +83,7 @@ interface TgpuExtendedResolveOptions extends TgpuResolveOptions {
  * // }
  * ```
  */
-declare function resolveWithContext(options: TgpuExtendedResolveOptions): ResolutionResult;
+export declare function resolveWithContext(options: TgpuExtendedResolveOptions): ResolutionResult;
 /**
  * Resolves given TypeGPU resources.
  * Any dependencies of the externals will also be resolved and included in the output.
@@ -105,7 +109,7 @@ declare function resolveWithContext(options: TgpuExtendedResolveOptions): Resolu
  * // }
  * ```
  */
-declare function resolveWithContext(items: ResolvableObject[], options?: TgpuResolveOptions): ResolutionResult;
+export declare function resolveWithContext(items: ResolvableObject[], options?: TgpuResolveOptions): ResolutionResult;
 /**
  * A shorthand for calling `tgpu.resolveWithContext(...).code`.
  *
@@ -147,7 +151,5 @@ declare function resolveWithContext(items: ResolvableObject[], options?: TgpuRes
  * // }
  * ```
  */
-declare function resolve(options: TgpuExtendedResolveOptions): string;
-declare function resolve(items: ResolvableObject[], options?: TgpuResolveOptions): string;
-//#endregion
-export { resolve, resolveWithContext };
+export declare function resolve(options: TgpuExtendedResolveOptions): string;
+export declare function resolve(items: ResolvableObject[], options?: TgpuResolveOptions): string;