wesl 0.6.0-pre2

package/dist/linker/packages/linker/src/CommentsGrammar.d.ts

@@ -0,0 +1,6 @@
+import { Parser } from '../../mini-parse/src';
+/** currently unused */
+export declare const unknown: Parser<void, import('../../mini-parse/src').NoTags>;
+export declare const blockComment: Parser<any>;
+export declare const lineComment: import('../../mini-parse/src/CombinatorTypes.ts').SeqParser<[import('../../mini-parse/src/CombinatorTypes.ts').ParserFromArg<"//">, import('../../mini-parse/src/CombinatorTypes.ts').ParserFromArg<Parser<[...any[], any], import('../../mini-parse/src').NoTags>>]>;
+export declare const comment: Parser<any, import('../../mini-parse/src').NoTags>;

package/dist/linker/packages/linker/src/FlattenTreeImport.d.ts

@@ -0,0 +1,11 @@
+import { ImportTree } from './ImportTree.js';
+export interface FlatImport {
+    importPath: string[];
+    modulePath: string[];
+}
+/**
+ * Simplify importTree into a flattened map from import paths to module paths.
+ *
+ * @return map from import path (with 'as' renaming) to module Path
+ */
+export declare function flattenTreeImport(imp: ImportTree): FlatImport[];

package/dist/linker/packages/linker/src/ImportGrammar.d.ts

@@ -0,0 +1,13 @@
+import { NoTags, Parser } from '../../mini-parse/src';
+export declare const importTokens: import('../../mini-parse/src').FullTokenMatcher<{
+    ws: RegExp;
+    importSymbol: RegExp;
+    ident: RegExp;
+    digits: RegExp;
+}>;
+export declare const eolTokens: import('../../mini-parse/src').FullTokenMatcher<{
+    ws: RegExp;
+    eol: RegExp;
+}>;
+/** parse a WESL style wgsl import statement. */
+export declare const weslImport: Parser<[string, [string, any], string | undefined, any], NoTags>;

package/dist/linker/packages/linker/src/ImportTree.d.ts

@@ -0,0 +1,17 @@
+export declare class ImportTree {
+    segments: PathSegment[];
+    /** segments in path order */
+    constructor(segments: PathSegment[]);
+}
+export type PathSegment = SimpleSegment | ImportTree | SegmentList;
+export declare class SimpleSegment {
+    name: string;
+    as?: string | undefined;
+    args?: string[] | undefined;
+    constructor(name: string, as?: string | undefined, args?: string[] | undefined);
+}
+/** or choices for this path segment */
+export declare class SegmentList {
+    list: PathSegment[];
+    constructor(list: PathSegment[]);
+}

package/dist/linker/packages/linker/src/Linker.d.ts

@@ -0,0 +1,26 @@
+import { SrcMap } from '../../mini-parse/src';
+import { ParsedRegistry } from './ParsedRegistry.ts';
+import { Conditions } from './Scope.ts';
+import { WgslBundle } from './WgslBundle.ts';
+/**
+ * Link a set of WESL source modules (typically the text from .wesl files) into a single WGSL string.
+ * Linking starts with a specified 'root' source module, and recursively incorporates code
+ * referenced from other modules (in local files or libraries).
+ *
+ * Unreferenced (dead) code outside the root module is not included in the output WGSL.
+ * Additionally the caller can specify conditions for to control conditional compilation.
+ * Only code that is valid with the current conditions is included in the output.
+ *
+ * @param weslSrc map of wesl source strings (aka modules) by scoped path
+ *                key is module path or file path
+ *                  `package::foo::bar`, or './foo/bar.wesl', or './foo/bar'
+ *                value is wesl src
+ *                (inludes both library and local WESL modules)
+ * @param rootModuleName name or module path of the root module
+ * @param conditions runtime conditions for conditional compilation
+ */
+export declare function linkWesl(weslSrc: Record<string, string>, rootModuleName?: string, conditions?: Conditions): SrcMap;
+export declare function linkWeslFiles(weslSrc: Record<string, string>, rootModuleName?: string, conditions?: Conditions, 
+/** record of file names and wgsl text for modules */
+libs?: WgslBundle[], maxParseCount?: number): SrcMap;
+export declare function linkRegistry(parsed: ParsedRegistry, rootModuleName?: string, conditions?: Conditions): SrcMap;

