wesl 0.6.0-pre10

package/dist/tools/packages/wesl/src/ParseWESL.d.ts

@@ -0,0 +1,60 @@
+import { AppState, ParseError, SrcMap } from '../../mini-parse/src';
+import { ConstAssertElem, ImportStatement, ModuleElem } from './AbstractElems.ts';
+import { FlatImport } from './FlattenTreeImport.ts';
+import { Scope, SrcModule } from './Scope.ts';
+import { OpenElem } from './WESLCollect.ts';
+/** result of a parse for one wesl module (e.g. one .wesl file)
+ *
+ * The parser constructs the AST constructed into three sections
+ * for convenient access by the binding stage.
+ *  - import statements
+ *  - language elements (fn, struct, etc)
+ *  - scopes
+ *
+ */
+export interface WeslAST {
+    /** source text for this module */
+    srcModule: SrcModule;
+    /** root module element */
+    moduleElem: ModuleElem;
+    /** root scope for this module */
+    rootScope: Scope;
+    /** imports found in this module */
+    imports: ImportStatement[];
+    /** module level const_assert statements */
+    moduleAsserts?: ConstAssertElem[];
+}
+/** an extended version of the AST */
+export interface BindingAST extends WeslAST {
+    _flatImports?: FlatImport[];
+}
+/** stable and unstable state used during parsing */
+export interface WeslParseState extends AppState<WeslParseContext, StableState> {
+    context: WeslParseContext;
+    stable: StableState;
+}
+/** stable values used or accumulated during parsing */
+export type StableState = WeslAST;
+/** unstable values used during parse collection */
+export interface WeslParseContext {
+    scope: Scope;
+    openElems: OpenElem[];
+}
+/**
+ * An error when parsing WESL fails. Designed to be human-readable.
+ */
+export declare class WeslParseError extends Error {
+    position: number;
+    src: SrcModule;
+    constructor(opts: {
+        cause: ParseError;
+        src: SrcModule;
+    });
+}
+/** Parse a WESL file. Throws on error. */
+export declare function parseSrcModule(srcModule: SrcModule, srcMap?: SrcMap): WeslAST;
+export declare function parseWESL(src: string, srcMap?: SrcMap): WeslAST;
+export declare function blankWeslParseState(srcModule: SrcModule): WeslParseState;
+export declare function syntheticWeslParseState(): WeslParseState;
+/** @return a flattened form of the import tree for convenience in binding idents. */
+export declare function flatImports(ast: BindingAST): FlatImport[];

package/dist/tools/packages/wesl/src/ParsedRegistry.d.ts

@@ -0,0 +1,29 @@
+import { WeslBundle } from '.';
+import { WeslAST } from './ParseWESL.ts';
+export interface ParsedRegistry {
+    modules: Record<string, WeslAST>;
+}
+export declare function parsedRegistry(): ParsedRegistry;
+/** for debug */
+export declare function registryToString(registry: ParsedRegistry): string;
+/**
+ * Parse WESL each src module (file) into AST elements and a Scope tree.
+ * @param src keys are module paths, values are wesl src strings
+ */
+export declare function parseWeslSrc(src: Record<string, string>): ParsedRegistry;
+/** Look up a module with a flexible selector.
+ *    :: separated module path,   package::util
+ *    / separated file path       ./util.wesl (or ./util)
+ *          - note: a file path should not include a weslRoot prefix, e.g. not ./shaders/util.wesl
+ *    simpleName                  util
+ */
+export declare function selectModule(parsed: ParsedRegistry, selectPath: string, packageName?: string): WeslAST | undefined;
+/**
+ * @param srcFiles    map of source strings by file path
+ *                    key is '/' separated relative path (relative to srcRoot, not absolute file path )
+ *                    value is wesl source string
+ * @param registry    add parsed modules to this registry
+ * @param packageName name of package
+ */
+export declare function parseIntoRegistry(srcFiles: Record<string, string>, registry: ParsedRegistry, packageName?: string, debugWeslRoot?: string): void;
+export declare function parseLibsIntoRegistry(libs: WeslBundle[], registry: ParsedRegistry): void;

package/dist/tools/packages/wesl/src/PathUtil.d.ts

@@ -0,0 +1,6 @@
+/** simplistic path manipulation utilities */
+/** return path with ./ and foo/.. elements removed */
+export declare function normalize(path: string): string;
+/** return path w/o a suffix.
+ * e.g. /foo/bar.wgsl => /foo/bar */
+export declare function noSuffix(path: string): string;

