wesl-link 0.6.6 → 0.6.7

package/bin/wesl-packager

@@ -0,0 +1,1510 @@
+#!/usr/bin/env node
+import { hideBin } from "yargs/helpers";
+import path from "node:path";
+import "diff";
+import { CachingStream, MatchersStream, ParseError, RegexMatchers, collectArray, delimited, enableTracing, eof, fn, kind, log, matchOneOf, not, opt, or, preceded, repeat, repeatPlus, req, separated_pair, seq, seqObj, span, tagScope, terminated, text, token, tokenKind, tokenOf, tracing, withSep, withSepPlus, withStreamAction, yes } from "mini-parse";
+import { astToString, link, scopeToString } from "wesl";
+import { loadModules, versionFromPackageJson } from "wesl-tooling";
+import yargs from "yargs";
+
+//#region ../wesl/src/Util.ts
+/** filter an array, returning the truthy results of the filter function */
+function filterMap(arr, fn$1) {
+	const out = [];
+	for (const t of arr) {
+		const u = fn$1(t);
+		if (u) out.push(u);
+	}
+	return out;
+}
+/**
+* Maps an character position in a string to a 1-indexed line number, and 1-indexed column.
+*/
+function offsetToLineNumber(offset, text$1) {
+	const safeOffset = Math.min(text$1.length, Math.max(0, offset));
+	let lineStartOffset = 0;
+	let lineNum = 1;
+	while (true) {
+		const lineEnd = text$1.indexOf("\n", lineStartOffset);
+		if (lineEnd === -1 || safeOffset <= lineEnd) {
+			const linePos = 1 + (safeOffset - lineStartOffset);
+			return [lineNum, linePos];
+		} else {
+			lineStartOffset = lineEnd + 1;
+			lineNum += 1;
+		}
+	}
+}
+/** Highlights an error.
+*
+* Returns a string with the line, and a string with the ^^^^ carets
+*/
+function errorHighlight(source, span$1) {
+	let lineStartOffset = source.lastIndexOf("\n", span$1[0]);
+	if (lineStartOffset === -1) lineStartOffset = 0;
+	let lineEndOffset = source.indexOf("\n", span$1[0]);
+	if (lineEndOffset === -1) lineEndOffset = source.length;
+	const errorLength = span$1[1] - span$1[0];
+	const caretCount = Math.max(1, errorLength);
+	const linePos = span$1[0] - lineStartOffset;
+	return [source.slice(lineStartOffset, lineEndOffset), " ".repeat(linePos) + "^".repeat(caretCount)];
+}
+
+//#endregion
+//#region ../wesl/src/vlq/vlq.ts
+/*!
+Copyright (c) 2017-2021 [these people](https://github.com/Rich-Harris/vlq/graphs/contributors)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+*/
+const char_to_integer = {};
+const integer_to_char = {};
+"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=".split("").forEach((char, i) => {
+	char_to_integer[char] = i;
+	integer_to_char[i] = char;
+});
+function encodeVlq(value) {
+	if (typeof value === "number") return encode_integer(value);
+	let result = "";
+	for (let i = 0; i < value.length; i += 1) result += encode_integer(value[i]);
+	return result;
+}
+function encode_integer(num) {
+	let result = "";
+	let enc;
+	if (num < 0) enc = -num << 1 | 1;
+	else enc = num << 1;
+	do {
+		let clamped = enc & 31;
+		enc >>>= 5;
+		if (enc > 0) clamped |= 32;
+		result += integer_to_char[clamped];
+	} while (enc > 0);
+	return result;
+}
+
+//#endregion
+//#region ../wesl/src/ClickableError.ts
+/** Throw an error with an embedded source map so that browser users can
+*  click on the error in the browser debug console and see the wesl source code.  */
+function throwClickableError(params) {
+	const { url, text: text$1, lineNumber, lineColumn, length, error } = params;
+	const mappings = encodeVlq([
+		0,
+		0,
+		Math.max(0, lineNumber - 1),
+		Math.max(0, lineColumn - 1)
+	]) + "," + encodeVlq([
+		18,
+		0,
+		Math.max(0, lineNumber - 1),
+		Math.max(0, lineColumn - 1) + length
+	]);
+	const sourceMap = {
+		version: 3,
+		file: null,
+		sources: [url],
+		sourcesContent: [text$1 ?? null],
+		names: [],
+		mappings
+	};
+	let generatedCode = `throw new Error(${JSON.stringify(error.message + "")})`;
+	generatedCode += "\n//# sourceMappingURL=data:application/json;base64," + btoa(unescape(encodeURIComponent(JSON.stringify(sourceMap))));
+	generatedCode += "\n//# sourceURL=" + sourceMap.sources[0];
+	let oldLimit = 0;
+	if ("stackTraceLimit" in Error) {
+		oldLimit = Error.stackTraceLimit;
+		Error.stackTraceLimit = 1;
+	}
+	try {
+		(0, eval)(generatedCode);
+	} catch (e) {
+		if ("stackTraceLimit" in Error) Error.stackTraceLimit = oldLimit;
+		error.message = "";
+		if (tracing) e.cause = error;
+		throw e;
+	}
+}
+
+//#endregion
+//#region ../wesl/src/Assertions.ts
+/** checks whether a condition is true, otherwise throws */
+function assertThat(condition, msg) {
+	if (!condition) throw new Error(msg);
+}
+/** when debug testing is enabled, checks whether a condition is true, otherwise throws */
+function assertThatDebug(condition, msg) {
+	tracing && assertThat(condition, msg);
+}
+/**
+* Useful to validate that all cases are handled,
+* TypeScript should complain if this statement could possibly be executed.
+*
+* If this is somehow executed at runtime, throw an exception.
+*/
+function assertUnreachable(value) {
+	throw new ErrorWithData("Unreachable value", { data: value });
+}
+var ErrorWithData = class extends Error {
+	data;
+	constructor(message, options) {
+		super(message, options);
+		this.data = options?.data;
+	}
+};
+
+//#endregion
+//#region ../wesl/src/Scope.ts
+/** Combine two scope siblings.
+* The first scope is mutated to append the contents of the second.  */
+function mergeScope(a, b) {
+	if (!b) return;
+	assertThatDebug(a.kind === b.kind);
+	assertThatDebug(a.parent === b.parent);
+	assertThatDebug(!b.ifAttribute);
+	a.contents = a.contents.concat(b.contents);
+}
+/** reset scope and ident debugging ids */
+function resetScopeIds() {
+	scopeId = 0;
+	identId = 0;
+}
+let scopeId = 0;
+let identId = 0;
+function nextIdentId() {
+	return identId++;
+}
+/** make a new Scope object */
+function emptyScope(parent, kind$1 = "scope") {
+	const id = scopeId++;
+	return {
+		id,
+		kind: kind$1,
+		parent,
+		contents: []
+	};
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/berry-pretty@0.0.5/node_modules/berry-pretty/dist/index.js
+var spaces = memoize((nesting) => {
+	return " ".repeat(nesting);
+});
+var defaultCallerSize = 20;
+var multiLinePad = "\n" + spaces(defaultCallerSize + 3);
+function memoize(fn$1) {
+	const cache = /* @__PURE__ */ new Map();
+	return function(...args) {
+		const key = JSON.stringify(args);
+		if (cache.has(key)) return cache.get(key);
+		else {
+			const value = fn$1(...args);
+			cache.set(key, value);
+			return value;
+		}
+	};
+}
+if (typeof DOMRect === "undefined") globalThis.DOMRect = function() {};
+
+//#endregion
+//#region ../wesl/src/WESLCollect.ts
+function importElem(cc) {
+	const importElems = cc.tags.owo?.[0];
+	for (const importElem$1 of importElems) {
+		cc.app.stable.imports.push(importElem$1.imports);
+		addToOpenElem(cc, importElem$1);
+	}
+}
+/** add an elem to the .contents array of the currently containing element */
+function addToOpenElem(cc, elem) {
+	const weslContext = cc.app.context;
+	const { openElems } = weslContext;
+	if (openElems?.length) {
+		const open = openElems[openElems.length - 1];
+		open.contents.push(elem);
+	}
+}
+/** create reference Ident and add to context */
+function refIdent(cc) {
+	const { src, start, end } = cc;
+	const app = cc.app;
+	const { srcModule } = app.stable;
+	const originalName = src.slice(start, end);
+	const kind$1 = "ref";
+	const ident$1 = {
+		kind: kind$1,
+		originalName,
+		ast: cc.app.stable,
+		id: nextIdentId(),
+		refIdentElem: null
+	};
+	const identElem = {
+		kind: kind$1,
+		start,
+		end,
+		srcModule,
+		ident: ident$1
+	};
+	ident$1.refIdentElem = identElem;
+	saveIdent(cc, identElem);
+	addToOpenElem(cc, identElem);
+	return identElem;
+}
+/** create declaration Ident and add to context */
+function declCollect(cc) {
+	return declCollectInternal(cc, false);
+}
+/** create global declaration Ident and add to context */
+function globalDeclCollect(cc) {
+	return declCollectInternal(cc, true);
+}
+function declCollectInternal(cc, isGlobal) {
+	const { src, start, end } = cc;
+	const app = cc.app;
+	const { scope: containingScope } = app.context;
+	const { srcModule } = app.stable;
+	const originalName = src.slice(start, end);
+	const kind$1 = "decl";
+	const declElem = null;
+	const ident$1 = {
+		declElem,
+		kind: kind$1,
+		originalName,
+		containingScope,
+		isGlobal,
+		id: nextIdentId(),
+		srcModule
+	};
+	const identElem = {
+		kind: kind$1,
+		start,
+		end,
+		srcModule,
+		ident: ident$1
+	};
+	saveIdent(cc, identElem);
+	addToOpenElem(cc, identElem);
+	return identElem;
+}
+const typedDecl = collectElem("typeDecl", (cc, openElem) => {
+	const decl = cc.tags.decl_elem?.[0];
+	const typeRef = cc.tags.typeRefElem?.[0];
+	const typeScope = cc.tags.decl_type?.[0];
+	const partial = {
+		...openElem,
+		decl,
+		typeScope,
+		typeRef
+	};
+	const elem = withTextCover(partial, cc);
+	return elem;
+});
+/** add Ident to current open scope, add IdentElem to current open element */
+function saveIdent(cc, identElem) {
+	const { ident: ident$1 } = identElem;
+	ident$1.id = nextIdentId();
+	const weslContext = cc.app.context;
+	weslContext.scope.contents.push(ident$1);
+}
+/** start a new child lexical Scope */
+function startScope(cc) {
+	startSomeScope("scope", cc);
+}
+/** start a new child partial Scope */
+function startPartialScope(cc) {
+	startSomeScope("partial", cc);
+}
+/** start a new lexical or partial scope */
+function startSomeScope(kind$1, cc) {
+	const { scope } = cc.app.context;
+	const newScope = emptyScope(scope, kind$1);
+	scope.contents.push(newScope);
+	cc.app.context.scope = newScope;
+}
+function completeScope(cc) {
+	return completeScopeInternal(cc, true);
+}
+function completeScopeNoIf(cc) {
+	return completeScopeInternal(cc, false);
+}
+function completeScopeInternal(cc, attachIfs) {
+	const weslContext = cc.app.context;
+	const completedScope = weslContext.scope;
+	const { parent } = completedScope;
+	if (parent) weslContext.scope = parent;
+	else if (tracing) console.log("ERR: completeScope, no parent scope", completedScope.contents);
+	if (attachIfs) {
+		const ifAttributes = collectIfAttributes(cc);
+		completedScope.ifAttribute = ifAttributes?.[0];
+	}
+	return completedScope;
+}
+/** return @if attributes from the 'attribute' tag */
+function collectIfAttributes(cc) {
+	const attributes = cc.tags.attribute;
+	return filterIfAttributes(attributes);
+}
+function filterIfAttributes(attributes) {
+	if (!attributes) return;
+	return filterMap(attributes, (a) => a.attribute.kind === "@if" ? a.attribute : void 0);
+}
+function collectVarLike(kind$1) {
+	return collectElem(kind$1, (cc, openElem) => {
+		const name$1 = cc.tags.var_name?.[0];
+		const decl_scope = cc.tags.decl_scope?.[0];
+		const attributes = cc.tags.attribute;
+		const partElem = {
+			...openElem,
+			name: name$1,
+			attributes
+		};
+		const varElem = withTextCover(partElem, cc);
+		const declIdent = name$1.decl.ident;
+		declIdent.declElem = varElem;
+		if (name$1.typeScope) {
+			mergeScope(name$1.typeScope, decl_scope);
+			declIdent.dependentScope = name$1.typeScope;
+		} else declIdent.dependentScope = decl_scope;
+		return varElem;
+	});
+}
+const aliasCollect = collectElem("alias", (cc, openElem) => {
+	const name$1 = cc.tags.alias_name?.[0];
+	const alias_scope = cc.tags.alias_scope?.[0];
+	const typeRef = cc.tags.typeRefElem?.[0];
+	const attributes = cc.tags.attributes?.flat() ?? [];
+	const partElem = {
+		...openElem,
+		name: name$1,
+		attributes,
+		typeRef
+	};
+	const aliasElem = withTextCover(partElem, cc);
+	name$1.ident.dependentScope = alias_scope;
+	name$1.ident.declElem = aliasElem;
+	return 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
+*   }
+* }
+*/
+const fnCollect = collectElem("fn", (cc, openElem) => {
+	const ourTags = fnTags(cc);
+	const { name: name$1, headerScope, returnScope, bodyScope, body, params } = ourTags;
+	const { attributes, returnAttributes, returnType, fnScope } = ourTags;
+	const fnElem = {
+		...openElem,
+		name: name$1,
+		attributes,
+		params,
+		returnAttributes,
+		body,
+		returnType
+	};
+	fnScope.ifAttribute = filterIfAttributes(attributes)?.[0];
+	const mergedScope = headerScope;
+	returnScope && mergeScope(mergedScope, returnScope);
+	mergeScope(mergedScope, bodyScope);
+	const filtered = [];
+	for (const e of fnScope.contents) if (e === headerScope || e === returnScope) continue;
+	else if (e === bodyScope) filtered.push(mergedScope);
+	else filtered.push(e);
+	fnScope.contents = filtered;
+	name$1.ident.declElem = fnElem;
+	name$1.ident.dependentScope = mergedScope;
+	return fnElem;
+});
+/** Fetch and cast the collection tags for fnCollect
+* LATER typechecking for collect! */
+function fnTags(cc) {
+	const { fn_attributes, fn_name, fn_param, return_attributes } = cc.tags;
+	const { return_type } = cc.tags;
+	const { header_scope, return_scope, body_scope, body_statement } = cc.tags;
+	const { fn_partial_scope } = cc.tags;
+	const name$1 = fn_name?.[0];
+	const headerScope = header_scope?.[0];
+	const returnScope = return_scope?.[0];
+	const bodyScope = body_scope?.[0];
+	const body = body_statement?.[0];
+	const params = fn_param?.flat(3) ?? [];
+	const attributes = fn_attributes?.flat();
+	const returnAttributes = return_attributes?.flat();
+	const returnType = return_type?.flat(3)[0];
+	const fnScope = fn_partial_scope?.[0];
+	return {
+		name: name$1,
+		headerScope,
+		returnScope,
+		bodyScope,
+		body,
+		params,
+		attributes,
+		returnAttributes,
+		returnType,
+		fnScope
+	};
+}
+const collectFnParam = collectElem("param", (cc, openElem) => {
+	const name$1 = cc.tags.param_name?.[0];
+	const attributes = cc.tags.attributes?.flat() ?? [];
+	const elem = {
+		...openElem,
+		name: name$1,
+		attributes
+	};
+	const paramElem = withTextCover(elem, cc);
+	name$1.decl.ident.declElem = paramElem;
+	return paramElem;
+});
+const collectStruct = collectElem("struct", (cc, openElem) => {
+	const name$1 = cc.tags.type_name?.[0];
+	const members = cc.tags.members;
+	const attributes = cc.tags.attributes?.flat() ?? [];
+	name$1.ident.dependentScope = cc.tags.struct_scope?.[0];
+	const structElem = {
+		...openElem,
+		name: name$1,
+		attributes,
+		members
+	};
+	const elem = withTextCover(structElem, cc);
+	name$1.ident.declElem = elem;
+	return elem;
+});
+const collectStructMember = collectElem("member", (cc, openElem) => {
+	const name$1 = cc.tags.nameElem?.[0];
+	const typeRef = cc.tags.typeRefElem?.[0];
+	const attributes = cc.tags.attribute?.flat(3);
+	const partElem = {
+		...openElem,
+		name: name$1,
+		attributes,
+		typeRef
+	};
+	return withTextCover(partElem, cc);
+});
+const specialAttribute = collectElem("attribute", (cc, openElem) => {
+	const attribute = cc.tags.attr_variant?.[0];
+	const attrElem = {
+		...openElem,
+		attribute
+	};
+	return attrElem;
+});
+const assertCollect = attrElemCollect("assert");
+const statementCollect = attrElemCollect("statement");
+const switchClauseCollect = attrElemCollect("switch-clause");
+/** @return a collector for container elem types that have only an attributes field */
+function attrElemCollect(kind$1) {
+	return collectElem(kind$1, (cc, openElem) => {
+		const attributes = cc.tags.attribute?.flat(3);
+		const partElem = {
+			...openElem,
+			attributes
+		};
+		return withTextCover(partElem, cc);
+	});
+}
+const collectAttribute = collectElem("attribute", (cc, openElem) => {
+	const params = cc.tags.attrParam;
+	const name$1 = cc.tags.name?.[0];
+	const kind$1 = "@attribute";
+	const stdAttribute = {
+		kind: kind$1,
+		name: name$1,
+		params
+	};
+	const attrElem = {
+		...openElem,
+		attribute: stdAttribute
+	};
+	return attrElem;
+});
+const typeRefCollect = collectElem("type", (cc, openElem) => {
+	const templateParamsTemp = cc.tags.templateParam?.flat(3);
+	const typeRef = cc.tags.typeRefName?.[0];
+	const name$1 = typeof typeRef === "string" ? typeRef : typeRef.ident;
+	const partElem = {
+		...openElem,
+		name: name$1,
+		templateParams: templateParamsTemp
+	};
+	return withTextCover(partElem, cc);
+});
+const expressionCollect = collectElem("expression", (cc, openElem) => {
+	const partElem = { ...openElem };
+	return withTextCover(partElem, cc);
+});
+function globalAssertCollect(cc) {
+	const globalAssert = cc.tags.const_assert?.flat()[0];
+	const ast = cc.app.stable;
+	if (!ast.moduleAsserts) ast.moduleAsserts = [];
+	ast.moduleAsserts.push(globalAssert);
+}
+const stuffCollect = collectElem("stuff", (cc, openElem) => {
+	const partElem = { ...openElem };
+	return withTextCover(partElem, cc);
+});
+const memberRefCollect = collectElem("memberRef", (cc, openElem) => {
+	const { component, structRef, extra_components } = cc.tags;
+	const member = component?.[0];
+	const name$1 = structRef?.flat()[0];
+	const extraComponents = extra_components?.flat()[0];
+	const partElem = {
+		...openElem,
+		name: name$1,
+		member,
+		extraComponents
+	};
+	return withTextCover(partElem, cc);
+});
+function nameCollect(cc) {
+	const { start, end, src } = cc;
+	const name$1 = src.slice(start, end);
+	const elem = {
+		kind: "name",
+		start,
+		end,
+		name: name$1
+	};
+	addToOpenElem(cc, elem);
+	return elem;
+}
+const collectModule = collectElem("module", (cc, openElem) => {
+	const ccComplete = {
+		...cc,
+		start: 0,
+		end: cc.src.length
+	};
+	const moduleElem = withTextCover(openElem, ccComplete);
+	const weslState = cc.app.stable;
+	weslState.moduleElem = moduleElem;
+	return moduleElem;
+});
+function directiveCollect(cc) {
+	const { start, end } = cc;
+	const directive = cc.tags.directive?.flat()[0];
+	const attributes = cc.tags.attribute?.flat();
+	const kind$1 = "directive";
+	const elem = {
+		kind: kind$1,
+		attributes,
+		start,
+		end,
+		directive
+	};
+	addToOpenElem(cc, elem);
+	return elem;
+}
+/**
+* Collect a LexicalScope.
+*
+* The scope starts encloses all idents and subscopes inside the parser to which
+* .collect is attached
+*/
+const scopeCollect = {
+	before: startScope,
+	after: completeScope
+};
+/**
+* Collect a LexicalScope.
+*
+* The scope starts encloses all idents and subscopes inside the parser to which
+* .collect is attached
+*
+* '@if' attributes are not attached to the scope.
+*/
+const scopeCollectNoIf = {
+	before: startScope,
+	after: completeScopeNoIf
+};
+/**
+* Collect a PartialScope.
+*
+* The scope starts encloses all idents and subscopes inside the parser to which
+* .collect is attached
+*/
+const partialScopeCollect = {
+	before: startPartialScope,
+	after: completeScope
+};
+/** utility to collect an ElemWithContents
+* starts the new element as the collection point corresponding
+* to the start of the attached grammar and completes
+* the element in the at the end of the grammar.
+*
+* In between the start and the end, the new element is available
+* as an 'open' element in the collection context. While this element
+* is 'open', other collected are added to the 'contents' field of this
+* open element.
+*/
+function collectElem(kind$1, fn$1) {
+	return {
+		before: (cc) => {
+			const partialElem = {
+				kind: kind$1,
+				contents: []
+			};
+			const weslContext = cc.app.context;
+			weslContext.openElems.push(partialElem);
+		},
+		after: (cc) => {
+			const weslContext = cc.app.context;
+			const partialElem = weslContext.openElems.pop();
+			console.assert(partialElem && partialElem.kind === kind$1);
+			const elem = fn$1(cc, {
+				...partialElem,
+				start: cc.start,
+				end: cc.end
+			});
+			if (elem) addToOpenElem(cc, elem);
+			return elem;
+		}
+	};
+}
+/**
+* @return a copy of the element with contents extended
+* to include TextElems to cover the entire range.
+*/
+function withTextCover(elem, cc) {
+	const contents = coverWithText(cc, elem);
+	return {
+		...elem,
+		contents
+	};
+}
+/** cover the entire source range with Elems by creating TextElems to
+* cover any parts of the source that are not covered by other elems
+* @returns the existing elems combined with any new TextElems, in src order */
+function coverWithText(cc, elem) {
+	let { start: pos } = cc;
+	const ast = cc.app.stable;
+	const { contents, end } = elem;
+	const sorted = contents.sort((a, b) => a.start - b.start);
+	const elems = [];
+	for (const elem$1 of sorted) {
+		if (pos < elem$1.start) elems.push(makeTextElem(elem$1.start));
+		elems.push(elem$1);
+		pos = elem$1.end;
+	}
+	if (pos < end) elems.push(makeTextElem(end));
+	return elems;
+	function makeTextElem(end$1) {
+		return {
+			kind: "text",
+			start: pos,
+			end: end$1,
+			srcModule: ast.srcModule
+		};
+	}
+}
+
+//#endregion
+//#region ../wesl/src/parse/WeslBaseGrammar.ts
+const word = kind("word");
+const keyword = kind("keyword");
+const qualified_ident = withSepPlus("::", or(word, keyword, "package", "super"));
+const number = kind("number");
+
+//#endregion
+//#region ../wesl/src/parse/ImportGrammar.ts
+function makeStatement(segments, finalSegment) {
+	return {
+		kind: "import-statement",
+		segments,
+		finalSegment
+	};
+}
+function makeSegment(name$1) {
+	return {
+		kind: "import-segment",
+		name: name$1
+	};
+}
+function makeCollection(subtrees) {
+	return {
+		kind: "import-collection",
+		subtrees
+	};
+}
+function makeItem(name$1, as) {
+	return {
+		kind: "import-item",
+		name: name$1,
+		as
+	};
+}
+function prependSegments(segments, statement$1) {
+	statement$1.segments = segments.concat(statement$1.segments);
+	return statement$1;
+}
+let import_collection = null;
+const segment_blacklist = or("super", "package", "import", "as");
+/** words allowed in an import segment (after the package:: or super::super:: part if any) */
+const packageWord = preceded(not(segment_blacklist), or(word, keyword));
+const import_path_or_item = seq(packageWord, or(preceded("::", req(or(fn(() => import_collection), fn(() => import_path_or_item)), "invalid import, expected '{' or name")), preceded("as", req(word, "invalid alias, expected name")).map((v) => makeItem("", v)), yes().map(() => makeItem("")))).map(([name$1, next]) => {
+	if (next.kind === "import-collection") return makeStatement([makeSegment(name$1)], next);
+	else if (next.kind === "import-statement") return prependSegments([makeSegment(name$1)], next);
+	else if (next.kind === "import-item") {
+		next.name = name$1;
+		return makeStatement([], next);
+	} else assertUnreachable(next);
+});
+import_collection = delimited("{", withSepPlus(",", () => import_path_or_item).map(makeCollection), req("}", "invalid import collection, expected }"));
+const import_relative = or(terminated("package", req("::", "invalid import, expected '::'")).map((v) => [makeSegment(v)]), repeatPlus(terminated("super", req("::", "invalid import, expected '::'")).map(makeSegment)));
+const import_statement = span(delimited("import", seqObj({
+	relative: opt(import_relative),
+	collection_or_statement: req(or(import_collection, import_path_or_item), "invalid import, expected { or name")
+}).map(({ relative, collection_or_statement }) => {
+	if (collection_or_statement.kind === "import-statement") return prependSegments(relative ?? [], collection_or_statement);
+	else return makeStatement(relative ?? [], collection_or_statement);
+}), req(";", "invalid import, expected ';'"))).map((v) => ({
+	kind: "import",
+	imports: v.value,
+	start: v.span[0],
+	end: v.span[1]
+}));
+/** parse a WESL style wgsl import statement. */
+const weslImports = tagScope(repeat(import_statement).ptag("owo").collect(importElem));
+if (tracing) {
+	const names = {
+		import_collection,
+		import_path_or_item,
+		import_relative,
+		import_statement,
+		weslImports
+	};
+	Object.entries(names).forEach(([name$1, parser]) => {
+		parser.setTraceName(name$1);
+	});
+}
+
+//#endregion
+//#region ../wesl/src/parse/Keywords.ts
+/** https://www.w3.org/TR/WGSL/#keyword-summary */
+const keywords = `alias break case const const_assert continue continuing 
+  default diagnostic discard else enable false fn for if 
+  let loop override requires return struct switch true var while`.split(/\s+/);
+/** https://www.w3.org/TR/WGSL/#reserved-words */
+const reservedWords = `NULL Self abstract active alignas alignof as asm asm_fragment async attribute auto await 
+  become binding_array cast catch class co_await co_return co_yield coherent column_major 
+  common compile compile_fragment concept const_cast consteval constexpr constinit crate 
+  debugger decltype delete demote demote_to_helper do dynamic_cast 
+  enum explicit export extends extern external fallthrough filter final finally friend from fxgroup 
+  get goto groupshared highp impl implements import inline instanceof interface layout lowp 
+  macro macro_rules match mediump meta mod module move mut mutable 
+  namespace new nil noexcept noinline nointerpolation non_coherent noncoherent noperspective null nullptr 
+  of operator package packoffset partition pass patch pixelfragment precise precision premerge 
+  priv protected pub public readonly ref regardless register reinterpret_cast require resource restrict 
+  self set shared sizeof smooth snorm static static_assert static_cast std subroutine super 
+  target template this thread_local throw trait try type typedef typeid typename typeof 
+  union unless unorm unsafe unsized use using varying virtual volatile wgsl where with writeonly yield`.split(/\s+/);
+
+//#endregion
+//#region ../wesl/src/parse/WeslStream.ts
+/** Whitespaces including new lines */
+const blankspaces = /[ \t\n\v\f\r\u{0085}\u{200E}\u{200F}\u{2028}\u{2029}]+/u;
+const symbolSet = "& && -> @ / ! [ ] { } :: : , == = != >>= >> >= > <<= << <= < % - -- . + ++ | || ( ) ; * ~ ^ // /* */ += -= *= /= %= &= |= ^= _";
+const ident = /(?:(?:[_\p{XID_Start}][\p{XID_Continue}]+)|(?:[\p{XID_Start}]))/u;
+const keywordOrReserved = new Set(keywords.concat(reservedWords));
+const digits = new RegExp(/(?:0[fh])|(?:[1-9][0-9]*[fh])/.source + /|(?:[0-9]*\.[0-9]+(?:[eE][+-]?[0-9]+)?[fh]?)/.source + /|(?:[0-9]+\.[0-9]*(?:[eE][+-]?[0-9]+)?[fh]?)/.source + /|(?:[0-9]+[eE][+-]?[0-9]+[fh]?)/.source + /|(?:0[xX][0-9a-fA-F]*\.[0-9a-fA-F]+(?:[pP][+-]?[0-9]+[fh]?)?)/.source + /|(?:0[xX][0-9a-fA-F]+\.[0-9a-fA-F]*(?:[pP][+-]?[0-9]+[fh]?)?)/.source + /|(?:0[xX][0-9a-fA-F]+[pP][+-]?[0-9]+[fh]?)/.source + /|(?:0[xX][0-9a-fA-F]+[iu]?)/.source + /|(?:0[iu]?)|(?:[1-9][0-9]*[iu]?)/.source);
+const commentStart = /\/\/|\/\*/;
+const weslMatcher = new RegexMatchers({
+	word: ident,
+	number: digits,
+	blankspaces,
+	commentStart,
+	symbol: matchOneOf(symbolSet),
+	invalid: /[^]/
+});
+/** To mark parts of the grammar implementation that are WESL specific extensions */
+function weslExtension(combinator) {
+	return combinator;
+}
+/** A stream that produces WESL tokens, skipping over comments and white space */
+var WeslStream = class {
+	stream;
+	/** New line */
+	eolPattern = /[\n\v\f\u{0085}\u{2028}\u{2029}]|\r\n?/gu;
+	/** Block comments */
+	blockCommentPattern = /\/\*|\*\//g;
+	constructor(src) {
+		this.src = src;
+		this.stream = new CachingStream(new MatchersStream(src, weslMatcher));
+	}
+	checkpoint() {
+		return this.stream.checkpoint();
+	}
+	reset(position) {
+		this.stream.reset(position);
+	}
+	nextToken() {
+		while (true) {
+			const token$1 = this.stream.nextToken();
+			if (token$1 === null) return null;
+			const kind$1 = token$1.kind;
+			if (kind$1 === "blankspaces") continue;
+			else if (kind$1 === "commentStart") if (token$1.text === "//") this.stream.reset(this.skipToEol(token$1.span[1]));
+			else this.stream.reset(this.skipBlockComment(token$1.span[1]));
+			else if (kind$1 === "word") {
+				const returnToken = token$1;
+				if (keywordOrReserved.has(token$1.text)) returnToken.kind = "keyword";
+				return returnToken;
+			} else if (kind$1 === "invalid") throw new ParseError("Invalid token " + token$1.text, token$1.span);
+			else return token$1;
+		}
+	}
+	skipToEol(position) {
+		this.eolPattern.lastIndex = position;
+		const result = this.eolPattern.exec(this.src);
+		if (result === null) return this.src.length;
+		else return this.eolPattern.lastIndex;
+	}
+	skipBlockComment(start) {
+		let position = start;
+		while (true) {
+			this.blockCommentPattern.lastIndex = position;
+			const result = this.blockCommentPattern.exec(this.src);
+			if (result === null) throw new ParseError("Unclosed block comment!", [position, position]);
+			else if (result[0] === "*/") return this.blockCommentPattern.lastIndex;
+			else if (result[0] === "/*") position = this.skipBlockComment(this.blockCommentPattern.lastIndex);
+			else throw new Error("Unreachable, invalid block comment pattern");
+		}
+	}
+	/**
+	* Only matches the `<` token if it is a template
+	* Precondition: An ident was parsed right before this.
+	* Runs the [template list discovery algorithm](https://www.w3.org/TR/WGSL/#template-list-discovery).
+	*/
+	nextTemplateStartToken() {
+		const startPosition = this.stream.checkpoint();
+		const token$1 = this.nextToken();
+		this.stream.reset(startPosition);
+		if (token$1 === null) return null;
+		if (token$1.kind !== "symbol") return null;
+		if (token$1.text === "<") if (this.isTemplateStart(token$1.span[1])) {
+			this.stream.reset(token$1.span[1]);
+			return token$1;
+		} else {
+			this.stream.reset(startPosition);
+			return null;
+		}
+		else return null;
+	}
+	nextTemplateEndToken() {
+		const startPosition = this.stream.checkpoint();
+		const token$1 = this.nextToken();
+		this.stream.reset(startPosition);
+		if (token$1 === null) return null;
+		if (token$1.kind === "symbol" && token$1.text[0] === ">") {
+			const tokenPosition = token$1.span[0];
+			this.stream.reset(tokenPosition + 1);
+			return {
+				kind: "symbol",
+				span: [tokenPosition, tokenPosition + 1],
+				text: ">"
+			};
+		} else return null;
+	}
+	isTemplateStart(afterToken) {
+		this.stream.reset(afterToken);
+		let pendingCounter = 1;
+		while (true) {
+			const nextToken = this.stream.nextToken();
+			if (nextToken === null) return false;
+			if (nextToken.kind !== "symbol") continue;
+			if (nextToken.text === "<") pendingCounter += 1;
+			else if (nextToken.text[0] === ">") {
+				if (nextToken.text === ">" || nextToken.text === ">=") pendingCounter -= 1;
+				else if (nextToken.text === ">>=" || nextToken.text === ">>") pendingCounter -= 2;
+				else throw new Error("This case should never be reached, looks like we forgot one of the tokens that start with >");
+				if (pendingCounter <= 0) return true;
+			} else if (nextToken.text === "(") this.skipBracketsTo(")");
+			else if (nextToken.text === "[") this.skipBracketsTo("]");
+			else if (nextToken.text === "==" || nextToken.text === "!=" || nextToken.text === ";" || nextToken.text === "{" || nextToken.text === ":" || nextToken.text === "&&" || nextToken.text === "||") return false;
+		}
+	}
+	/**
+	* Call this after consuming an opening bracket.
+	* Skips until a closing bracket. This also consumes the closing bracket.
+	*/
+	skipBracketsTo(closingBracket) {
+		while (true) {
+			const nextToken = this.stream.nextToken();
+			if (nextToken === null) {
+				const after = this.stream.checkpoint();
+				throw new ParseError("Unclosed bracket!", [after, after]);
+			}
+			if (nextToken.kind !== "symbol") continue;
+			if (nextToken.text === "(") this.skipBracketsTo(")");
+			else if (nextToken.text === "[") this.skipBracketsTo("]");
+			else if (nextToken.text === closingBracket) return;
+		}
+	}
+};
+const templateOpen = withStreamAction((stream) => {
+	return stream.nextTemplateStartToken();
+});
+const templateClose = withStreamAction((stream) => {
+	return stream.nextTemplateEndToken();
+});
+
+//#endregion
+//#region ../wesl/src/parse/WeslExpression.ts
+const opt_template_list = opt(seq(templateOpen, withSepPlus(",", () => template_parameter), req(templateClose, "invalid template, expected '>'")));
+const other_address_space = or("private", "workgroup", "uniform", "function");
+const storage_address_space = seq("storage", opt(seq(",", or("read", "read_write"))));
+const var_template_list = opt(seq(templateOpen, or(storage_address_space, other_address_space), req(templateClose, "invalid template, expected '>'")));
+const template_elaborated_ident = seq(qualified_ident.collect(refIdent), opt_template_list);
+const literal = or("true", "false", number);
+const paren_expression = seq("(", () => expression, req(")", "invalid expression, expected ')'"));
+const primary_expression = or(literal, paren_expression, seq(template_elaborated_ident, opt(fn(() => argument_expression_list))));
+const component_or_swizzle = repeatPlus(or(preceded(".", word), collectArray(delimited("[", () => expression, req("]", "invalid expression, expected ']'")))));
+/** parse simple struct.member style references specially, for binding struct lowering */
+const simple_component_reference = tagScope(seq(qualified_ident.collect(refIdent, "structRef"), seq(".", word.collect(nameCollect, "component")), opt(component_or_swizzle.collect(stuffCollect, "extra_components"))).collect(memberRefCollect));
+const unary_expression = or(seq(tokenOf("symbol", [
+	"!",
+	"&",
+	"*",
+	"-",
+	"~"
+]), () => unary_expression), or(simple_component_reference, seq(primary_expression, opt(component_or_swizzle))));
+const bitwise_post_unary = or(repeatPlus(seq("&", unary_expression)), repeatPlus(seq("^", unary_expression)), repeatPlus(seq("|", unary_expression)));
+const multiplicative_operator = or("%", "*", "/");
+const additive_operator = or("+", "-");
+const shift_post_unary = (inTemplate) => {
+	const shift_left = seq("<<", unary_expression);
+	const shift_right = seq(">>", unary_expression);
+	const mul_add = seq(repeat(seq(multiplicative_operator, unary_expression)), repeat(seq(additive_operator, unary_expression, repeat(seq(multiplicative_operator, unary_expression)))));
+	return inTemplate ? or(shift_left, mul_add) : or(shift_left, shift_right, mul_add);
+};
+const relational_post_unary = (inTemplate) => {
+	return seq(shift_post_unary(inTemplate), opt(seq(inTemplate ? tokenOf("symbol", [
+		"<",
+		"<=",
+		"!=",
+		"=="
+	]) : tokenOf("symbol", [
+		">",
+		">=",
+		"<",
+		"<=",
+		"!=",
+		"=="
+	]), unary_expression, shift_post_unary(inTemplate))));
+};
+/** The expression parser exists in two variants
+* `true` is template-expression: Refuses to parse parse symbols like `&&` and `||`.
+* `false` is maybe-template-expression: Does the template disambiguation.
+*/
+const expressionParser = (inTemplate) => {
+	return seq(unary_expression, or(bitwise_post_unary, seq(relational_post_unary(inTemplate), inTemplate ? yes() : or(repeatPlus(seq("||", seq(unary_expression, relational_post_unary(false)))), repeatPlus(seq("&&", seq(unary_expression, relational_post_unary(false)))), yes().map(() => [])))));
+};
+const maybe_template = false;
+const expression = expressionParser(maybe_template);
+const is_template = true;
+const template_arg_expression = expressionParser(is_template);
+const std_type_specifier = seq(qualified_ident.collect(refIdent, "typeRefName"), () => opt_template_list).collect(typeRefCollect);
+const type_specifier = tagScope(std_type_specifier).ctag("typeRefElem");
+/** a template_arg_expression with additional collection for parameters
+* that are types like array<f32> vs. expressions like 1+2 */
+const template_parameter = or(type_specifier.ctag("templateParam"), template_arg_expression.collect(expressionCollect, "templateParam"));
+const argument_expression_list = seq("(", withSep(",", expression), req(")", "invalid fn arguments, expected ')'"));
+if (tracing) {
+	const names = {
+		opt_template_list,
+		other_address_space,
+		storage_address_space,
+		var_template_list,
+		template_elaborated_ident,
+		primary_expression,
+		literal,
+		paren_expression,
+		component_or_swizzle,
+		simple_component_reference,
+		unary_expression,
+		bitwise_post_unary,
+		multiplicative_operator,
+		additive_operator,
+		expression,
+		template_arg_expression,
+		std_type_specifier,
+		type_specifier,
+		template_parameter,
+		argument_expression_list
+	};
+	Object.entries(names).forEach(([name$1, parser]) => {
+		parser.setTraceName(name$1);
+	});
+}
+
+//#endregion
+//#region ../wesl/src/parse/WeslGrammar.ts
+const name = tokenKind("word").map(makeName);
+const diagnostic_rule_name = seq(name, opt(preceded(".", req(name, "invalid diagnostic rule name, expected name"))));
+const diagnostic_control = delimited("(", req(separated_pair(name, ",", diagnostic_rule_name), "invalid diagnostic control, expected rule name"), seq(opt(","), req(")", "invalid diagnostic control, expected ')'")));
+/** list of words that aren't identifiers (e.g. for @interpolate) */
+const name_list = withSep(",", name, { requireOne: true });
+const special_attribute = tagScope(preceded("@", or(or("compute", "const", "fragment", "invariant", "must_use", "vertex").map((name$1) => makeStandardAttribute([name$1, []])), preceded("interpolate", req(delimited("(", name_list, ")"), "invalid @interpolate, expected '('")).map(makeInterpolateAttribute), preceded("builtin", req(delimited("(", name, ")"), "invalid @builtin, expected '('")).map(makeBuiltinAttribute), preceded("diagnostic", req(diagnostic_control, "invalid @diagnostic, expected '('")).map(makeDiagnosticAttribute)).ptag("attr_variant")).collect(specialAttribute));
+const if_attribute = tagScope(preceded(seq("@", weslExtension("if")), span(delimited("(", fn(() => attribute_if_expression), seq(opt(","), ")"))).map(makeTranslateTimeExpressionElem)).map(makeIfAttribute).ptag("attr_variant").collect(specialAttribute));
+const normal_attribute = tagScope(preceded("@", or(seq(or("workgroup_size", "align", "binding", "blend_src", "group", "id", "location", "size").ptag("name"), req(() => attribute_argument_list, "invalid attribute, expected '('")), seq(word.ptag("name"), opt(() => attribute_argument_list)))).collect(collectAttribute));
+const attribute_argument_list = delimited("(", withSep(",", span(fn(() => expression)).collect(expressionCollect, "attrParam")), req(")", "invalid attribute arguments, expected ')'"));
+const attribute_no_if = or(special_attribute, normal_attribute).ctag("attribute");
+const attribute_incl_if = or(if_attribute, special_attribute, normal_attribute).ctag("attribute");
+const opt_attributes = repeat(attribute_incl_if);
+const opt_attributes_no_if = repeat(attribute_no_if);
+const globalTypeNameDecl = req(word.collect(globalDeclCollect, "type_name"), "invalid type name, expected a name");
+const fnNameDecl = req(word.collect(globalDeclCollect, "fn_name"), "missing fn name");
+const optionally_typed_ident = tagScope(seq(word.collect(declCollect, "decl_elem"), opt(seq(":", type_specifier))).collect(typedDecl)).ctag("var_name");
+const req_optionally_typed_ident = req(optionally_typed_ident, "invalid ident");
+const global_ident = tagScope(req(seq(word.collect(globalDeclCollect, "decl_elem"), opt(seq(":", type_specifier.collect(scopeCollect, "decl_type")))).collect(typedDecl), "expected identifier")).ctag("var_name");
+const struct_member = tagScope(seq(opt_attributes, word.collect(nameCollect, "nameElem"), req(":", "invalid struct member, expected ':'"), req(type_specifier, "invalid struct member, expected type specifier")).collect(collectStructMember)).ctag("members");
+const struct_decl = seq(weslExtension(opt_attributes).collect((cc) => cc.tags.attribute, "attributes"), "struct", req(globalTypeNameDecl, "invalid struct, expected name"), seq(req("{", "invalid struct, expected '{'"), withSepPlus(",", struct_member), req("}", "invalid struct, expected '}'")).collect(scopeCollect, "struct_scope")).collect(collectStruct);
+/** Also covers func_call_statement.post.ident */
+const fn_call = seq(qualified_ident.collect(refIdent), () => opt_template_list, argument_expression_list);
+const fnParam = tagScope(seq(opt_attributes.collect((cc) => cc.tags.attribute, "attributes"), word.collect(declCollect, "decl_elem"), opt(seq(":", req(type_specifier, "invalid fn parameter, expected type specifier"))).collect(typedDecl, "param_name")).collect(collectFnParam)).ctag("fn_param");
+const fnParamList = seq("(", withSep(",", fnParam), ")");
+const local_variable_decl = seq("var", () => var_template_list, req_optionally_typed_ident, opt(seq("=", () => expression))).collect(collectVarLike("var"));
+const global_variable_decl = seq(opt_attributes, "var", () => var_template_list, global_ident, opt(seq("=", () => expression.collect(scopeCollect, "decl_scope"))), ";").collect(collectVarLike("gvar")).collect(partialScopeCollect);
+const attribute_if_primary_expression = or(tokenOf("keyword", ["true", "false"]).map(makeLiteral), delimited(token("symbol", "("), fn(() => attribute_if_expression), token("symbol", ")")).map(makeParenthesizedExpression), tokenKind("word").map(makeTranslateTimeFeature));
+const attribute_if_unary_expression = or(seq(token("symbol", "!").map(makeUnaryOperator), fn(() => attribute_if_unary_expression)).map(makeUnaryExpression), attribute_if_primary_expression);
+const attribute_if_expression = weslExtension(seq(attribute_if_unary_expression, or(repeatPlus(seq(token("symbol", "||").map(makeBinaryOperator), req(attribute_if_unary_expression, "invalid expression, expected expression"))), repeatPlus(seq(token("symbol", "&&").map(makeBinaryOperator), req(attribute_if_unary_expression, "invalid expression, expected expression"))), yes().map(() => []))).map(makeRepeatingBinaryExpression));
+const unscoped_compound_statement = seq(opt_attributes, text("{"), repeat(() => statement), req("}", "invalid block, expected }")).collect(statementCollect);
+const compound_statement = tagScope(seq(opt_attributes, seq(text("{"), repeat(() => statement), req("}", "invalid block, expected '}'")).collect(scopeCollect)).collect(statementCollect));
+const for_init = seq(opt_attributes, or(fn_call, () => variable_or_value_statement, () => variable_updating_statement));
+const for_update = seq(opt_attributes, or(fn_call, () => variable_updating_statement));
+const for_statement = seq("for", seq(req("(", "invalid for loop, expected '('"), opt(for_init), req(";", "invalid for loop, expected ';'"), opt(expression), req(";", "invalid for loop, expected ';'"), opt(for_update), req(")", "invalid for loop, expected ')'"), unscoped_compound_statement).collect(scopeCollect));
+const if_statement = seq("if", req(seq(expression, compound_statement), "invalid if statement"), repeat(seq("else", "if", req(seq(expression, compound_statement), "invalid else if branch"))), opt(seq("else", req(compound_statement, "invalid else branch, expected '{'"))));
+const loop_statement = seq("loop", opt_attributes_no_if, req(seq("{", repeat(() => statement), opt(tagScope(seq(opt_attributes, "continuing", opt_attributes_no_if, "{", repeat(() => statement), tagScope(opt(seq(opt_attributes, seq("break", "if", expression, ";")).collect(statementCollect))), "}").collect(statementCollect).collect(scopeCollect))), "}"), "invalid loop statement")).collect(scopeCollect);
+const case_selector = or("default", expression);
+const switch_clause = tagScope(seq(opt_attributes, or(seq("case", withSep(",", case_selector, { requireOne: true }), opt(":"), compound_statement), seq("default", opt(":"), compound_statement)).collect(switchClauseCollect)));
+const switch_body = seq(opt_attributes, "{", repeatPlus(switch_clause), "}");
+const switch_statement = seq("switch", expression, switch_body);
+const while_statement = seq("while", expression, compound_statement);
+const regular_statement = or(for_statement, if_statement, loop_statement, switch_statement, while_statement, seq("break", ";"), seq("continue", req(";", "invalid statement, expected ';'")), seq(";"), () => const_assert, seq("discard", req(";", "invalid statement, expected ';'")), seq("return", opt(expression), req(";", "invalid statement, expected ';'")), seq(fn_call, req(";", "invalid statement, expected ';'")), seq(() => variable_or_value_statement, req(";", "invalid statement, expected ';'")), seq(() => variable_updating_statement, req(";", "invalid statement, expected ';'")));
+const conditional_statement = tagScope(seq(opt_attributes, regular_statement).collect(statementCollect).collect(partialScopeCollect));
+const unconditional_statement = tagScope(seq(opt_attributes_no_if, regular_statement));
+const statement = or(compound_statement, unconditional_statement, conditional_statement);
+const lhs_expression = or(simple_component_reference, seq(qualified_ident.collect(refIdent), opt(component_or_swizzle)), seq("(", () => lhs_expression, ")", opt(component_or_swizzle)), seq("&", () => lhs_expression), seq("*", () => lhs_expression));
+const variable_or_value_statement = tagScope(or(local_variable_decl, seq("const", req_optionally_typed_ident, req("=", "invalid const declaration, expected '='"), expression), seq("let", req_optionally_typed_ident, req("=", "invalid let declaration, expected '='"), expression)));
+const variable_updating_statement = or(seq(lhs_expression, or("=", "<<=", ">>=", "%=", "&=", "*=", "+=", "-=", "/=", "^=", "|="), expression), seq(lhs_expression, or("++", "--")), seq("_", "=", expression));
+const fn_decl = seq(tagScope(opt_attributes.collect((cc) => cc.tags.attribute || [])).ctag("fn_attributes"), text("fn"), req(fnNameDecl, "invalid fn, expected function name"), seq(req(fnParamList, "invalid fn, expected function parameters").collect(scopeCollect, "header_scope"), opt(seq("->", opt_attributes.collect((cc) => cc.tags.attribute, "return_attributes"), type_specifier.ctag("return_type").collect(scopeCollect, "return_scope"))), req(unscoped_compound_statement, "invalid fn, expected function body").ctag("body_statement").collect(scopeCollect, "body_scope"))).collect(partialScopeCollect, "fn_partial_scope").collect(fnCollect);
+const global_value_decl = or(seq(opt_attributes, "override", global_ident, seq(opt(seq("=", expression.collect(scopeCollectNoIf, "decl_scope")))), ";").collect(collectVarLike("override")), seq(opt_attributes, "const", global_ident, "=", seq(expression).collect(scopeCollectNoIf, "decl_scope"), ";").collect(collectVarLike("const"))).collect(partialScopeCollect);
+const global_alias = seq(weslExtension(opt_attributes).collect((cc) => cc.tags.attribute, "attributes"), "alias", req(word, "invalid alias, expected name").collect(globalDeclCollect, "alias_name"), req("=", "invalid alias, expected '='"), req(type_specifier, "invalid alias, expected type").collect(scopeCollect, "alias_scope"), req(";", "invalid alias, expected ';'")).collect(aliasCollect);
+const const_assert = tagScope(seq(opt_attributes, "const_assert", req(expression, "invalid const_assert, expected expression"), req(";", "invalid statement, expected ';'")).collect(assertCollect)).ctag("const_assert");
+const global_directive = tagScope(seq(opt_attributes, terminated(or(preceded("diagnostic", diagnostic_control).map(makeDiagnosticDirective), preceded("enable", name_list).map(makeEnableDirective), preceded("requires", name_list).map(makeRequiresDirective)).ptag("directive"), ";")).collect(directiveCollect));
+const global_decl = tagScope(or(fn_decl, global_variable_decl, global_value_decl, ";", global_alias, const_assert.collect(globalAssertCollect), struct_decl));
+const weslRoot = seq(weslExtension(weslImports), repeat(global_directive), repeat(global_decl), req(eof(), "invalid WESL, expected EOF")).collect(collectModule, "collectModule");
+function makeDiagnosticDirective([severity, rule]) {
+	return {
+		kind: "diagnostic",
+		severity,
+		rule
+	};
+}
+function makeEnableDirective(extensions) {
+	return {
+		kind: "enable",
+		extensions
+	};
+}
+function makeRequiresDirective(extensions) {
+	return {
+		kind: "requires",
+		extensions
+	};
+}
+function makeStandardAttribute([name$1, params]) {
+	return {
+		kind: "@attribute",
+		name: name$1,
+		params
+	};
+}
+function makeInterpolateAttribute(params) {
+	return {
+		kind: "@interpolate",
+		params
+	};
+}
+function makeBuiltinAttribute(param) {
+	return {
+		kind: "@builtin",
+		param
+	};
+}
+function makeDiagnosticAttribute([severity, rule]) {
+	return {
+		kind: "@diagnostic",
+		severity,
+		rule
+	};
+}
+function makeIfAttribute(param) {
+	return {
+		kind: "@if",
+		param
+	};
+}
+function makeTranslateTimeExpressionElem(args) {
+	return {
+		kind: "translate-time-expression",
+		expression: args.value,
+		span: args.span
+	};
+}
+function makeName(token$1) {
+	return {
+		kind: "name",
+		name: token$1.text,
+		start: token$1.span[0],
+		end: token$1.span[1]
+	};
+}
+function makeLiteral(token$1) {
+	return {
+		kind: "literal",
+		value: token$1.text,
+		span: token$1.span
+	};
+}
+function makeTranslateTimeFeature(token$1) {
+	return {
+		kind: "translate-time-feature",
+		name: token$1.text,
+		span: token$1.span
+	};
+}
+function makeParenthesizedExpression(expression$1) {
+	return {
+		kind: "parenthesized-expression",
+		expression: expression$1
+	};
+}
+function makeUnaryOperator(token$1) {
+	return {
+		value: token$1.text,
+		span: token$1.span
+	};
+}
+function makeBinaryOperator(token$1) {
+	return {
+		value: token$1.text,
+		span: token$1.span
+	};
+}
+function makeUnaryExpression([operator, expression$1]) {
+	return {
+		kind: "unary-expression",
+		operator,
+		expression: expression$1
+	};
+}
+/** A list of left-to-right associative binary expressions */
+function makeRepeatingBinaryExpression([start, repeating]) {
+	let result = start;
+	for (const [op, left] of repeating) result = makeBinaryExpression([
+		result,
+		op,
+		left
+	]);
+	return result;
+}
+function makeBinaryExpression([left, operator, right]) {
+	return {
+		kind: "binary-expression",
+		operator,
+		left,
+		right
+	};
+}
+if (tracing) {
+	const names = {
+		name,
+		diagnostic_rule_name,
+		diagnostic_control,
+		name_list,
+		special_attribute,
+		if_attribute,
+		normal_attribute,
+		attribute_argument_list,
+		attribute_no_if,
+		attribute_incl_if,
+		opt_attributes,
+		opt_attributes_no_if,
+		globalTypeNameDecl,
+		fnNameDecl,
+		optionally_typed_ident,
+		req_optionally_typed_ident,
+		global_ident,
+		struct_member,
+		struct_decl,
+		fn_call,
+		fnParam,
+		fnParamList,
+		local_variable_decl,
+		global_variable_decl,
+		attribute_if_primary_expression,
+		attribute_if_unary_expression,
+		attribute_if_expression,
+		unscoped_compound_statement,
+		compound_statement,
+		for_init,
+		for_update,
+		for_statement,
+		if_statement,
+		loop_statement,
+		case_selector,
+		switch_clause,
+		switch_body,
+		switch_statement,
+		while_statement,
+		regular_statement,
+		conditional_statement,
+		statement,
+		lhs_expression,
+		variable_or_value_statement,
+		variable_updating_statement,
+		fn_decl,
+		global_value_decl,
+		global_alias,
+		const_assert,
+		global_directive,
+		global_decl,
+		weslRoot,
+		qualified_ident,
+		word
+	};
+	Object.entries(names).forEach(([name$1, parser]) => {
+		parser.setTraceName(name$1);
+	});
+}
+
+//#endregion
+//#region ../wesl/src/ParseWESL.ts
+/**
+* An error when parsing WESL fails. Designed to be human-readable.
+*/
+var WeslParseError = class extends Error {
+	span;
+	src;
+	constructor(opts) {
+		const source = opts.src.src;
+		const [lineNum, linePos] = offsetToLineNumber(opts.cause.span[0], source);
+		let message = `${opts.src.debugFilePath}:${lineNum}:${linePos}`;
+		message += ` error: ${opts.cause.message}\n`;
+		message += errorHighlight(source, opts.cause.span).join("\n");
+		super(message, { cause: opts.cause });
+		this.span = opts.cause.span;
+		this.src = opts.src;
+	}
+};
+/** Parse a WESL file. Throws on error. */
+function parseSrcModule(srcModule) {
+	const stream = new WeslStream(srcModule.src);
+	const appState = blankWeslParseState(srcModule);
+	const init = {
+		stream,
+		appState
+	};
+	try {
+		const parseResult = weslRoot.parse(init);
+		if (parseResult === null) throw new Error("parseWESL failed");
+	} catch (e) {
+		if (e instanceof ParseError) {
+			const [lineNumber, lineColumn] = offsetToLineNumber(e.span[0], srcModule.src);
+			const error = new WeslParseError({
+				cause: e,
+				src: srcModule
+			});
+			throwClickableError({
+				url: srcModule.debugFilePath,
+				text: srcModule.src,
+				error,
+				lineNumber,
+				lineColumn,
+				length: e.span[1] - e.span[0]
+			});
+		} else throw e;
+	}
+	return appState.stable;
+}
+function blankWeslParseState(srcModule) {
+	const rootScope = emptyScope(null);
+	const moduleElem = null;
+	return {
+		context: {
+			scope: rootScope,
+			openElems: []
+		},
+		stable: {
+			srcModule,
+			imports: [],
+			rootScope,
+			moduleElem
+		}
+	};
+}
+
+//#endregion
+//#region ../wesl/src/PathUtil.ts
+/** simplistic path manipulation utilities */
+/** return path with ./ and foo/.. elements removed */
+function normalize(path$1) {
+	const segments = path$1.split("/");
+	const noDots = segments.filter((s) => s !== ".");
+	const noDbl = [];
+	noDots.forEach((s) => {
+		if (s !== "") if (s === ".." && noDbl.length && noDbl[noDbl.length - 1] !== "..") noDbl.pop();
+		else noDbl.push(s);
+	});
+	return noDbl.join("/");
+}
+/** return path w/o a suffix.
+* e.g. /foo/bar.wgsl => /foo/bar */
+function noSuffix(path$1) {
+	const lastSlash = path$1.lastIndexOf("/");
+	const lastStart = lastSlash === -1 ? 0 : lastSlash + 1;
+	const suffix = path$1.indexOf(".", lastStart);
+	const suffixStart = suffix === -1 ? path$1.length : suffix;
+	return path$1.slice(0, suffixStart);
+}
+
+//#endregion
+//#region ../wesl/src/ParsedRegistry.ts
+function parsedRegistry() {
+	resetScopeIds();
+	return { modules: {} };
+}
+/**
+* @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
+*/
+function parseIntoRegistry(srcFiles, registry, packageName = "package", debugWeslRoot) {
+	let weslRoot$1 = debugWeslRoot;
+	if (weslRoot$1 === void 0) weslRoot$1 = "";
+	else if (!weslRoot$1.endsWith("/")) weslRoot$1 += "/";
+	const srcModules = Object.entries(srcFiles).map(([filePath, src]) => {
+		const modulePath = fileToModulePath(filePath, packageName);
+		return {
+			modulePath,
+			debugFilePath: weslRoot$1 + filePath,
+			src
+		};
+	});
+	srcModules.forEach((mod) => {
+		const parsed = parseSrcModule(mod);
+		if (registry.modules[mod.modulePath]) throw new Error(`duplicate module path: '${mod.modulePath}'`);
+		registry.modules[mod.modulePath] = parsed;
+	});
+}
+const libRegex = /^lib\.w[eg]sl$/i;
+/** convert a file path (./foo/bar.wesl)
+*  to a module path (package::foo::bar) */
+function fileToModulePath(filePath, packageName) {
+	if (filePath.includes("::")) return filePath;
+	if (packageName !== "package" && libRegex.test(filePath)) return packageName;
+	const strippedPath = noSuffix(normalize(filePath));
+	const moduleSuffix = strippedPath.replaceAll("/", "::");
+	const modulePath = packageName + "::" + moduleSuffix;
+	return modulePath;
+}
+
+//#endregion
+//#region src/cli.ts
+async function cli(rawArgs$1) {
+	enableTracing();
+	const argv = await parseArgs(rawArgs$1);
+	await linkNormally(argv);
+}
+async function parseArgs(args) {
+	const toolDir = path.join(import.meta.url, "..");
+	const appVersion = await versionFromPackageJson(toolDir);
+	return yargs(args).version(appVersion).option("src", {
+		type: "string",
+		default: "./shaders/*.w[eg]sl",
+		describe: "WGSL/WESL files to bundle in the package (glob syntax)"
+	}).option("rootModule", {
+		type: "string",
+		default: "main",
+		describe: "start linking from this module name"
+	}).option("define", {
+		type: "array",
+		describe: "definitions for preprocessor and linking"
+	}).option("baseDir", {
+		requiresArg: true,
+		type: "string",
+		default: "./shaders",
+		describe: "root directory for shaders"
+	}).option("projectDir", {
+		requiresArg: true,
+		type: "string",
+		default: ".",
+		describe: "directory containing package.json"
+	}).option("details", {
+		type: "boolean",
+		default: false,
+		hidden: true,
+		describe: "show details about parsed files"
+	}).option("emit", {
+		type: "boolean",
+		default: true,
+		hidden: true,
+		describe: "emit linked result"
+	}).help().parse();
+}
+async function linkNormally(argv) {
+	const weslRoot$1 = argv.baseDir || process.cwd();
+	const weslSrc = await loadModules(argv.projectDir, weslRoot$1, argv.src);
+	if (argv.emit) {
+		const linked = await link({
+			weslSrc,
+			rootModuleName: argv.rootModule
+		});
+		log(linked.dest);
+	}
+	if (argv.details) {
+		const registry = parsedRegistry();
+		try {
+			parseIntoRegistry(weslSrc, registry, "package");
+		} catch (e) {
+			console.error(e);
+		}
+		Object.entries(registry.modules).forEach(([modulePath, ast]) => {
+			log(`---\n${modulePath}`);
+			log(`\n->ast`);
+			log(astToString(ast.moduleElem));
+			log(`\n->scope`);
+			log(scopeToString(ast.rootScope));
+			log();
+		});
+	}
+}
+
+//#endregion
+//#region src/main.ts
+const rawArgs = hideBin(process.argv);
+cli(rawArgs);
+
+//#endregion