package/dist/linker/packages/linker/src/LowerAndEmit.d.ts

@@ -0,0 +1,25 @@
+import { SrcMapBuilder } from '../../mini-parse/src';
+import { AbstractElem, DeclIdentElem, RefIdentElem, NameElem, TextElem } from './AbstractElems.ts';
+import { Conditions, DeclIdent, Ident } from './Scope.ts';
+/** passed to the emitters */
+interface EmitContext {
+    srcBuilder: SrcMapBuilder;
+    conditions: Conditions;
+    extracting: boolean;
+}
+/** traverse the AST, starting from root elements, emitting wgsl for each */
+export declare function lowerAndEmit(srcBuilder: SrcMapBuilder, rootElems: AbstractElem[], conditions: Conditions, extracting?: boolean): void;
+export declare function lowerAndEmitElem(e: AbstractElem, ctx: EmitContext): void;
+export declare function emitText(e: TextElem, ctx: EmitContext): void;
+export declare function emitName(e: NameElem, ctx: EmitContext): void;
+export declare function emitContents(elem: AbstractElem & {
+    contents: AbstractElem[];
+}, ctx: EmitContext): void;
+export declare function emitIdent(e: RefIdentElem | DeclIdentElem, ctx: EmitContext): void;
+/** trace through refersTo links in reference Idents until we find the declaration
+ * expects that bindIdents has filled in all refersTo: links
+ */
+export declare function findDecl(ident: Ident): DeclIdent;
+/** check if the element is visible with the current current conditional compilation settings */
+export declare function conditionsValid(elem: AbstractElem, conditions: Conditions): boolean;
+export {};

package/dist/linker/packages/linker/src/ParseWESL.d.ts

@@ -0,0 +1,36 @@
+import { AppState, SrcMap } from '../../mini-parse/src';
+import { ModuleElem } from './AbstractElems.ts';
+import { ImportTree } from './ImportTree.ts';
+import { Scope, SrcModule } from './Scope.ts';
+import { OpenElem } from './WESLCollect.ts';
+import { FlatImport } from './FlattenTreeImport.ts';
+/** result of a parse */
+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: ImportTree[];
+    _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[];
+}
+export declare function parseSrcModule(srcModule: SrcModule, srcMap?: SrcMap, maxParseCount?: number | undefined): WeslAST;
+export declare function parseWESL(src: string, srcMap?: SrcMap, maxParseCount?: number | undefined): 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: WeslAST): FlatImport[];

package/dist/linker/packages/linker/src/ParsedRegistry.d.ts