package/dist/tools/packages/wesl/src/RawEmit.d.ts

@@ -0,0 +1,6 @@
+import { AttributeElem, NameElem, StuffElem, TranslateTimeExpressionElem, TypeRefElem, TypeTemplateParameter, UnknownExpressionElem } from './AbstractElems.ts';
+export declare function attributeToString(e: AttributeElem): string;
+export declare function typeListToString(params: TypeTemplateParameter[]): string;
+export declare function typeParamToString(param?: TypeTemplateParameter): string;
+export declare function typeRefToString(t?: TypeRefElem): string;
+export declare function contentsToString(elem: TranslateTimeExpressionElem | UnknownExpressionElem | NameElem | StuffElem): string;

package/dist/tools/packages/wesl/src/Reflection.d.ts

@@ -0,0 +1,45 @@
+import { BindingStructElem } from './AbstractElems.ts';
+import { TransformedAST, WeslJsPlugin } from './Linker.ts';
+export type BindingStructReportFn = (structs: BindingStructElem[]) => void;
+export declare const textureStorage: RegExp;
+export declare function reportBindingStructsPlugin(fn: BindingStructReportFn): WeslJsPlugin;
+/**
+ * Linker plugin that generates TypeScript strings for GPUBindingGroupLayouts
+ * based on the binding structs in the WESL source
+ *
+ * requires the enableBindingStructs() transform to be enabled
+ *
+ * @param fn a function that will be called with the binding structs
+ * (Normally the caller will pass a function that uses bindingGroupLayoutTs()
+ * to generate the TypeScript)
+ *
+ * The generated TypeScript looks looks roughly like this
+
+  export function MyBindingLayout(device: GPUDevice): GPUBindGroupLayout {
+    return device.createBindGroupLayout({
+      entries: [
+        {
+          binding: 0,
+          visibility: GPUShaderStage.COMPUTE,
+          buffer: {
+            type: "storage",
+          },
+        },
+      ],
+    });
+  }
+*/
+export declare function reportBindingStructs(fn: BindingStructReportFn): (ast: TransformedAST) => TransformedAST;
+/**
+ * @return a string containing a generated TypeScript function that creates
+ * a GPUBindingGroupLayout instance to align with the binding structures
+ * in wesl source.
+ */
+export declare function bindingGroupLayoutTs(struct: BindingStructElem, typeScript?: boolean): string;
+export declare function formatToTextureSampleType(format: GPUTextureFormat, float32Filterable?: boolean): GPUTextureSampleType;
+export type WgslTexelType = "f32" | "u32" | "i32";
+/** return the wgsl element type for a given texture format */
+export declare function formatToTexelType(format: GPUTextureFormat): WgslTexelType;
+/** @return the webgpu GPUTextureSampleType from the wgsl texel type */
+export declare function texelTypeToSampleType(type: WgslTexelType): GPUTextureSampleType;
+export declare function accessMode(access: string): GPUStorageTextureAccess;

package/dist/tools/packages/wesl/src/Scope.d.ts