@@ -0,0 +1,26 @@
+import { WgslBundle } from 'random_wgsl';
+import { WeslAST } from './ParseWESL.ts';
+export interface ParsedRegistry {
+    modules: Record<string, WeslAST>;
+}
+export declare function parsedRegistry(): ParsedRegistry;
+/**
+ * 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)
+ *    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, maxParseCount?: number): void;
+export declare function parseLibsIntoRegistry(libs: WgslBundle[], registry: ParsedRegistry): void;

package/dist/linker/packages/linker/src/PathUtil.d.ts

@@ -0,0 +1,9 @@
+/** simplistic path manipulation utilities */
+export declare function relativePath(srcPath: string | undefined, reqPath: string): string;
+export declare function dirname(path: string): string;
+export declare function join(a: string, b: string): string;
+/** 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/linker/packages/linker/src/Scope.d.ts

@@ -0,0 +1,55 @@
+import { DeclarationElem, 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" */
+    filePath: string;
+    /** original src for module */
+    src: string;
+}
+/** a src declaration or reference to an ident */
+export type Ident = DeclIdent | RefIdent;
+export type Conditions = Record<string, boolean>;
+interface IdentBase {
+    originalName: string;
+    conditions?: Conditions;
+    id?: number;
+}
+export interface RefIdent extends IdentBase {
+    kind: "ref";
+    refersTo?: Ident;
+    std?: true;
+    ast: WeslAST;
+    scope: Scope;
+    refIdentElem?: RefIdentElem;
+}
+export interface DeclIdent extends IdentBase {
+    kind: "decl";
+    mangledName?: string;
+    declElem?: DeclarationElem;
+    scope: Scope;
+}
+export type ScopeKind = "module-scope" | "body-scope";
+/** tree of ident references, organized by lexical scope */
+export interface Scope {
+    id?: number;
+    idents: Ident[];
+    parent: Scope | null;
+    children: Scope[];
+    kind: ScopeKind;
+}
+export declare function resetScopeIds(): void;
+/** make a new Scope object */
+export declare function makeScope(s: Omit<Scope, "id">): Scope;
+export interface RootAndScope {
+    rootScope: Scope;
+    scope: Scope;
+}
+export declare function emptyScope(kind: ScopeKind): Scope;
+export declare function emptyBodyScope(parent: Scope): Scope;
+/** For debugging,
+ * @return true if a scope is in the rootScope tree somewhere */
+export declare function containsScope(rootScope: Scope, scope: Scope): boolean;
+export declare function exportDecl(scope: Scope, name: string): DeclIdent | undefined;
+export {};

package/dist/linker/packages/linker/src/Slicer.d.ts

@@ -0,0 +1,26 @@
+import { SrcMap } from '../../mini-parse/src';
+/** specify a start,end portion of a string to be replaced */
+export interface SliceReplace {
+    start: number;
+    end: number;
+    replacement: string;
+}
+/**
+ * Rewrite a string by replacing segments them with provided texts.
+ *
+ * example:
+ * src:
+ *  aaabbbbbc
+ *     ^    ^
+ *     St   End Repl='XXX'
+ *
+ * returns a srcMap with the new text and mappings from the original text to the new text
+ *  aaaXXXc
+ */
+export declare function sliceReplace(src: string, slices: SliceReplace[], start?: number, end?: number): SrcMap;
+/** find strings in a text -
+ * found strings must be 'tokens', surrounded by spaces or punctuation
+ *
+ * @return SliceReplace elements
+ */
+export declare function sliceWords(text: string, replace: Record<string, string>): SliceReplace[];

package/dist/linker/packages/linker/src/StandardTypes.d.ts

@@ -0,0 +1,6 @@
+export declare const stdFns: string[];
+export declare const stdTypes: 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;

package/dist/linker/packages/linker/src/Util.d.ts

@@ -0,0 +1,26 @@
+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;

package/dist/linker/packages/linker/src/WESLCollect.d.ts

@@ -0,0 +1,29 @@
+import { CollectContext, CollectPair } from '../../mini-parse/src';
+import { AbstractElem, AliasElem, ConstElem, DeclIdentElem, ElemWithContents, FnElem, GlobalVarElem, ImportElem, ModuleElem, NameElem, OverrideElem, ParamElem, RefIdentElem, StructElem, StructMemberElem, VarElem } from './AbstractElems.ts';
+import { ImportTree, SegmentList, SimpleSegment } from './ImportTree.ts';
+/** create reference Ident and add to context */
+export declare function refIdent(cc: CollectContext): RefIdentElem;
+/** create declaration Ident and add to context */
+export declare function declIdentElem(cc: CollectContext): DeclIdentElem;
+export type OpenElem<T extends AbstractElem = AbstractElem> = Pick<T, "kind"> & {
+    contents: AbstractElem[];
+};
+export type PartElem<T extends AbstractElem = AbstractElem> = Pick<T, "kind" | "start" | "end"> & {
+    contents: AbstractElem[];
+};
+type VarLikeElem = GlobalVarElem | VarElem | ConstElem | OverrideElem | AliasElem;
+export declare function collectVarLike<E extends VarLikeElem>(kind: E["kind"]): CollectPair<E>;
+export declare function collectFn(): CollectPair<FnElem>;
+export declare function collectFnParam(): CollectPair<ParamElem>;
+export declare function collectStruct(): CollectPair<StructElem>;
+export declare function collectStructMember(): CollectPair<StructMemberElem>;
+export declare function collectNameElem(cc: CollectContext): NameElem;
+export declare function collectModule(): CollectPair<ModuleElem>;
+export declare function importList(cc: CollectContext): SegmentList;
+export declare function importSegment(cc: CollectContext): SimpleSegment;
+export declare function importTree(cc: CollectContext): ImportTree;
+export declare function importElem(): CollectPair<ImportElem>;
+/** collect a scope start starts before and ends after a parser */
+export declare function scopeCollect(): CollectPair<void>;
+export declare function collectSimpleElem<V extends AbstractElem & ElemWithContents>(kind: V["kind"]): CollectPair<V>;
+export {};

package/dist/linker/packages/linker/src/WESLGrammar.d.ts

@@ -0,0 +1,23 @@
+import { Parser } from '../../mini-parse/src';
+/** parser that recognizes key parts of WGSL and also directives like #import */
+export declare const word: import('../../mini-parse/src/CombinatorTypes.ts').OrParser<[Parser<string, import('../../mini-parse/src').NoTags>, Parser<string, import('../../mini-parse/src').NoTags>]>;
+/** parse an identifier into a TypeNameElem */
+export declare const typeNameDecl: import('../../mini-parse/src/CombinatorTypes.ts').ParserFromArg<Parser<string, import('../../mini-parse/src').NoTags>>;
+/** parse an identifier into a TypeNameElem */
+export declare const fnNameDecl: import('../../mini-parse/src/CombinatorTypes.ts').ParserFromArg<Parser<string, import('../../mini-parse/src').NoTags>>;
+export declare const type_specifier: Parser<any>;
+export declare const struct_member: Parser<[[string, string | [string, [string, string[], string]] | [string, [string, string, string, string[], string | undefined, string]] | [string, [string, [any, [string, any][]][], string]] | [string, [string, [any, [string, any][]][], string] | undefined]][], string, string, any], import('../../mini-parse/src').NoTags>;
+export declare const struct_decl: Parser<[string, string, [string, [[string, string | [string, [string, string[], string]] | [string, [string, string, string, string[], string | undefined, string]] | [string, [string, [any, [string, any][]][], string]] | [string, [string, [any, [string, any][]][], string] | undefined]][], string, string, any][], string]], import('../../mini-parse/src').NoTags & {
+    members: [[string, string | [string, [string, string[], string]] | [string, [string, string, string, string[], string | undefined, string]] | [string, [string, [any, [string, any][]][], string]] | [string, [string, [any, [string, any][]][], string] | undefined]][], string, string, any][][];
+}>;
+/** Also covers func_call_statement.post.ident */
+export declare const fn_call: import('../../mini-parse/src/CombinatorTypes.ts').SeqParser<[Parser<string, import('../../mini-parse/src').NoTags>, () => import('../../mini-parse/src').UndefinedParser | import('../../mini-parse/src/CombinatorTypes.ts').ParserFromArg<import('../../mini-parse/src/CombinatorTypes.ts').SeqParser<[import('../../mini-parse/src/CombinatorTypes.ts').ParserFromArg<"<">, Parser<[any, [string, any][]][], import('../../mini-parse/src').NoTags>, import('../../mini-parse/src/CombinatorTypes.ts').ParserFromArg<">">]>>, import('../../mini-parse/src/CombinatorTypes.ts').SeqParser<["(", Parser<[any, [string, any][]][], import('../../mini-parse/src').NoTags>, import('../../mini-parse/src/CombinatorTypes.ts').ParserFromArg<")">]>]>;
+export declare const expression: import('../../mini-parse/src/CombinatorTypes.ts').SeqParser<[Parser<any, import('../../mini-parse/src').NoTags>, import('../../mini-parse/src/CombinatorTypes.ts').ParserFromRepeatArg<import('../../mini-parse/src/CombinatorTypes.ts').SeqParser<[import('../../mini-parse/src/CombinatorTypes.ts').OrParser<string[]>, Parser<any, import('../../mini-parse/src').NoTags>]>>]>;
+export declare const fn_decl: Parser<[[string, string | [string, [string, string[], string]] | [string, [string, string, string, string[], string | undefined, string]] | [string, [string, [any, [string, any][]][], string]] | [string, [string, [any, [string, any][]][], string] | undefined]][], string, string, [[string, [[string, string | [string, [string, string[], string]] | [string, [string, string, string, string[], string | undefined, string]] | [string, [string, [any, [string, any][]][], string]] | [string, [string, [any, [string, any][]][], string] | undefined]][], string, [string, any] | undefined][], string], [string, [string, string | [string, [string, string[], string]] | [string, [string, string, string, string[], string | undefined, string]] | [string, [string, [any, [string, any][]][], string]] | [string, [string, [any, [string, any][]][], string] | undefined]][], any] | undefined, [[string, string | [string, [string, string[], string]] | [string, [string, string, string, string[], string | undefined, string]] | [string, [string, [any, [string, any][]][], string]] | [string, [string, [any, [string, any][]][], string] | undefined]][], string, any[], string]]], import('../../mini-parse/src').NoTags & {
+    fnParam: [[string, string | [string, [string, string[], string]] | [string, [string, string, string, string[], string | undefined, string]] | [string, [string, [any, [string, any][]][], string]] | [string, [string, [any, [string, any][]][], string] | undefined]][], string, [string, any] | undefined][];
+} & {
+    returnType: any[];
+}>;
+export declare const global_alias: Parser<[string, string, string, any, string], import('../../mini-parse/src').NoTags>;
+export declare const global_decl: Parser<string | [string, string, [string, [[string, string | [string, [string, string[], string]] | [string, [string, string, string, string[], string | undefined, string]] | [string, [string, [any, [string, any][]][], string]] | [string, [string, [any, [string, any][]][], string] | undefined]][], string, string, any][], string]] | [string, [any, [string, any][]], string] | [[string, string | [string, [string, string[], string]] | [string, [string, string, string, string[], string | undefined, string]] | [string, [string, [any, [string, any][]][], string]] | [string, [string, [any, [string, any][]][], string] | undefined]][], string, string, [[string, [[string, string | [string, [string, string[], string]] | [string, [string, string, string, string[], string | undefined, string]] | [string, [string, [any, [string, any][]][], string]] | [string, [string, [any, [string, any][]][], string] | undefined]][], string, [string, any] | undefined][], string], [string, [string, string | [string, [string, string[], string]] | [string, [string, string, string, string[], string | undefined, string]] | [string, [string, [any, [string, any][]][], string]] | [string, [string, [any, [string, any][]][], string] | undefined]][], any] | undefined, [[string, string | [string, [string, string[], string]] | [string, [string, string, string, string[], string | undefined, string]] | [string, [string, [any, [string, any][]][], string]] | [string, [string, [any, [string, any][]][], string] | undefined]][], string, any[], string]]] | [[string, string | [string, [string, string[], string]] | [string, [string, string, string, string[], string | undefined, string]] | [string, [string, [any, [string, any][]][], string]] | [string, [string, [any, [string, any][]][], string] | undefined]][], string, [string, [string, any] | undefined], [[string, [any, [string, any][]]] | undefined], string] | [string, [string, [string, any] | undefined], string, [[any, [string, any][]]], string] | [string, string, string, any, string] | [[string, string | [string, [string, string[], string]] | [string, [string, string, string, string[], string | undefined, string]] | [string, [string, [any, [string, any][]][], string]] | [string, [string, [any, [string, any][]][], string] | undefined]][], [string, [string, string[], string] | undefined, [string, [string, any] | undefined], [string, [any, [string, any][]]] | undefined], string], import('../../mini-parse/src').NoTags>;
+export declare const weslRoot: Parser<[[string, [string, any], string | undefined, any][], ([string, [string, any], string | undefined, any] | [[string, [string, string, string, string[], string | undefined, string]] | [string, string[]], string])[], (string | [string, [string, any], string | undefined, any] | [string, string, [string, [[string, string | [string, [string, string[], string]] | [string, [string, string, string, string[], string | undefined, string]] | [string, [string, [any, [string, any][]][], string]] | [string, [string, [any, [string, any][]][], string] | undefined]][], string, string, any][], string]] | [string, [any, [string, any][]], string] | [[string, string | [string, [string, string[], string]] | [string, [string, string, string, string[], string | undefined, string]] | [string, [string, [any, [string, any][]][], string]] | [string, [string, [any, [string, any][]][], string] | undefined]][], string, string, [[string, [[string, string | [string, [string, string[], string]] | [string, [string, string, string, string[], string | undefined, string]] | [string, [string, [any, [string, any][]][], string]] | [string, [string, [any, [string, any][]][], string] | undefined]][], string, [string, any] | undefined][], string], [string, [string, string | [string, [string, string[], string]] | [string, [string, string, string, string[], string | undefined, string]] | [string, [string, [any, [string, any][]][], string]] | [string, [string, [any, [string, any][]][], string] | undefined]][], any] | undefined, [[string, string | [string, [string, string[], string]] | [string, [string, string, string, string[], string | undefined, string]] | [string, [string, [any, [string, any][]][], string]] | [string, [string, [any, [string, any][]][], string] | undefined]][], string, any[], string]]] | [[string, string | [string, [string, string[], string]] | [string, [string, string, string, string[], string | undefined, string]] | [string, [string, [any, [string, any][]][], string]] | [string, [string, [any, [string, any][]][], string] | undefined]][], string, [string, [string, any] | undefined], [[string, [any, [string, any][]]] | undefined], string] | [string, [string, [string, any] | undefined], string, [[any, [string, any][]]], string] | [string, string, string, any, string] | [[string, string | [string, [string, string[], string]] | [string, [string, string, string, string[], string | undefined, string]] | [string, [string, [any, [string, any][]][], string]] | [string, [string, [any, [string, any][]][], string] | undefined]][], [string, [string, string[], string] | undefined, [string, [string, any] | undefined], [string, [any, [string, any][]]] | undefined], string])[], [string[], true]], import('../../mini-parse/src').NoTags>;