@@ -0,0 +1,81 @@
+import { DeclarationElem, IfAttribute, RefIdentElem } from './AbstractElems.ts';
+import { WeslAST } from './ParseWESL.ts';
+export interface SrcModule {
+    /** module path "rand_pkg::sub::foo", or "package::main" */
+    modulePath: string;
+    /** file path to the module for user error reporting e.g "rand_pkg:sub/foo.wesl", or "./sub/foo.wesl" */
+    debugFilePath: string;
+    /** original src for module */
+    src: string;
+}
+/** a src declaration or reference to an ident */
+export type Ident = DeclIdent | RefIdent;
+/** LATER change this to a Map, so that `toString` isn't accidentally a condition */
+export type Conditions = Record<string, boolean>;
+interface IdentBase {
+    originalName: string;
+    id?: number;
+}
+export interface RefIdent extends IdentBase {
+    kind: "ref";
+    refersTo?: Ident;
+    std?: true;
+    ast: WeslAST;
+    refIdentElem: RefIdentElem;
+}
+export interface DeclIdent extends IdentBase {
+    kind: "decl";
+    mangledName?: string;
+    declElem?: DeclarationElem;
+    scope: Scope;
+    isGlobal: boolean;
+    srcModule: SrcModule;
+}
+/** tree of ident references, organized by lexical scope and partialScope . */
+export type Scope = LexicalScope | PartialScope;
+/** A wgsl scope */
+export interface LexicalScope extends ScopeBase {
+    kind: "scope";
+    /** @if condition for conditionally translating this scope */
+    ifAttribute?: IfAttribute;
+    /**
+     * Efficient access to declarations in this scope.
+     * constructed on demand, for module root scopes only */ scopeDecls?: Map<string, DeclIdent>;
+}
+/** A synthetic partial scope to contain @if conditioned idents.
+ * PartialScope idents are considered to be in the wgsl lexical scope of their parent.  */
+export interface PartialScope extends ScopeBase {
+    kind: "partial";
+    /** @if condition for conditionally translating this scope */
+    ifAttribute?: IfAttribute;
+}
+/** common scope elements  */
+interface ScopeBase {
+    /** id for debugging */
+    id: number;
+    /** null for root scope in a module */
+    parent: Scope | null;
+    contents: (Ident | Scope)[];
+    /** @if conditions for conditionally translating this scope */
+    ifAttribute?: IfAttribute;
+}
+/** Combine two scope siblings.
+ * The first scope is mutated to append the contents of the second.  */
+export declare function mergeScope(a: Scope, b: Scope): void;
+/** reset scope and ident debugging ids */
+export declare function resetScopeIds(): void;
+export declare function nextIdentId(): number;
+/** make a new Scope object */
+export declare function emptyScope(parent: Scope | null, kind?: Scope["kind"]): Omit<Scope, "ifAttribute">;
+/** For debugging,
+ * @return true if a scope is in the rootScope tree somewhere */
+export declare function containsScope(rootScope: Scope, scope: Scope): boolean;
+/** @returns true if the provided element of a Scope
+ *    is itself a Scope (and not an Ident) */
+export declare function childScope(child: Scope | Ident): child is Scope;
+/** @returns true if the provided element of a Scope
+ *    is an Ident (and not a child Scope) */
+export declare function childIdent(child: Scope | Ident): child is Ident;
+/** find a public declaration with the given original name */
+export declare function publicDecl(scope: Scope, name: string, conditions: Conditions): DeclIdent | undefined;
+export {};

package/dist/tools/packages/wesl/src/StandardTypes.d.ts

@@ -0,0 +1,13 @@
+export declare const stdFns: string[];
+export declare const sampledTextureTypes = "\n  texture_1d texture_2d texture_2d_array texture_3d \n  texture_cube texture_cube_array\n";
+export declare const multisampledTextureTypes = "\n  texture_multisampled_2d texture_depth_multisampled_2d\n";
+export declare const textureStorageTypes = "\n  texture_storage_1d texture_storage_2d texture_storage_2d_array \n  texture_storage_3d\n";
+export declare const stdTypes: string[];
+/** https://www.w3.org/TR/WGSL/#predeclared-enumerants  */
+export declare const stdEnumerants: string[];
+/** return true if the name is for a built in type (not a user struct) */
+export declare function stdType(name: string): boolean;
+/** return true if the name is for a built in fn (not a user function) */
+export declare function stdFn(name: string): boolean;
+/** return true if the name is for a built in enumerant */
+export declare function stdEnumerant(name: string): boolean;

package/dist/tools/packages/wesl/src/TransformBindingStructs.d.ts