package/dist/linker/packages/linker/src/WESLTokens.d.ts

@@ -0,0 +1,42 @@
+/** New lines */
+export declare const eol: RegExp;
+/** Whitespaces including new lines */
+export declare const blankspaces: RegExp;
+export declare const directive: RegExp;
+export declare const ident: RegExp;
+export declare const digits: RegExp;
+/** main set of tokens for WGSL */
+export declare const mainTokens: import('../../mini-parse/src').FullTokenMatcher<{
+    directive: RegExp;
+    textureStorage: RegExp;
+    ident: RegExp;
+    digits: RegExp;
+    symbol: RegExp;
+    quote: RegExp;
+    ws: RegExp;
+}>;
+export declare const bracketTokens: import('../../mini-parse/src').FullTokenMatcher<{
+    bracket: RegExp;
+    ws: RegExp;
+    other: RegExp;
+}>;
+/** matching tokens at the start of a '//' line comment that might contain #directives */
+export declare const lineCommentTokens: import('../../mini-parse/src').FullTokenMatcher<{
+    ws: RegExp;
+    notEol: RegExp;
+    eol: RegExp;
+}>;
+/** matching tokens while parsing directive parameters #export foo(param1, param2) */
+export declare const argsTokens: import('../../mini-parse/src').FullTokenMatcher<{
+    directive: RegExp;
+    quote: RegExp;
+    relPath: RegExp;
+    arg: RegExp;
+    symbol: RegExp;
+    ws: RegExp;
+    eol: RegExp;
+}>;
+export declare const rootWs: import('../../mini-parse/src').FullTokenMatcher<{
+    blanks: RegExp;
+    other: RegExp;
+}>;

package/dist/linker/packages/linker/src/WgslBundle.d.ts

@@ -0,0 +1,13 @@
+export interface WgslBundle {
+    /** name of the package, e.g. wgsl-rand */
+    name: string;
+    /** npm version of the package  e.g. 0.4.1 */
+    version: 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>;
+}

package/dist/linker/packages/linker/src/debug/ASTtoString.d.ts

@@ -0,0 +1,3 @@
+import { AbstractElem } from '../AbstractElems.ts';
+export declare function astToString(elem: AbstractElem, indent?: number): string;
+export declare function elemToString(elem: AbstractElem): string;

package/dist/linker/packages/linker/src/debug/ImportToString.d.ts

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

package/dist/linker/packages/linker/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/linker/packages/linker/src/debug/ScopeToString.d.ts

@@ -0,0 +1,4 @@
+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): string;
+export declare function identToString(ident?: Ident): string;

package/dist/linker/packages/linker/src/index.d.ts

@@ -0,0 +1,7 @@
+export * from './debug/ASTtoString.js';
+export * from './debug/ScopeToString.js';
+export * from './Linker.js';
+export * from './ParseWESL.js';
+export * from './PathUtil.js';
+export * from './Util.js';
+export * from './WgslBundle.js';

package/dist/linker/packages/linker/src/test/ErrorLogging.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/linker/packages/linker/src/test/Expression.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/linker/packages/linker/src/test/FlattenTreeImport.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/linker/packages/linker/src/test/ImportCases.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/linker/packages/linker/src/test/ImportSyntaxCases.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/linker/packages/linker/src/test/LinkGlob.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/linker/packages/linker/src/test/LinkPackage.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/linker/packages/linker/src/test/Linker.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/linker/packages/linker/src/test/MatchWgslD.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/linker/packages/linker/src/test/ParseComments.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/linker/packages/linker/src/test/ParseWESL.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/linker/packages/linker/src/test/PathUtil.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/linker/packages/linker/src/test/PrettyGrammar.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/linker/packages/linker/src/test/ScopeWESL.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/linker/packages/linker/src/test/Slicer.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/linker/packages/linker/src/test/TestSetup.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/linker/packages/linker/src/test/TestUtil.d.ts