@@ -0,0 +1,52 @@
+import { BindingStructElem, DeclarationElem, ModuleElem, SimpleMemberRef, StructElem, SyntheticElem } from './AbstractElems.ts';
+import { TransformedAST, WeslJsPlugin } from './Linker.ts';
+export declare function bindingStructsPlugin(): WeslJsPlugin;
+/**
+ * Transform binding structures into binding variables by mutating the AST.
+ *
+ * First we find all the binding structs:
+ *   . find all the structs in the module by filtering the moduleElem.contents
+ *     . for each struct:
+ *       . mark any structs with that contain @group or @binding annotations as 'binding structs' and save them in a list
+ *       . (later) create reverse links from structs to struct members
+ *       . (later) visit all the binding structs and traverse to referencing structs, marking the referencing structs as binding structs too
+ * Generate synethic AST nodes for binding variables
+ *
+ * Find all references to binding struct members
+ *   . find the componound idents by traversing moduleElem.contents
+ *   . filter to find the compound idents that refer to 'binding structs'
+ *     . go from each ident to its declaration,
+ *     . declaration to typeRef reference
+ *     . typeRef to type declaration
+ *     . check type declaration to see if it's a binding struct
+ *     . record the intermediate declaration (e.g. a fn param b:Bindings from 'fn(b:Bindings)' )
+ * rewrite references to binding struct members as synthetic elements
+ *
+ * Remove the binding structs from the AST
+ * Remove the intermediate fn param declarations from the AST
+ * Add the new binding variables to the AST
+ *
+ * @return the binding structs and the mutated AST
+ */
+export declare function lowerBindingStructs(ast: TransformedAST): TransformedAST;
+export declare function markEntryTypes(moduleElem: ModuleElem, bindingStructs: BindingStructElem[]): void;
+/** mutate the AST, marking StructElems as bindingStructs
+ *  (if they contain ptrs with @group @binding annotations)
+ * @return the binding structs
+ */
+export declare function markBindingStructs(moduleElem: ModuleElem): BindingStructElem[];
+/** convert each member of the binding struct into a synthetic global variable */
+export declare function transformBindingStruct(s: StructElem, globalNames: Set<string>): SyntheticElem[];
+interface MemberRefToStruct extends StructTrace {
+    memberRef: SimpleMemberRef;
+}
+interface StructTrace {
+    struct: StructElem;
+    intermediates: DeclarationElem[];
+}
+/** find all simple member references in the module that refer to binding structs */
+export declare function findRefsToBindingStructs(moduleElem: ModuleElem): MemberRefToStruct[];
+/** Mutate the member reference elem to instead contain synthetic elem text.
+ * The new text is the mangled var name of the struct member that the memberRef refers to. */
+export declare function transformBindingReference(memberRef: SimpleMemberRef, struct: StructElem): SyntheticElem;
+export {};

package/dist/tools/packages/wesl/src/Util.d.ts

@@ -0,0 +1,43 @@
+import { Span } from '../../mini-parse/src';
+export declare function multiKeySet<A, B, V>(m: Map<A, Map<B, V>>, a: A, b: B, v: V): void;
+/** replace strings in a text according to a relacement map
+ * replaced strings must be 'tokens', surrounded by spaces or punctuation
+ */
+export declare function replaceWords(text: string, replace: Record<string, string>): string;
+/** return an array partitioned into possibly overlapping groups */
+export declare function grouped<T>(a: T[], size: number, stride?: number): T[][];
+/** group an array into subarrays by a key function */
+export declare function groupBy<T, K>(a: T[], key: (t: T) => K): Map<K, T[]>;
+/** partition an array into two parts by a discriminator function */
+export declare function partition<T>(a: T[], partFn: (t: T) => boolean): [T[], T[]];
+/** run an carrying function over every element in an array,
+ * i.e. an inclusive prefix scan */
+export declare function scan<T, U>(array: T[], fn: (a: T, b: U) => U, zero: U): U[];
+/** return a new record by replacing values in 'a' with 'b' as a map.
+ * values in 'a' that are not in 'b' are unchanged.
+ * e.g. {a: "b", x: 9}, {b: 1} yields {a: 1, x: 9}
+ */
+export declare function mapForward(a: Record<string, string>, b: Record<string, any>): Record<string, any>;
+/** return the last element of an array or undefined */
+export declare function last<T>(a: T[]): T | undefined;
+/**
+ * Overlap two arrays, returning the tail of b if a is a prefix of b.
+ * Otherwise, return undefined.
+ */
+export declare function overlapTail<T>(a: T[], b: T[]): T[] | undefined;
+/** filter an array, returning the truthy results of the filter function */
+export declare function filterMap<T, U>(arr: T[], fn: (t: T) => U | undefined): U[];
+/** filters an array, returns the first truthy result of the filter function */
+export declare function findMap<T, U>(arr: T[], fn: (t: T) => U | undefined): U | undefined;
+/** Run a function over the values in a Record
+ * @return a new Record with mapped values.  */
+export declare function mapValues<T, U>(obj: Record<string, T>, fn: (v: T) => U): Record<string, U>;
+/**
+ * Maps an index to a 1-indexed line number, and 1-indexed column.
+ */
+export declare function offsetToLineNumber(offset: number, text: string): [lineNum: number, linePos: number];
+/** Highlights an error.
+ *
+ * Returns a string with the line, and a string with the ^^^^ carets
+ */
+export declare function errorHighlight(source: string, span: Span): [string, string];

package/dist/tools/packages/wesl/src/WESLCollect.d.ts

@@ -0,0 +1,94 @@
+import { CollectContext, CollectPair } from '../../mini-parse/src';
+import { AbstractElem, AliasElem, AttributeElem, ConstAssertElem, ConstElem, ContainerElem, DeclIdentElem, DirectiveElem, FnElem, FnParamElem, GlobalVarElem, LetElem, ModuleElem, NameElem, OverrideElem, RefIdentElem, SimpleMemberRef, StatementElem, StructMemberElem, SwitchClauseElem, TypedDeclElem, TypeRefElem, VarElem } from './AbstractElems.ts';
+import { Scope } from './Scope.ts';
+export declare function importElem(cc: CollectContext): void;
+/** create reference Ident and add to context */
+export declare function refIdent(cc: CollectContext): RefIdentElem;
+/** create declaration Ident and add to context */
+export declare function declCollect(cc: CollectContext): DeclIdentElem;
+/** create global declaration Ident and add to context */
+export declare function globalDeclCollect(cc: CollectContext): DeclIdentElem;
+export declare const typedDecl: CollectPair<TypedDeclElem>;
+export type OpenElem<T extends ContainerElem = ContainerElem> = Pick<T, "kind" | "contents">;
+export type PartElem<T extends ContainerElem = ContainerElem> = Pick<T, "kind" | "start" | "end" | "contents">;
+type VarLikeElem = GlobalVarElem | VarElem | LetElem | ConstElem | OverrideElem;
+export declare function collectVarLike<E extends VarLikeElem>(kind: E["kind"]): CollectPair<E>;
+export declare const aliasCollect: CollectPair<AliasElem>;
+/**
+ * Collect a FnElem and associated scopes.
+ *
+ * Scope definition is a bit complicated in wgsl and wesl for fns.
+ * Here's what we collect for scopes for this example function:
+ *    @if(true) fn foo(a: u32) -> @location(x) R { let y = a; }
+ *
+ * -{ // partial scope in case the whole shebang is prefixed by an `@if`
+ *   %foo
+ *
+ *   {<=%foo // foo decl references this header+returnType+body scope (for tracing dependencies from decls)
+ *      x  // for @location(x) (contains no decls, so ok to merge for tracing)
+ *      %a u32 // merged from header scope
+ *      R // merged from return type (contains no decls, so ok to merge for tracing)
+ *      %y a // merged body scope
+ *   }
+ * }
+ */
+export declare const fnCollect: CollectPair<FnElem>;
+export declare const collectFnParam: CollectPair<FnParamElem>;
+export declare const collectStruct: CollectPair<{
+    name: DeclIdentElem;
+    attributes: AttributeElem[];
+    members: StructMemberElem[];
+    start: number;
+    end: number;
+    kind: "struct";
+    contents: AbstractElem[];
+}>;
+export declare const collectStructMember: CollectPair<{
+    name: any;
+    attributes: AttributeElem[];
+    typeRef: any;
+    start: number;
+    end: number;
+    kind: "member";
+    contents: AbstractElem[];
+}>;
+export declare const specialAttribute: CollectPair<AttributeElem>;
+/** debug routine to log tags at collect() */
+export declare function logCollect(msg?: string): (cc: CollectContext) => void;
+export declare const assertCollect: CollectPair<ConstAssertElem>;
+export declare const statementCollect: CollectPair<StatementElem>;
+export declare const switchClauseCollect: CollectPair<SwitchClauseElem>;
+export declare const collectAttribute: CollectPair<AttributeElem>;
+export declare const typeRefCollect: CollectPair<TypeRefElem>;
+export declare const expressionCollect: CollectPair<{
+    start: number;
+    end: number;
+    kind: "expression";
+    contents: AbstractElem[];
+}>;
+export declare function globalAssertCollect(cc: CollectContext): void;
+export declare const stuffCollect: CollectPair<{
+    start: number;
+    end: number;
+    kind: "stuff";
+    contents: AbstractElem[];
+}>;
+export declare const memberRefCollect: CollectPair<SimpleMemberRef>;
+export declare function nameCollect(cc: CollectContext): NameElem;
+export declare const collectModule: CollectPair<ModuleElem>;
+export declare function directiveCollect(cc: CollectContext): DirectiveElem;
+/**
+ * Collect a LexicalScope.
+ *
+ * The scope starts encloses all idents and subscopes inside the parser to which
+ * .collect is attached
+ */
+export declare const scopeCollect: CollectPair<Scope>;
+/**
+ * Collect a PartialScope.
+ *
+ * The scope starts encloses all idents and subscopes inside the parser to which
+ * .collect is attached
+ */
+export declare const partialScopeCollect: CollectPair<Scope>;
+export {};