@@ -0,0 +1,15 @@
+import { NoTags, Parser, TagRecord } from '../../../mini-parse/src';
+import { TestParseResult } from '../../../mini-parse/src/test-util';
+import { WeslAST } from '../ParseWESL.js';
+export declare function testAppParse<T, N extends TagRecord = NoTags>(parser: Parser<T, N>, src: string): TestParseResult<T, N, WeslAST>;
+/** Convenience wrapper to link wgsl for tests.
+ * The first module is named "package::root",
+ * subsequent modules are named "package::file1", "package::file2", etc.
+ */
+export declare function link2Test(...rawWgsl: string[]): string;
+/** link wesl for tests, and return the console log as well */
+export declare function linkWithLog(...rawWgsl: string[]): {
+    log: string;
+    result: string;
+};
+export declare function parse2Test(src: string): WeslAST;

package/dist/linker/packages/linker/src/test/Util.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/linker/packages/linker/src/test/shared/StringUtil.d.ts

@@ -0,0 +1,8 @@
+/** trim source for test comparisons
+ * rm blank lines
+ * rm leading indent consistently across remaining lines
+ * rm trailing spaces from each line */
+export declare function trimSrc(src: string): string;
+export declare function dropWhile<T>(a: T[], fn: (el: T) => boolean): T[];
+export declare function dropRightWhile<T>(a: T[], fn: (el: T) => boolean): T[];
+export declare function matchTrimmed(result: string, expected: string): void;

package/dist/linker/packages/linker/src/test/shared/test/StringUtil.test.d.ts

@@ -0,0 +1 @@
+export {};