package/dist/tools/packages/wesl/src/WeslBundle.d.ts

@@ -0,0 +1,13 @@
+export interface WeslBundle {
+    /** name of the package, e.g. random_wgsl */
+    name: string;
+    /** wesl edition of the code e.g. wesl_unstable_2024_1 */
+    edition: string;
+    /** map of wesl/wgsl modules:
+     *    keys are file paths, relative to package root (e.g. "./lib.wgsl")
+     *    values are wgsl/wesl code strings
+     */
+    modules: Record<string, string>;
+    /** packages referenced by this package */
+    dependencies?: WeslBundle[];
+}

package/dist/tools/packages/wesl/src/WeslDevice.d.ts

@@ -0,0 +1,25 @@
+/**
+ * A {@link GPUDevice} with extensions for WESL. Created with {@link makeWeslDevice}.
+ * Used to make error reporting point at the orignal WESL sources.
+ */
+export interface WeslDevice extends GPUDevice {
+    /**
+     * Attaches an error to the current error scope (created by {@link GPUDevice.pushErrorScope}).
+     * If there is no error scope, it reports the error as a `'uncapturederror'`
+     */
+    injectError(type: GPUErrorFilter, error: Promise<GPUError | null>): void;
+}
+/**
+ * Mutates a {@link GPUDevice} for usage with WESL. Does not impact your existing code, wherever a {@link GPUDevice} can be used, a {@link WeslDevice} is also valid.
+ *
+ * WESL uses this to display errors pointing at the WESL source instead of pointing at generated code.
+ */
+export declare function makeWeslDevice(device: GPUDevice): WeslDevice;
+export declare function throwClickableError({ url, text, lineNumber, lineColumn, length, error, }: {
+    url: string;
+    text: string | null;
+    lineNumber: number;
+    lineColumn: number;
+    length: number;
+    error: Error;
+}): void;

package/dist/tools/packages/wesl/src/debug/ASTtoString.d.ts

@@ -0,0 +1,5 @@
+import { AbstractElem, Attribute, StuffElem } from '../AbstractElems.ts';
+export declare function astToString(elem: AbstractElem, indent?: number): string;
+/** @return string representation of an attribute (for test/debug) */
+export declare function attributeToString(attr: Attribute): string;
+export declare function debugContentsToString(elem: StuffElem): string;

package/dist/tools/packages/wesl/src/debug/ImportToString.d.ts

@@ -0,0 +1,2 @@
+import { ImportStatement } from '../AbstractElems';
+export declare function importToString(tree: ImportStatement): string;

package/dist/tools/packages/wesl/src/debug/LineWrapper.d.ts

@@ -0,0 +1,21 @@
+/** debug utility for constructing strings that wrap at a fixed column width
+ * text beyond the column width is wrapped to start on the next line
+ */
+export declare class LineWrapper {
+    #private;
+    readonly indent: number;
+    readonly maxWidth: number;
+    readonly hangingIndent: number;
+    constructor(indent?: number, maxWidth?: number, hangingIndent?: number);
+    /** add a new line to the constructed string */
+    nl(): void;
+    /** add a string, wrapping to the next line if necessary */
+    add(s: string): void;
+    /** add a raw block of text with no wrapping */
+    addBlock(s: string, andNewLine?: boolean): void;
+    /** @return the constructed string */
+    get result(): string;
+    /** true if the result contains no newlines */
+    get oneLine(): boolean;
+    private hangingNl;
+}

package/dist/tools/packages/wesl/src/debug/ScopeToString.d.ts

@@ -0,0 +1,6 @@
+import { Ident, Scope } from '../Scope.ts';
+/** A debugging print of the scope tree with identifiers in nested brackets */
+export declare function scopeToString(scope: Scope, indent?: number, shortIdents?: boolean): string;
+/** A debug print of the scope tree with identifiers in long form in nested brackets */
+export declare function scopeToStringLong(scope: Scope): string;
+export declare function identToString(ident?: Ident): string;

package/dist/tools/packages/wesl/src/index.d.ts

@@ -0,0 +1,11 @@
+export * from './debug/ASTtoString.js';
+export * from './debug/ScopeToString.js';
+export * from './LinkedWesl.js';
+export * from './Linker.js';
+export { WeslStream } from './parse/WeslStream.js';
+export * from './ParsedRegistry.js';
+export * from './ParseWESL.js';
+export * from './PathUtil.js';
+export * from './TransformBindingStructs.js';
+export * from './WeslBundle.js';
+export * from './WeslDevice.js';

package/dist/tools/packages/wesl/src/parse/ImportGrammar.d.ts

@@ -0,0 +1,5 @@
+import { Parser, Stream } from '../../../mini-parse/src';
+import { ImportElem } from '../AbstractElems.js';
+import { WeslToken } from './WeslStream.js';
+/** parse a WESL style wgsl import statement. */
+export declare const weslImports: Parser<Stream<WeslToken>, ImportElem[]>;

package/dist/tools/packages/wesl/src/parse/Keywords.d.ts

@@ -0,0 +1,4 @@
+/** https://www.w3.org/TR/WGSL/#keyword-summary */
+export declare const keywords: string[];
+/** https://www.w3.org/TR/WGSL/#reserved-words */
+export declare const reservedWords: string[];

package/dist/tools/packages/wesl/src/parse/WeslBaseGrammar.d.ts

@@ -0,0 +1,5 @@
+import { WeslTokenKind } from './WeslStream';
+export declare const word: import('../../../mini-parse/src').Parser<import('../../../mini-parse/src').Stream<import('../../../mini-parse/src').TypedToken<WeslTokenKind>>, string>;
+export declare const keyword: import('../../../mini-parse/src').Parser<import('../../../mini-parse/src').Stream<import('../../../mini-parse/src').TypedToken<WeslTokenKind>>, string>;
+export declare const qualified_ident: import('../../../mini-parse/src').Parser<import('../../../mini-parse/src').ParserStream | import('../../../mini-parse/src').Stream<import('../../../mini-parse/src').TypedToken<WeslTokenKind>>, string[]>;
+export declare const number: import('../../../mini-parse/src').Parser<import('../../../mini-parse/src').Stream<import('../../../mini-parse/src').TypedToken<WeslTokenKind>>, string>;

package/dist/tools/packages/wesl/src/parse/WeslExpression.d.ts

@@ -0,0 +1,13 @@
+import { Parser, Stream } from '../../../mini-parse/src';
+import { WeslToken } from './WeslStream';
+export declare const opt_template_list: Parser<import('../../../mini-parse/src').ParserStream | Stream<WeslToken>, [WeslToken<import('./WeslStream').WeslTokenKind> & {
+    kind: "symbol";
+}, any[], WeslToken<import('./WeslStream').WeslTokenKind> & {
+    kind: "symbol";
+}] | null>;
+export declare const component_or_swizzle: import('../../../mini-parse/src/CombinatorTypes').ParserFromRepeatArg<import('../../../mini-parse/src/CombinatorTypes').OrParser<[Parser<import('../../../mini-parse/src').ParserStream | Stream<import('../../../mini-parse/src').TypedToken<import('./WeslStream').WeslTokenKind>>, string>, Parser<import('../../../mini-parse/src').ParserStream | Stream<WeslToken>, any>]>>;
+/** parse simple struct.member style references specially, for binding struct lowering */
+export declare const simple_component_reference: Parser<import('../../../mini-parse/src').ParserStream, [string[], [string, string], any[] | null]>;
+export declare const expression: Parser<Stream<WeslToken>, any>;
+export declare const type_specifier: Parser<Stream<WeslToken>, any>;
+export declare const argument_expression_list: import('../../../mini-parse/src/CombinatorTypes').SeqParser<["(", Parser<import('../../../mini-parse/src').ParserStream | Stream<WeslToken>, any[]>, import('../../../mini-parse/src/CombinatorTypes').ParserFromArg<")">]>;

package/dist/tools/packages/wesl/src/parse/WeslGrammar.d.ts

@@ -0,0 +1,80 @@
+import { Parser, Span, Stream } from '../../../mini-parse/src';
+import { BuiltinAttribute, DiagnosticAttribute, DiagnosticDirective, EnableDirective, IfAttribute, InterpolateAttribute, RequiresDirective, StandardAttribute } from '../AbstractElems.ts';
+import { WeslToken } from './WeslStream.ts';
+export declare const weslRoot: Parser<import('../../../mini-parse/src').ParserStream | Stream<WeslToken>, [import('../AbstractElems.ts').ImportElem[], [(IfAttribute | StandardAttribute | InterpolateAttribute | BuiltinAttribute | DiagnosticAttribute | [string, {
+    value: any;
+    span: Span;
+}[]] | [string, {
+    value: any;
+    span: Span;
+}[] | null])[], DiagnosticDirective | EnableDirective | RequiresDirective][], (string | [(IfAttribute | StandardAttribute | InterpolateAttribute | BuiltinAttribute | DiagnosticAttribute | [string, {
+    value: any;
+    span: Span;
+}[]] | [string, {
+    value: any;
+    span: Span;
+}[] | null])[], string, string, [string, [(IfAttribute | StandardAttribute | InterpolateAttribute | BuiltinAttribute | DiagnosticAttribute | [string, {
+    value: any;
+    span: Span;
+}[]] | [string, {
+    value: any;
+    span: Span;
+}[] | null])[], string, string, any][], string]] | [(IfAttribute | StandardAttribute | InterpolateAttribute | BuiltinAttribute | DiagnosticAttribute | [string, {
+    value: any;
+    span: Span;
+}[]] | [string, {
+    value: any;
+    span: Span;
+}[] | null])[], string, any, string] | [(IfAttribute | StandardAttribute | InterpolateAttribute | BuiltinAttribute | DiagnosticAttribute | [string, {
+    value: any;
+    span: Span;
+}[]] | [string, {
+    value: any;
+    span: Span;
+}[] | null])[], string, string, [[string, [(IfAttribute | StandardAttribute | InterpolateAttribute | BuiltinAttribute | DiagnosticAttribute | [string, {
+    value: any;
+    span: Span;
+}[]] | [string, {
+    value: any;
+    span: Span;
+}[] | null])[], string, [string, any] | null][], string], [string, (IfAttribute | StandardAttribute | InterpolateAttribute | BuiltinAttribute | DiagnosticAttribute | [string, {
+    value: any;
+    span: Span;
+}[]] | [string, {
+    value: any;
+    span: Span;
+}[] | null])[], any] | null, [(IfAttribute | StandardAttribute | InterpolateAttribute | BuiltinAttribute | DiagnosticAttribute | [string, {
+    value: any;
+    span: Span;
+}[]] | [string, {
+    value: any;
+    span: Span;
+}[] | null])[], string, any[], string]]] | [(IfAttribute | StandardAttribute | InterpolateAttribute | BuiltinAttribute | DiagnosticAttribute | [string, {
+    value: any;
+    span: Span;
+}[]] | [string, {
+    value: any;
+    span: Span;
+}[] | null])[], string, [string, [string, any] | null], [[string, any] | null], string] | [(IfAttribute | StandardAttribute | InterpolateAttribute | BuiltinAttribute | DiagnosticAttribute | [string, {
+    value: any;
+    span: Span;
+}[]] | [string, {
+    value: any;
+    span: Span;
+}[] | null])[], string, [string, [string, any] | null], string, [any], string] | [(IfAttribute | StandardAttribute | InterpolateAttribute | BuiltinAttribute | DiagnosticAttribute | [string, {
+    value: any;
+    span: Span;
+}[]] | [string, {
+    value: any;
+    span: Span;
+}[] | null])[], string, string, string, any, string] | [(IfAttribute | StandardAttribute | InterpolateAttribute | BuiltinAttribute | DiagnosticAttribute | [string, {
+    value: any;
+    span: Span;
+}[]] | [string, {
+    value: any;
+    span: Span;
+}[] | null])[], [string, [WeslToken<import('./WeslStream.ts').WeslTokenKind> & {
+    kind: "symbol";
+}, any[], WeslToken<import('./WeslStream.ts').WeslTokenKind> & {
+    kind: "symbol";
+}] | null, [string, [string, any] | null], [string, any] | null], string])[], true]>;