wesl-link 0.6.1 → 0.6.6

package/bin/wesl-link

@@ -1634,223 +1634,258 @@ var esm_default = {
   })
 };
 
-// ../../node_modules/.pnpm/diff@7.0.0/node_modules/diff/lib/index.mjs
-function Diff() {
-}
-Diff.prototype = {
-  diff: function diff(oldString, newString) {
-    var _options$timeout;
-    var options = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : {};
-    var callback = options.callback;
-    if (typeof options === "function") {
-      callback = options;
-      options = {};
-    }
-    var self = this;
-    function done(value) {
-      value = self.postProcess(value, options);
-      if (callback) {
-        setTimeout(function() {
-          callback(value);
-        }, 0);
-        return true;
-      } else {
-        return value;
-      }
-    }
-    oldString = this.castInput(oldString, options);
-    newString = this.castInput(newString, options);
-    oldString = this.removeEmpty(this.tokenize(oldString, options));
-    newString = this.removeEmpty(this.tokenize(newString, options));
-    var newLen = newString.length, oldLen = oldString.length;
-    var editLength = 1;
-    var maxEditLength = newLen + oldLen;
-    if (options.maxEditLength != null) {
-      maxEditLength = Math.min(maxEditLength, options.maxEditLength);
-    }
-    var maxExecutionTime = (_options$timeout = options.timeout) !== null && _options$timeout !== void 0 ? _options$timeout : Infinity;
-    var abortAfterTimestamp = Date.now() + maxExecutionTime;
-    var bestPath = [{
-      oldPos: -1,
-      lastComponent: void 0
-    }];
-    var newPos = this.extractCommon(bestPath[0], newString, oldString, 0, options);
-    if (bestPath[0].oldPos + 1 >= oldLen && newPos + 1 >= newLen) {
-      return done(buildValues(self, bestPath[0].lastComponent, newString, oldString, self.useLongestToken));
-    }
-    var minDiagonalToConsider = -Infinity, maxDiagonalToConsider = Infinity;
-    function execEditLength() {
-      for (var diagonalPath = Math.max(minDiagonalToConsider, -editLength); diagonalPath <= Math.min(maxDiagonalToConsider, editLength); diagonalPath += 2) {
-        var basePath = void 0;
-        var removePath = bestPath[diagonalPath - 1], addPath = bestPath[diagonalPath + 1];
-        if (removePath) {
-          bestPath[diagonalPath - 1] = void 0;
-        }
-        var canAdd = false;
-        if (addPath) {
-          var addPathNewPos = addPath.oldPos - diagonalPath;
-          canAdd = addPath && 0 <= addPathNewPos && addPathNewPos < newLen;
-        }
-        var canRemove = removePath && removePath.oldPos + 1 < oldLen;
-        if (!canAdd && !canRemove) {
-          bestPath[diagonalPath] = void 0;
-          continue;
-        }
-        if (!canRemove || canAdd && removePath.oldPos < addPath.oldPos) {
-          basePath = self.addToPath(addPath, true, false, 0, options);
+// src/cli.ts
+import fs from "node:fs";
+import path from "node:path";
+
+// ../../node_modules/.pnpm/diff@8.0.1/node_modules/diff/libesm/diff/base.js
+var Diff = (
+  /** @class */
+  function() {
+    function Diff2() {
+    }
+    Diff2.prototype.diff = function(oldStr, newStr, options) {
+      if (options === void 0) {
+        options = {};
+      }
+      var callback;
+      if (typeof options === "function") {
+        callback = options;
+        options = {};
+      } else if ("callback" in options) {
+        callback = options.callback;
+      }
+      var oldString = this.castInput(oldStr, options);
+      var newString = this.castInput(newStr, options);
+      var oldTokens = this.removeEmpty(this.tokenize(oldString, options));
+      var newTokens = this.removeEmpty(this.tokenize(newString, options));
+      return this.diffWithOptionsObj(oldTokens, newTokens, options, callback);
+    };
+    Diff2.prototype.diffWithOptionsObj = function(oldTokens, newTokens, options, callback) {
+      var _this = this;
+      var _a2;
+      var done = function(value) {
+        value = _this.postProcess(value, options);
+        if (callback) {
+          setTimeout(function() {
+            callback(value);
+          }, 0);
+          return void 0;
         } else {
-          basePath = self.addToPath(removePath, false, true, 1, options);
+          return value;
         }
-        newPos = self.extractCommon(basePath, newString, oldString, diagonalPath, options);
-        if (basePath.oldPos + 1 >= oldLen && newPos + 1 >= newLen) {
-          return done(buildValues(self, basePath.lastComponent, newString, oldString, self.useLongestToken));
-        } else {
-          bestPath[diagonalPath] = basePath;
-          if (basePath.oldPos + 1 >= oldLen) {
-            maxDiagonalToConsider = Math.min(maxDiagonalToConsider, diagonalPath - 1);
+      };
+      var newLen = newTokens.length, oldLen = oldTokens.length;
+      var editLength = 1;
+      var maxEditLength = newLen + oldLen;
+      if (options.maxEditLength != null) {
+        maxEditLength = Math.min(maxEditLength, options.maxEditLength);
+      }
+      var maxExecutionTime = (_a2 = options.timeout) !== null && _a2 !== void 0 ? _a2 : Infinity;
+      var abortAfterTimestamp = Date.now() + maxExecutionTime;
+      var bestPath = [{ oldPos: -1, lastComponent: void 0 }];
+      var newPos = this.extractCommon(bestPath[0], newTokens, oldTokens, 0, options);
+      if (bestPath[0].oldPos + 1 >= oldLen && newPos + 1 >= newLen) {
+        return done(this.buildValues(bestPath[0].lastComponent, newTokens, oldTokens));
+      }
+      var minDiagonalToConsider = -Infinity, maxDiagonalToConsider = Infinity;
+      var execEditLength = function() {
+        for (var diagonalPath = Math.max(minDiagonalToConsider, -editLength); diagonalPath <= Math.min(maxDiagonalToConsider, editLength); diagonalPath += 2) {
+          var basePath = void 0;
+          var removePath = bestPath[diagonalPath - 1], addPath = bestPath[diagonalPath + 1];
+          if (removePath) {
+            bestPath[diagonalPath - 1] = void 0;
           }
-          if (newPos + 1 >= newLen) {
-            minDiagonalToConsider = Math.max(minDiagonalToConsider, diagonalPath + 1);
+          var canAdd = false;
+          if (addPath) {
+            var addPathNewPos = addPath.oldPos - diagonalPath;
+            canAdd = addPath && 0 <= addPathNewPos && addPathNewPos < newLen;
           }
-        }
-      }
-      editLength++;
-    }
-    if (callback) {
-      (function exec() {
-        setTimeout(function() {
-          if (editLength > maxEditLength || Date.now() > abortAfterTimestamp) {
-            return callback();
+          var canRemove = removePath && removePath.oldPos + 1 < oldLen;
+          if (!canAdd && !canRemove) {
+            bestPath[diagonalPath] = void 0;
+            continue;
           }
-          if (!execEditLength()) {
-            exec();
+          if (!canRemove || canAdd && removePath.oldPos < addPath.oldPos) {
+            basePath = _this.addToPath(addPath, true, false, 0, options);
+          } else {
+            basePath = _this.addToPath(removePath, false, true, 1, options);
+          }
+          newPos = _this.extractCommon(basePath, newTokens, oldTokens, diagonalPath, options);
+          if (basePath.oldPos + 1 >= oldLen && newPos + 1 >= newLen) {
+            return done(_this.buildValues(basePath.lastComponent, newTokens, oldTokens)) || true;
+          } else {
+            bestPath[diagonalPath] = basePath;
+            if (basePath.oldPos + 1 >= oldLen) {
+              maxDiagonalToConsider = Math.min(maxDiagonalToConsider, diagonalPath - 1);
+            }
+            if (newPos + 1 >= newLen) {
+              minDiagonalToConsider = Math.max(minDiagonalToConsider, diagonalPath + 1);
+            }
           }
-        }, 0);
-      })();
-    } else {
-      while (editLength <= maxEditLength && Date.now() <= abortAfterTimestamp) {
-        var ret = execEditLength();
-        if (ret) {
-          return ret;
-        }
-      }
-    }
-  },
-  addToPath: function addToPath(path2, added, removed, oldPosInc, options) {
-    var last3 = path2.lastComponent;
-    if (last3 && !options.oneChangePerToken && last3.added === added && last3.removed === removed) {
-      return {
-        oldPos: path2.oldPos + oldPosInc,
-        lastComponent: {
-          count: last3.count + 1,
-          added,
-          removed,
-          previousComponent: last3.previousComponent
         }
+        editLength++;
       };
-    } else {
-      return {
-        oldPos: path2.oldPos + oldPosInc,
-        lastComponent: {
-          count: 1,
-          added,
-          removed,
-          previousComponent: last3
+      if (callback) {
+        (function exec() {
+          setTimeout(function() {
+            if (editLength > maxEditLength || Date.now() > abortAfterTimestamp) {
+              return callback(void 0);
+            }
+            if (!execEditLength()) {
+              exec();
+            }
+          }, 0);
+        })();
+      } else {
+        while (editLength <= maxEditLength && Date.now() <= abortAfterTimestamp) {
+          var ret = execEditLength();
+          if (ret) {
+            return ret;
+          }
         }
-      };
-    }
-  },
-  extractCommon: function extractCommon(basePath, newString, oldString, diagonalPath, options) {
-    var newLen = newString.length, oldLen = oldString.length, oldPos = basePath.oldPos, newPos = oldPos - diagonalPath, commonCount = 0;
-    while (newPos + 1 < newLen && oldPos + 1 < oldLen && this.equals(oldString[oldPos + 1], newString[newPos + 1], options)) {
-      newPos++;
-      oldPos++;
-      commonCount++;
-      if (options.oneChangePerToken) {
-        basePath.lastComponent = {
-          count: 1,
-          previousComponent: basePath.lastComponent,
-          added: false,
-          removed: false
+      }
+    };
+    Diff2.prototype.addToPath = function(path2, added, removed, oldPosInc, options) {
+      var last3 = path2.lastComponent;
+      if (last3 && !options.oneChangePerToken && last3.added === added && last3.removed === removed) {
+        return {
+          oldPos: path2.oldPos + oldPosInc,
+          lastComponent: { count: last3.count + 1, added, removed, previousComponent: last3.previousComponent }
+        };
+      } else {
+        return {
+          oldPos: path2.oldPos + oldPosInc,
+          lastComponent: { count: 1, added, removed, previousComponent: last3 }
         };
       }
-    }
-    if (commonCount && !options.oneChangePerToken) {
-      basePath.lastComponent = {
-        count: commonCount,
-        previousComponent: basePath.lastComponent,
-        added: false,
-        removed: false
-      };
-    }
-    basePath.oldPos = oldPos;
-    return newPos;
-  },
-  equals: function equals(left2, right2, options) {
-    if (options.comparator) {
-      return options.comparator(left2, right2);
-    } else {
-      return left2 === right2 || options.ignoreCase && left2.toLowerCase() === right2.toLowerCase();
-    }
-  },
-  removeEmpty: function removeEmpty(array) {
-    var ret = [];
-    for (var i = 0; i < array.length; i++) {
-      if (array[i]) {
-        ret.push(array[i]);
+    };
+    Diff2.prototype.extractCommon = function(basePath, newTokens, oldTokens, diagonalPath, options) {
+      var newLen = newTokens.length, oldLen = oldTokens.length;
+      var oldPos = basePath.oldPos, newPos = oldPos - diagonalPath, commonCount = 0;
+      while (newPos + 1 < newLen && oldPos + 1 < oldLen && this.equals(oldTokens[oldPos + 1], newTokens[newPos + 1], options)) {
+        newPos++;
+        oldPos++;
+        commonCount++;
+        if (options.oneChangePerToken) {
+          basePath.lastComponent = { count: 1, previousComponent: basePath.lastComponent, added: false, removed: false };
+        }
       }
-    }
-    return ret;
-  },
-  castInput: function castInput(value) {
-    return value;
-  },
-  tokenize: function tokenize(value) {
-    return Array.from(value);
-  },
-  join: function join(chars) {
-    return chars.join("");
-  },
-  postProcess: function postProcess(changeObjects) {
-    return changeObjects;
-  }
-};
-function buildValues(diff2, lastComponent, newString, oldString, useLongestToken) {
-  var components = [];
-  var nextComponent;
-  while (lastComponent) {
-    components.push(lastComponent);
-    nextComponent = lastComponent.previousComponent;
-    delete lastComponent.previousComponent;
-    lastComponent = nextComponent;
-  }
-  components.reverse();
-  var componentPos = 0, componentLen = components.length, newPos = 0, oldPos = 0;
-  for (; componentPos < componentLen; componentPos++) {
-    var component = components[componentPos];
-    if (!component.removed) {
-      if (!component.added && useLongestToken) {
-        var value = newString.slice(newPos, newPos + component.count);
-        value = value.map(function(value2, i) {
-          var oldValue = oldString[oldPos + i];
-          return oldValue.length > value2.length ? oldValue : value2;
-        });
-        component.value = diff2.join(value);
+      if (commonCount && !options.oneChangePerToken) {
+        basePath.lastComponent = { count: commonCount, previousComponent: basePath.lastComponent, added: false, removed: false };
+      }
+      basePath.oldPos = oldPos;
+      return newPos;
+    };
+    Diff2.prototype.equals = function(left2, right2, options) {
+      if (options.comparator) {
+        return options.comparator(left2, right2);
       } else {
-        component.value = diff2.join(newString.slice(newPos, newPos + component.count));
+        return left2 === right2 || !!options.ignoreCase && left2.toLowerCase() === right2.toLowerCase();
       }
-      newPos += component.count;
-      if (!component.added) {
-        oldPos += component.count;
+    };
+    Diff2.prototype.removeEmpty = function(array) {
+      var ret = [];
+      for (var i = 0; i < array.length; i++) {
+        if (array[i]) {
+          ret.push(array[i]);
+        }
       }
-    } else {
-      component.value = diff2.join(oldString.slice(oldPos, oldPos + component.count));
-      oldPos += component.count;
-    }
-  }
-  return components;
-}
-var characterDiff = new Diff();
+      return ret;
+    };
+    Diff2.prototype.castInput = function(value, options) {
+      return value;
+    };
+    Diff2.prototype.tokenize = function(value, options) {
+      return Array.from(value);
+    };
+    Diff2.prototype.join = function(chars) {
+      return chars.join("");
+    };
+    Diff2.prototype.postProcess = function(changeObjects, options) {
+      return changeObjects;
+    };
+    Object.defineProperty(Diff2.prototype, "useLongestToken", {
+      get: function() {
+        return false;
+      },
+      enumerable: false,
+      configurable: true
+    });
+    Diff2.prototype.buildValues = function(lastComponent, newTokens, oldTokens) {
+      var components = [];
+      var nextComponent;
+      while (lastComponent) {
+        components.push(lastComponent);
+        nextComponent = lastComponent.previousComponent;
+        delete lastComponent.previousComponent;
+        lastComponent = nextComponent;
+      }
+      components.reverse();
+      var componentLen = components.length;
+      var componentPos = 0, newPos = 0, oldPos = 0;
+      for (; componentPos < componentLen; componentPos++) {
+        var component = components[componentPos];
+        if (!component.removed) {
+          if (!component.added && this.useLongestToken) {
+            var value = newTokens.slice(newPos, newPos + component.count);
+            value = value.map(function(value2, i) {
+              var oldValue = oldTokens[oldPos + i];
+              return oldValue.length > value2.length ? oldValue : value2;
+            });
+            component.value = this.join(value);
+          } else {
+            component.value = this.join(newTokens.slice(newPos, newPos + component.count));
+          }
+          newPos += component.count;
+          if (!component.added) {
+            oldPos += component.count;
+          }
+        } else {
+          component.value = this.join(oldTokens.slice(oldPos, oldPos + component.count));
+          oldPos += component.count;
+        }
+      }
+      return components;
+    };
+    return Diff2;
+  }()
+);
+var base_default = Diff;
+
+// ../../node_modules/.pnpm/diff@8.0.1/node_modules/diff/libesm/diff/character.js
+var __extends = /* @__PURE__ */ function() {
+  var extendStatics = function(d, b) {
+    extendStatics = Object.setPrototypeOf || { __proto__: [] } instanceof Array && function(d2, b2) {
+      d2.__proto__ = b2;
+    } || function(d2, b2) {
+      for (var p in b2) if (Object.prototype.hasOwnProperty.call(b2, p)) d2[p] = b2[p];
+    };
+    return extendStatics(d, b);
+  };
+  return function(d, b) {
+    if (typeof b !== "function" && b !== null)
+      throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+    extendStatics(d, b);
+    function __() {
+      this.constructor = d;
+    }
+    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+  };
+}();
+var CharacterDiff = (
+  /** @class */
+  function(_super) {
+    __extends(CharacterDiff2, _super);
+    function CharacterDiff2() {
+      return _super !== null && _super.apply(this, arguments) || this;
+    }
+    return CharacterDiff2;
+  }(base_default)
+);
+var characterDiff = new CharacterDiff();
+
+// ../../node_modules/.pnpm/diff@8.0.1/node_modules/diff/libesm/util/string.js
 function longestCommonPrefix(str1, str2) {
   var i;
   for (i = 0; i < str1.length && i < str2.length; i++) {
@@ -1932,92 +1967,139 @@ function overlapCount(a, b) {
   }
   return k;
 }
+function trailingWs(string) {
+  var i;
+  for (i = string.length - 1; i >= 0; i--) {
+    if (!string[i].match(/\s/)) {
+      break;
+    }
+  }
+  return string.substring(i + 1);
+}
+function leadingWs(string) {
+  var match = string.match(/^\s*/);
+  return match ? match[0] : "";
+}
+
+// ../../node_modules/.pnpm/diff@8.0.1/node_modules/diff/libesm/diff/word.js
+var __extends2 = /* @__PURE__ */ function() {
+  var extendStatics = function(d, b) {
+    extendStatics = Object.setPrototypeOf || { __proto__: [] } instanceof Array && function(d2, b2) {
+      d2.__proto__ = b2;
+    } || function(d2, b2) {
+      for (var p in b2) if (Object.prototype.hasOwnProperty.call(b2, p)) d2[p] = b2[p];
+    };
+    return extendStatics(d, b);
+  };
+  return function(d, b) {
+    if (typeof b !== "function" && b !== null)
+      throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+    extendStatics(d, b);
+    function __() {
+      this.constructor = d;
+    }
+    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+  };
+}();
 var extendedWordChars = "a-zA-Z0-9_\\u{C0}-\\u{FF}\\u{D8}-\\u{F6}\\u{F8}-\\u{2C6}\\u{2C8}-\\u{2D7}\\u{2DE}-\\u{2FF}\\u{1E00}-\\u{1EFF}";
 var tokenizeIncludingWhitespace = new RegExp("[".concat(extendedWordChars, "]+|\\s+|[^").concat(extendedWordChars, "]"), "ug");
-var wordDiff = new Diff();
-wordDiff.equals = function(left2, right2, options) {
-  if (options.ignoreCase) {
-    left2 = left2.toLowerCase();
-    right2 = right2.toLowerCase();
-  }
-  return left2.trim() === right2.trim();
-};
-wordDiff.tokenize = function(value) {
-  var options = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {};
-  var parts;
-  if (options.intlSegmenter) {
-    if (options.intlSegmenter.resolvedOptions().granularity != "word") {
-      throw new Error('The segmenter passed must have a granularity of "word"');
-    }
-    parts = Array.from(options.intlSegmenter.segment(value), function(segment) {
-      return segment.segment;
-    });
-  } else {
-    parts = value.match(tokenizeIncludingWhitespace) || [];
-  }
-  var tokens = [];
-  var prevPart = null;
-  parts.forEach(function(part) {
-    if (/\s/.test(part)) {
-      if (prevPart == null) {
-        tokens.push(part);
-      } else {
-        tokens.push(tokens.pop() + part);
-      }
-    } else if (/\s/.test(prevPart)) {
-      if (tokens[tokens.length - 1] == prevPart) {
-        tokens.push(tokens.pop() + part);
+var WordDiff = (
+  /** @class */
+  function(_super) {
+    __extends2(WordDiff2, _super);
+    function WordDiff2() {
+      return _super !== null && _super.apply(this, arguments) || this;
+    }
+    WordDiff2.prototype.equals = function(left2, right2, options) {
+      if (options.ignoreCase) {
+        left2 = left2.toLowerCase();
+        right2 = right2.toLowerCase();
+      }
+      return left2.trim() === right2.trim();
+    };
+    WordDiff2.prototype.tokenize = function(value, options) {
+      if (options === void 0) {
+        options = {};
+      }
+      var parts;
+      if (options.intlSegmenter) {
+        var segmenter = options.intlSegmenter;
+        if (segmenter.resolvedOptions().granularity != "word") {
+          throw new Error('The segmenter passed must have a granularity of "word"');
+        }
+        parts = Array.from(segmenter.segment(value), function(segment) {
+          return segment.segment;
+        });
       } else {
-        tokens.push(prevPart + part);
-      }
-    } else {
-      tokens.push(part);
-    }
-    prevPart = part;
-  });
-  return tokens;
-};
-wordDiff.join = function(tokens) {
-  return tokens.map(function(token2, i) {
-    if (i == 0) {
-      return token2;
-    } else {
-      return token2.replace(/^\s+/, "");
-    }
-  }).join("");
-};
-wordDiff.postProcess = function(changes, options) {
-  if (!changes || options.oneChangePerToken) {
-    return changes;
-  }
-  var lastKeep = null;
-  var insertion = null;
-  var deletion = null;
-  changes.forEach(function(change) {
-    if (change.added) {
-      insertion = change;
-    } else if (change.removed) {
-      deletion = change;
-    } else {
+        parts = value.match(tokenizeIncludingWhitespace) || [];
+      }
+      var tokens = [];
+      var prevPart = null;
+      parts.forEach(function(part) {
+        if (/\s/.test(part)) {
+          if (prevPart == null) {
+            tokens.push(part);
+          } else {
+            tokens.push(tokens.pop() + part);
+          }
+        } else if (prevPart != null && /\s/.test(prevPart)) {
+          if (tokens[tokens.length - 1] == prevPart) {
+            tokens.push(tokens.pop() + part);
+          } else {
+            tokens.push(prevPart + part);
+          }
+        } else {
+          tokens.push(part);
+        }
+        prevPart = part;
+      });
+      return tokens;
+    };
+    WordDiff2.prototype.join = function(tokens) {
+      return tokens.map(function(token2, i) {
+        if (i == 0) {
+          return token2;
+        } else {
+          return token2.replace(/^\s+/, "");
+        }
+      }).join("");
+    };
+    WordDiff2.prototype.postProcess = function(changes, options) {
+      if (!changes || options.oneChangePerToken) {
+        return changes;
+      }
+      var lastKeep = null;
+      var insertion = null;
+      var deletion = null;
+      changes.forEach(function(change) {
+        if (change.added) {
+          insertion = change;
+        } else if (change.removed) {
+          deletion = change;
+        } else {
+          if (insertion || deletion) {
+            dedupeWhitespaceInChangeObjects(lastKeep, deletion, insertion, change);
+          }
+          lastKeep = change;
+          insertion = null;
+          deletion = null;
+        }
+      });
       if (insertion || deletion) {
-        dedupeWhitespaceInChangeObjects(lastKeep, deletion, insertion, change);
+        dedupeWhitespaceInChangeObjects(lastKeep, deletion, insertion, null);
       }
-      lastKeep = change;
-      insertion = null;
-      deletion = null;
-    }
-  });
-  if (insertion || deletion) {
-    dedupeWhitespaceInChangeObjects(lastKeep, deletion, insertion, null);
-  }
-  return changes;
-};
+      return changes;
+    };
+    return WordDiff2;
+  }(base_default)
+);
+var wordDiff = new WordDiff();
 function dedupeWhitespaceInChangeObjects(startKeep, deletion, insertion, endKeep) {
   if (deletion && insertion) {
-    var oldWsPrefix = deletion.value.match(/^\s*/)[0];
-    var oldWsSuffix = deletion.value.match(/\s*$/)[0];
-    var newWsPrefix = insertion.value.match(/^\s*/)[0];
-    var newWsSuffix = insertion.value.match(/\s*$/)[0];
+    var oldWsPrefix = leadingWs(deletion.value);
+    var oldWsSuffix = trailingWs(deletion.value);
+    var newWsPrefix = leadingWs(insertion.value);
+    var newWsSuffix = trailingWs(insertion.value);
     if (startKeep) {
       var commonWsPrefix = longestCommonPrefix(oldWsPrefix, newWsPrefix);
       startKeep.value = replaceSuffix(startKeep.value, newWsPrefix, commonWsPrefix);
@@ -2032,13 +2114,15 @@ function dedupeWhitespaceInChangeObjects(startKeep, deletion, insertion, endKeep
     }
   } else if (insertion) {
     if (startKeep) {
-      insertion.value = insertion.value.replace(/^\s*/, "");
+      var ws = leadingWs(insertion.value);
+      insertion.value = insertion.value.substring(ws.length);
     }
     if (endKeep) {
-      endKeep.value = endKeep.value.replace(/^\s*/, "");
+      var ws = leadingWs(endKeep.value);
+      endKeep.value = endKeep.value.substring(ws.length);
     }
   } else if (startKeep && endKeep) {
-    var newWsFull = endKeep.value.match(/^\s*/)[0], delWsStart = deletion.value.match(/^\s*/)[0], delWsEnd = deletion.value.match(/\s*$/)[0];
+    var newWsFull = leadingWs(endKeep.value), delWsStart = leadingWs(deletion.value), delWsEnd = trailingWs(deletion.value);
     var newWsStart = longestCommonPrefix(newWsFull, delWsStart);
     deletion.value = removePrefix(deletion.value, newWsStart);
     var newWsEnd = longestCommonSuffix(removePrefix(newWsFull, newWsStart), delWsEnd);
@@ -2046,24 +2130,85 @@ function dedupeWhitespaceInChangeObjects(startKeep, deletion, insertion, endKeep
     endKeep.value = replacePrefix(endKeep.value, newWsFull, newWsEnd);
     startKeep.value = replaceSuffix(startKeep.value, newWsFull, newWsFull.slice(0, newWsFull.length - newWsEnd.length));
   } else if (endKeep) {
-    var endKeepWsPrefix = endKeep.value.match(/^\s*/)[0];
-    var deletionWsSuffix = deletion.value.match(/\s*$/)[0];
+    var endKeepWsPrefix = leadingWs(endKeep.value);
+    var deletionWsSuffix = trailingWs(deletion.value);
     var overlap = maximumOverlap(deletionWsSuffix, endKeepWsPrefix);
     deletion.value = removeSuffix(deletion.value, overlap);
   } else if (startKeep) {
-    var startKeepWsSuffix = startKeep.value.match(/\s*$/)[0];
-    var deletionWsPrefix = deletion.value.match(/^\s*/)[0];
-    var _overlap = maximumOverlap(startKeepWsSuffix, deletionWsPrefix);
-    deletion.value = removePrefix(deletion.value, _overlap);
-  }
-}
-var wordWithSpaceDiff = new Diff();
-wordWithSpaceDiff.tokenize = function(value) {
-  var regex = new RegExp("(\\r?\\n)|[".concat(extendedWordChars, "]+|[^\\S\\n\\r]+|[^").concat(extendedWordChars, "]"), "ug");
-  return value.match(regex) || [];
-};
-var lineDiff = new Diff();
-lineDiff.tokenize = function(value, options) {
+    var startKeepWsSuffix = trailingWs(startKeep.value);
+    var deletionWsPrefix = leadingWs(deletion.value);
+    var overlap = maximumOverlap(startKeepWsSuffix, deletionWsPrefix);
+    deletion.value = removePrefix(deletion.value, overlap);
+  }
+}
+var WordsWithSpaceDiff = (
+  /** @class */
+  function(_super) {
+    __extends2(WordsWithSpaceDiff2, _super);
+    function WordsWithSpaceDiff2() {
+      return _super !== null && _super.apply(this, arguments) || this;
+    }
+    WordsWithSpaceDiff2.prototype.tokenize = function(value) {
+      var regex = new RegExp("(\\r?\\n)|[".concat(extendedWordChars, "]+|[^\\S\\n\\r]+|[^").concat(extendedWordChars, "]"), "ug");
+      return value.match(regex) || [];
+    };
+    return WordsWithSpaceDiff2;
+  }(base_default)
+);
+var wordsWithSpaceDiff = new WordsWithSpaceDiff();
+
+// ../../node_modules/.pnpm/diff@8.0.1/node_modules/diff/libesm/diff/line.js
+var __extends3 = /* @__PURE__ */ function() {
+  var extendStatics = function(d, b) {
+    extendStatics = Object.setPrototypeOf || { __proto__: [] } instanceof Array && function(d2, b2) {
+      d2.__proto__ = b2;
+    } || function(d2, b2) {
+      for (var p in b2) if (Object.prototype.hasOwnProperty.call(b2, p)) d2[p] = b2[p];
+    };
+    return extendStatics(d, b);
+  };
+  return function(d, b) {
+    if (typeof b !== "function" && b !== null)
+      throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+    extendStatics(d, b);
+    function __() {
+      this.constructor = d;
+    }
+    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+  };
+}();
+var LineDiff = (
+  /** @class */
+  function(_super) {
+    __extends3(LineDiff2, _super);
+    function LineDiff2() {
+      var _this = _super !== null && _super.apply(this, arguments) || this;
+      _this.tokenize = tokenize;
+      return _this;
+    }
+    LineDiff2.prototype.equals = function(left2, right2, options) {
+      if (options.ignoreWhitespace) {
+        if (!options.newlineIsToken || !left2.includes("\n")) {
+          left2 = left2.trim();
+        }
+        if (!options.newlineIsToken || !right2.includes("\n")) {
+          right2 = right2.trim();
+        }
+      } else if (options.ignoreNewlineAtEof && !options.newlineIsToken) {
+        if (left2.endsWith("\n")) {
+          left2 = left2.slice(0, -1);
+        }
+        if (right2.endsWith("\n")) {
+          right2 = right2.slice(0, -1);
+        }
+      }
+      return _super.prototype.equals.call(this, left2, right2, options);
+    };
+    return LineDiff2;
+  }(base_default)
+);
+var lineDiff = new LineDiff();
+function tokenize(value, options) {
   if (options.stripTrailingCr) {
     value = value.replace(/\r\n/g, "\n");
   }
@@ -2080,58 +2225,132 @@ lineDiff.tokenize = function(value, options) {
     }
   }
   return retLines;
-};
-lineDiff.equals = function(left2, right2, options) {
-  if (options.ignoreWhitespace) {
-    if (!options.newlineIsToken || !left2.includes("\n")) {
-      left2 = left2.trim();
-    }
-    if (!options.newlineIsToken || !right2.includes("\n")) {
-      right2 = right2.trim();
-    }
-  } else if (options.ignoreNewlineAtEof && !options.newlineIsToken) {
-    if (left2.endsWith("\n")) {
-      left2 = left2.slice(0, -1);
-    }
-    if (right2.endsWith("\n")) {
-      right2 = right2.slice(0, -1);
-    }
-  }
-  return Diff.prototype.equals.call(this, left2, right2, options);
-};
-var sentenceDiff = new Diff();
-sentenceDiff.tokenize = function(value) {
-  return value.split(/(\S.+?[.!?])(?=\s+|$)/);
-};
-var cssDiff = new Diff();
-cssDiff.tokenize = function(value) {
-  return value.split(/([{}:;,]|\s+)/);
-};
-function _typeof(o) {
-  "@babel/helpers - typeof";
-  return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(o2) {
-    return typeof o2;
-  } : function(o2) {
-    return o2 && "function" == typeof Symbol && o2.constructor === Symbol && o2 !== Symbol.prototype ? "symbol" : typeof o2;
-  }, _typeof(o);
-}
-var jsonDiff = new Diff();
-jsonDiff.useLongestToken = true;
-jsonDiff.tokenize = lineDiff.tokenize;
-jsonDiff.castInput = function(value, options) {
-  var undefinedReplacement = options.undefinedReplacement, _options$stringifyRep = options.stringifyReplacer, stringifyReplacer = _options$stringifyRep === void 0 ? function(k, v) {
-    return typeof v === "undefined" ? undefinedReplacement : v;
-  } : _options$stringifyRep;
-  return typeof value === "string" ? value : JSON.stringify(canonicalize(value, null, null, stringifyReplacer), stringifyReplacer, "  ");
-};
-jsonDiff.equals = function(left2, right2, options) {
-  return Diff.prototype.equals.call(jsonDiff, left2.replace(/,([\r\n])/g, "$1"), right2.replace(/,([\r\n])/g, "$1"), options);
-};
+}
+
+// ../../node_modules/.pnpm/diff@8.0.1/node_modules/diff/libesm/diff/sentence.js
+var __extends4 = /* @__PURE__ */ function() {
+  var extendStatics = function(d, b) {
+    extendStatics = Object.setPrototypeOf || { __proto__: [] } instanceof Array && function(d2, b2) {
+      d2.__proto__ = b2;
+    } || function(d2, b2) {
+      for (var p in b2) if (Object.prototype.hasOwnProperty.call(b2, p)) d2[p] = b2[p];
+    };
+    return extendStatics(d, b);
+  };
+  return function(d, b) {
+    if (typeof b !== "function" && b !== null)
+      throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+    extendStatics(d, b);
+    function __() {
+      this.constructor = d;
+    }
+    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+  };
+}();
+var SentenceDiff = (
+  /** @class */
+  function(_super) {
+    __extends4(SentenceDiff2, _super);
+    function SentenceDiff2() {
+      return _super !== null && _super.apply(this, arguments) || this;
+    }
+    SentenceDiff2.prototype.tokenize = function(value) {
+      return value.split(/(?<=[.!?])(\s+|$)/);
+    };
+    return SentenceDiff2;
+  }(base_default)
+);
+var sentenceDiff = new SentenceDiff();
+
+// ../../node_modules/.pnpm/diff@8.0.1/node_modules/diff/libesm/diff/css.js
+var __extends5 = /* @__PURE__ */ function() {
+  var extendStatics = function(d, b) {
+    extendStatics = Object.setPrototypeOf || { __proto__: [] } instanceof Array && function(d2, b2) {
+      d2.__proto__ = b2;
+    } || function(d2, b2) {
+      for (var p in b2) if (Object.prototype.hasOwnProperty.call(b2, p)) d2[p] = b2[p];
+    };
+    return extendStatics(d, b);
+  };
+  return function(d, b) {
+    if (typeof b !== "function" && b !== null)
+      throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+    extendStatics(d, b);
+    function __() {
+      this.constructor = d;
+    }
+    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+  };
+}();
+var CssDiff = (
+  /** @class */
+  function(_super) {
+    __extends5(CssDiff2, _super);
+    function CssDiff2() {
+      return _super !== null && _super.apply(this, arguments) || this;
+    }
+    CssDiff2.prototype.tokenize = function(value) {
+      return value.split(/([{}:;,]|\s+)/);
+    };
+    return CssDiff2;
+  }(base_default)
+);
+var cssDiff = new CssDiff();
+
+// ../../node_modules/.pnpm/diff@8.0.1/node_modules/diff/libesm/diff/json.js
+var __extends6 = /* @__PURE__ */ function() {
+  var extendStatics = function(d, b) {
+    extendStatics = Object.setPrototypeOf || { __proto__: [] } instanceof Array && function(d2, b2) {
+      d2.__proto__ = b2;
+    } || function(d2, b2) {
+      for (var p in b2) if (Object.prototype.hasOwnProperty.call(b2, p)) d2[p] = b2[p];
+    };
+    return extendStatics(d, b);
+  };
+  return function(d, b) {
+    if (typeof b !== "function" && b !== null)
+      throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+    extendStatics(d, b);
+    function __() {
+      this.constructor = d;
+    }
+    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+  };
+}();
+var JsonDiff = (
+  /** @class */
+  function(_super) {
+    __extends6(JsonDiff2, _super);
+    function JsonDiff2() {
+      var _this = _super !== null && _super.apply(this, arguments) || this;
+      _this.tokenize = tokenize;
+      return _this;
+    }
+    Object.defineProperty(JsonDiff2.prototype, "useLongestToken", {
+      get: function() {
+        return true;
+      },
+      enumerable: false,
+      configurable: true
+    });
+    JsonDiff2.prototype.castInput = function(value, options) {
+      var undefinedReplacement = options.undefinedReplacement, _a2 = options.stringifyReplacer, stringifyReplacer = _a2 === void 0 ? function(k, v) {
+        return typeof v === "undefined" ? undefinedReplacement : v;
+      } : _a2;
+      return typeof value === "string" ? value : JSON.stringify(canonicalize(value, null, null, stringifyReplacer), null, "  ");
+    };
+    JsonDiff2.prototype.equals = function(left2, right2, options) {
+      return _super.prototype.equals.call(this, left2.replace(/,([\r\n])/g, "$1"), right2.replace(/,([\r\n])/g, "$1"), options);
+    };
+    return JsonDiff2;
+  }(base_default)
+);
+var jsonDiff = new JsonDiff();
 function canonicalize(obj, stack, replacementStack, replacer, key) {
   stack = stack || [];
   replacementStack = replacementStack || [];
   if (replacer) {
-    obj = replacer(key, obj);
+    obj = replacer(key === void 0 ? "" : key, obj);
   }
   var i;
   for (i = 0; i < stack.length; i += 1) {
@@ -2145,7 +2364,7 @@ function canonicalize(obj, stack, replacementStack, replacer, key) {
     canonicalizedObj = new Array(obj.length);
     replacementStack.push(canonicalizedObj);
     for (i = 0; i < obj.length; i += 1) {
-      canonicalizedObj[i] = canonicalize(obj[i], stack, replacementStack, replacer, key);
+      canonicalizedObj[i] = canonicalize(obj[i], stack, replacementStack, replacer, String(i));
     }
     stack.pop();
     replacementStack.pop();
@@ -2154,20 +2373,21 @@ function canonicalize(obj, stack, replacementStack, replacer, key) {
   if (obj && obj.toJSON) {
     obj = obj.toJSON();
   }
-  if (_typeof(obj) === "object" && obj !== null) {
+  if (typeof obj === "object" && obj !== null) {
     stack.push(obj);
     canonicalizedObj = {};
     replacementStack.push(canonicalizedObj);
-    var sortedKeys = [], _key;
-    for (_key in obj) {
-      if (Object.prototype.hasOwnProperty.call(obj, _key)) {
-        sortedKeys.push(_key);
+    var sortedKeys = [];
+    var key_1;
+    for (key_1 in obj) {
+      if (Object.prototype.hasOwnProperty.call(obj, key_1)) {
+        sortedKeys.push(key_1);
       }
     }
     sortedKeys.sort();
     for (i = 0; i < sortedKeys.length; i += 1) {
-      _key = sortedKeys[i];
-      canonicalizedObj[_key] = canonicalize(obj[_key], stack, replacementStack, replacer, _key);
+      key_1 = sortedKeys[i];
+      canonicalizedObj[key_1] = canonicalize(obj[key_1], stack, replacementStack, replacer, key_1);
     }
     stack.pop();
     replacementStack.pop();
@@ -2176,16 +2396,47 @@ function canonicalize(obj, stack, replacementStack, replacer, key) {
   }
   return canonicalizedObj;
 }
-var arrayDiff = new Diff();
-arrayDiff.tokenize = function(value) {
-  return value.slice();
-};
-arrayDiff.join = arrayDiff.removeEmpty = function(value) {
-  return value;
-};
 
-// src/cli.ts
-import fs from "fs";
+// ../../node_modules/.pnpm/diff@8.0.1/node_modules/diff/libesm/diff/array.js
+var __extends7 = /* @__PURE__ */ function() {
+  var extendStatics = function(d, b) {
+    extendStatics = Object.setPrototypeOf || { __proto__: [] } instanceof Array && function(d2, b2) {
+      d2.__proto__ = b2;
+    } || function(d2, b2) {
+      for (var p in b2) if (Object.prototype.hasOwnProperty.call(b2, p)) d2[p] = b2[p];
+    };
+    return extendStatics(d, b);
+  };
+  return function(d, b) {
+    if (typeof b !== "function" && b !== null)
+      throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+    extendStatics(d, b);
+    function __() {
+      this.constructor = d;
+    }
+    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+  };
+}();
+var ArrayDiff = (
+  /** @class */
+  function(_super) {
+    __extends7(ArrayDiff2, _super);
+    function ArrayDiff2() {
+      return _super !== null && _super.apply(this, arguments) || this;
+    }
+    ArrayDiff2.prototype.tokenize = function(value) {
+      return value.slice();
+    };
+    ArrayDiff2.prototype.join = function(value) {
+      return value;
+    };
+    ArrayDiff2.prototype.removeEmpty = function(value) {
+      return value;
+    };
+    return ArrayDiff2;
+  }(base_default)
+);
+var arrayDiff = new ArrayDiff();
 
 // ../mini-parse/src/Assertions.ts
 function assertThat(condition, msg) {
@@ -2302,12 +2553,10 @@ function logInternalSrc(log2, src, pos, ...msgs) {
   log2(caret);
 }
 function carets(linePos, linePos2) {
-  const firstCaret = " ".repeat(linePos) + "^";
-  let secondCaret = "";
-  if (linePos2 && linePos2 > linePos) {
-    secondCaret = " ".repeat(linePos2 - linePos - 1) + "^";
-  }
-  return firstCaret + secondCaret;
+  const indent = " ".repeat(linePos);
+  const numCarets = linePos2 ? linePos2 - linePos : 1;
+  const carets2 = "^".repeat(numCarets);
+  return indent + carets2;
 }
 var startCache = /* @__PURE__ */ new Map();
 function srcLine(src, position) {
@@ -2563,6 +2812,18 @@ function opt(arg) {
     }
   );
 }
+function not(arg) {
+  const p = parserArg(arg);
+  return parser2("not", function _not(state) {
+    const pos = state.stream.checkpoint();
+    const result = p._run(state);
+    if (result === null) {
+      state.stream.reset(pos);
+      return { value: true };
+    }
+    return null;
+  });
+}
 function repeat(arg) {
   const p = parserArg(arg);
   return parser2("repeat", repeatWhileFilter(p));
@@ -2704,7 +2965,7 @@ function parserArg(arg) {
 function fn(fn2) {
   const parser3 = new Parser2({
     fn: function _fn(state) {
-      let generatedParser = fn2();
+      const generatedParser = fn2();
       if (!fn2) {
         const before = state.stream.checkpoint();
         throw new ParseError(`fn parser called before definition`, [
@@ -3026,7 +3287,7 @@ function runParserWithTracing(debugName, fn2, context, traceInfo) {
         parserLog(`..${debugName}`);
       }
     }
-    let result2 = fn2(ctx);
+    const result2 = fn2(ctx);
     if (result2 === null) {
       if (tracing) {
         const traceSuccessOnly = ctx._trace?.successOnly;
@@ -3359,9 +3620,6 @@ function findGroupDex(indices) {
   }
 }
 
-// src/cli.ts
-import path from "path";
-
 // ../wesl/src/Assertions.ts
 function assertThat2(condition, msg) {
   if (!condition) {
@@ -3406,13 +3664,13 @@ function mapValues(obj, fn2) {
   return Object.fromEntries(Object.entries(obj).map(([k, v]) => [k, fn2(v)]));
 }
 function offsetToLineNumber(offset, text2) {
-  offset = Math.min(text2.length, Math.max(0, offset));
+  const safeOffset = Math.min(text2.length, Math.max(0, offset));
   let lineStartOffset = 0;
   let lineNum = 1;
   while (true) {
     const lineEnd = text2.indexOf("\n", lineStartOffset);
-    if (lineEnd === -1 || offset <= lineEnd) {
-      const linePos = 1 + (offset - lineStartOffset);
+    if (lineEnd === -1 || safeOffset <= lineEnd) {
+      const linePos = 1 + (safeOffset - lineStartOffset);
       return [lineNum, linePos];
     } else {
       lineStartOffset = lineEnd + 1;
@@ -3438,6 +3696,111 @@ function errorHighlight(source, span2) {
   ];
 }
 
+// ../wesl/src/vlq/vlq.ts
+var char_to_integer = {};
+var 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;
+}
+
+// ../wesl/src/ClickableError.ts
+function throwClickableError(params) {
+  const { url, text: text2, lineNumber, lineColumn, length, error } = params;
+  const mappings = encodeVlq([
+    0,
+    0,
+    Math.max(0, lineNumber - 1),
+    Math.max(0, lineColumn - 1)
+  ]) + "," + // Sadly no browser makes use of this info to map the error properly
+  encodeVlq([
+    18,
+    // Arbitrary number that is high enough
+    0,
+    Math.max(0, lineNumber - 1),
+    Math.max(0, lineColumn - 1) + length
+  ]);
+  const sourceMap = {
+    version: 3,
+    file: null,
+    sources: [url],
+    sourcesContent: [text2 ?? 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;
+  }
+}
+function failIdent(ident2, msg) {
+  const { refIdentElem, originalName } = ident2;
+  const baseMessage = msg ?? `'${originalName}'`;
+  if (refIdentElem) {
+    failIdentElem(refIdentElem, baseMessage);
+  } else {
+    throw new Error(baseMessage);
+  }
+}
+function failIdentElem(identElem, msg = "") {
+  const { srcModule, start, end } = identElem;
+  const { debugFilePath, src } = srcModule;
+  const detailedMessage = `${msg} in file: ${debugFilePath}`;
+  srcLog(src, [start, end], detailedMessage);
+  const [lineNumber, lineColumn] = offsetToLineNumber(start, src);
+  const length = end - start;
+  throwClickableError({
+    url: debugFilePath,
+    text: src,
+    lineNumber,
+    lineColumn,
+    length,
+    error: new Error(detailedMessage)
+  });
+}
+
 // ../wesl/src/Conditions.ts
 function elementValid(elem, conditions) {
   const attributes = elem.attributes;
@@ -3460,10 +3823,10 @@ function evaluateIfAttribute(ifAttribute, conditions) {
 }
 function evaluateIfExpression(expression2, conditions) {
   const { kind: kind2 } = expression2;
-  if (kind2 == "unary-expression") {
+  if (kind2 === "unary-expression") {
     assertThatDebug(expression2.operator.value === "!");
     return !evaluateIfExpression(expression2.expression, conditions);
-  } else if (kind2 == "binary-expression") {
+  } else if (kind2 === "binary-expression") {
     const op = expression2.operator.value;
     assertThatDebug(op === "||" || op === "&&");
     const leftResult = evaluateIfExpression(expression2.left, conditions);
@@ -3474,11 +3837,11 @@ function evaluateIfExpression(expression2, conditions) {
     } else {
       assertUnreachable2(op);
     }
-  } else if (kind2 == "literal") {
+  } else if (kind2 === "literal") {
     const { value } = expression2;
     assertThatDebug(value === "true" || value === "false");
     return value === "true";
-  } else if (kind2 == "parenthesized-expression") {
+  } else if (kind2 === "parenthesized-expression") {
     return evaluateIfExpression(expression2.expression, conditions);
   } else if (kind2 === "translate-time-feature") {
     return conditions[expression2.name];
@@ -3726,7 +4089,7 @@ function importElem(cc) {
 function addToOpenElem(cc, elem) {
   const weslContext = cc.app.context;
   const { openElems } = weslContext;
-  if (openElems && openElems.length) {
+  if (openElems?.length) {
     const open = openElems[openElems.length - 1];
     open.contents.push(elem);
   }
@@ -3888,7 +4251,7 @@ var fnCollect = collectElem(
     mergeScope(mergedScope, bodyScope);
     const filtered = [];
     for (const e of fnScope.contents) {
-      if (e === headerScope || e == returnScope) {
+      if (e === headerScope || e === returnScope) {
         continue;
       } else if (e === bodyScope) {
         filtered.push(mergedScope);
@@ -3989,7 +4352,7 @@ var typeRefCollect = collectElem(
   "type",
   // @ts-ignore
   (cc, openElem) => {
-    let templateParamsTemp = cc.tags.templateParam?.flat(3);
+    const templateParamsTemp = cc.tags.templateParam?.flat(3);
     const typeRef = cc.tags.typeRefName?.[0];
     const name2 = typeof typeRef === "string" ? typeRef : typeRef.ident;
     const partElem = {
@@ -4024,7 +4387,7 @@ var memberRefCollect = collectElem(
   "memberRef",
   (cc, openElem) => {
     const { component, structRef, extra_components } = cc.tags;
-    const member = component[0];
+    const member = component?.[0];
     const name2 = structRef?.flat()[0];
     const extraComponents = extra_components?.flat()[0];
     const partElem = {
@@ -4037,7 +4400,7 @@ var memberRefCollect = collectElem(
   }
 );
 function nameCollect(cc) {
-  const { start, end, src, app } = cc;
+  const { start, end, src } = cc;
   const name2 = src.slice(start, end);
   const elem = { kind: "name", start, end, name: name2 };
   addToOpenElem(cc, elem);
@@ -4120,7 +4483,10 @@ function coverWithText(cc, elem) {
 // ../wesl/src/parse/WeslBaseGrammar.ts
 var word = kind("word");
 var keyword = kind("keyword");
-var qualified_ident = withSepPlus("::", or(word, "package", "super"));
+var qualified_ident = withSepPlus(
+  "::",
+  or(word, keyword, "package", "super")
+);
 var number = kind("number");
 
 // ../wesl/src/parse/ImportGrammar.ts
@@ -4144,8 +4510,10 @@ function prependSegments(segments, statement2) {
   return statement2;
 }
 var import_collection = null;
+var segment_blacklist = or("super", "package", "import", "as");
+var packageWord = preceded(not(segment_blacklist), or(word, keyword));
 var import_path_or_item = seq(
-  word,
+  packageWord,
   or(
     preceded(
       "::",
@@ -4271,6 +4639,7 @@ var weslMatcher = new RegexMatchers({
   blankspaces,
   commentStart,
   symbol: matchOneOf(symbolSet),
+  // biome-ignore lint/correctness/noEmptyCharacterClassInRegex: TODO
   invalid: /[^]/
 });
 function weslExtension(combinator) {
@@ -4305,7 +4674,7 @@ var WeslStream = class {
           this.stream.reset(this.skipBlockComment(token2.span[1]));
         }
       } else if (kind2 === "word") {
-        let returnToken = token2;
+        const returnToken = token2;
         if (keywordOrReserved.has(token2.text)) {
           returnToken.kind = "keyword";
         }
@@ -4326,7 +4695,8 @@ var WeslStream = class {
       return this.eolPattern.lastIndex;
     }
   }
-  skipBlockComment(position) {
+  skipBlockComment(start) {
+    let position = start;
     while (true) {
       this.blockCommentPattern.lastIndex = position;
       const result = this.blockCommentPattern.exec(this.src);
@@ -4393,7 +4763,7 @@ var WeslStream = class {
       if (nextToken.text === "<") {
         pendingCounter += 1;
       } else if (nextToken.text[0] === ">") {
-        if (nextToken.text === ">" || nextToken.text == ">=") {
+        if (nextToken.text === ">" || nextToken.text === ">=") {
           pendingCounter -= 1;
         } else if (nextToken.text === ">>=" || nextToken.text === ">>") {
           pendingCounter -= 2;
@@ -4633,11 +5003,25 @@ var special_attribute = tagScope(
     "@",
     or(
       // These attributes have no arguments
-      or("compute", "const", "fragment", "invariant", "must_use", "vertex").map((name2) => makeStandardAttribute([name2, []])),
+      or("compute", "const", "fragment", "invariant", "must_use", "vertex").map(
+        (name2) => makeStandardAttribute([name2, []])
+      ),
       // These attributes have arguments, but the argument doesn't have any identifiers
-      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)
+      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)
 );
@@ -4673,7 +5057,7 @@ var normal_attribute = tagScope(
       ),
       // Everything else is also a normal attribute, optional expression list
       seq(
-        // we don't want this to interfere with if_attribute, 
+        // we don't want this to interfere with if_attribute,
         // but not("if") isn't necessary for now, since 'if' is a keyword, not a word
         word.ptag("name"),
         opt(() => attribute_argument_list)
@@ -4690,10 +5074,9 @@ var attribute_argument_list = delimited(
   ),
   req(")", "invalid attribute arguments, expected ')'")
 );
-var attribute_no_if = or(
-  special_attribute,
-  normal_attribute
-).ctag("attribute");
+var attribute_no_if = or(special_attribute, normal_attribute).ctag(
+  "attribute"
+);
 var attribute_incl_if = or(
   if_attribute,
   special_attribute,
@@ -4752,7 +5135,12 @@ var 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")
+    opt(
+      seq(
+        ":",
+        req(type_specifier, "invalid fn parameter, expected type specifier")
+      )
+    ).collect(typedDecl, "param_name")
   ).collect(collectFnParam)
 ).ctag("fn_param");
 var fnParamList = seq("(", withSep(",", fnParam), ")");
@@ -4944,16 +5332,10 @@ var regular_statement = or(
   )
 );
 var conditional_statement = tagScope(
-  seq(
-    opt_attributes,
-    regular_statement
-  ).collect(statementCollect).collect(partialScopeCollect)
+  seq(opt_attributes, regular_statement).collect(statementCollect).collect(partialScopeCollect)
 );
 var unconditional_statement = tagScope(
-  seq(
-    opt_attributes_no_if,
-    regular_statement
-  )
+  seq(opt_attributes_no_if, regular_statement)
 );
 var statement = or(
   compound_statement,
@@ -4962,10 +5344,7 @@ var statement = or(
 );
 var lhs_expression = or(
   simple_component_reference,
-  seq(
-    qualified_ident.collect(refIdent),
-    opt(component_or_swizzle)
-  ),
+  seq(qualified_ident.collect(refIdent), opt(component_or_swizzle)),
   seq(
     "(",
     () => lhs_expression,
@@ -4981,7 +5360,12 @@ var variable_or_value_statement = tagScope(
   or(
     // Also covers the = expression case
     local_variable_decl,
-    seq("const", req_optionally_typed_ident, req("=", "invalid const declaration, expected '='"), expression),
+    seq(
+      "const",
+      req_optionally_typed_ident,
+      req("=", "invalid const declaration, expected '='"),
+      expression
+    ),
     seq(
       "let",
       req_optionally_typed_ident,
@@ -5000,22 +5384,24 @@ var variable_updating_statement = or(
   seq("_", "=", expression)
 );
 var fn_decl = seq(
-  tagScope(
-    opt_attributes.collect((cc) => cc.tags.attribute || [])
-  ).ctag("fn_attributes"),
+  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")
+    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);
 var global_value_decl = or(
@@ -5038,9 +5424,15 @@ var global_value_decl = or(
 var global_alias = seq(
   weslExtension(opt_attributes).collect((cc) => cc.tags.attribute, "attributes"),
   "alias",
-  req(word, "invalid alias, expected name").collect(globalDeclCollect, "alias_name"),
+  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(type_specifier, "invalid alias, expected type").collect(
+    scopeCollect,
+    "alias_scope"
+  ),
   req(";", "invalid alias, expected ';'")
 ).collect(aliasCollect);
 var const_assert = tagScope(
@@ -5255,91 +5647,6 @@ if (tracing) {
   });
 }
 
-// ../wesl/src/vlq/vlq.ts
-var char_to_integer = {};
-var integer_to_char = {};
-"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=".split("").forEach(function(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 = "";
-  if (num < 0) {
-    num = -num << 1 | 1;
-  } else {
-    num <<= 1;
-  }
-  do {
-    let clamped = num & 31;
-    num >>>= 5;
-    if (num > 0) {
-      clamped |= 32;
-    }
-    result += integer_to_char[clamped];
-  } while (num > 0);
-  return result;
-}
-
-// ../wesl/src/WeslDevice.ts
-function throwClickableError({
-  url,
-  text: text2,
-  lineNumber,
-  lineColumn,
-  length,
-  error
-}) {
-  let mappings = encodeVlq([
-    0,
-    0,
-    Math.max(0, lineNumber - 1),
-    Math.max(0, lineColumn - 1)
-  ]) + "," + // Sadly no browser makes use of this info to map the error properly
-  encodeVlq([
-    18,
-    // Arbitrary number that is high enough
-    0,
-    Math.max(0, lineNumber - 1),
-    Math.max(0, lineColumn - 1) + length
-  ]);
-  const sourceMap = {
-    version: 3,
-    file: null,
-    sources: [url],
-    sourcesContent: [text2 ?? 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 = "";
-    e.cause = error;
-    throw e;
-  }
-}
-
 // ../wesl/src/ParseWESL.ts
 var WeslParseError = class extends Error {
   constructor(opts) {
@@ -5356,7 +5663,7 @@ var WeslParseError = class extends Error {
     this.src = opts.src;
   }
 };
-function parseSrcModule(srcModule, srcMap) {
+function parseSrcModule(srcModule) {
   const stream = new WeslStream(srcModule.src);
   const appState = blankWeslParseState(srcModule);
   const init = { stream, appState };
@@ -5526,7 +5833,7 @@ function findValidRootDecls(rootScope, conditions) {
   return found;
 }
 function bindIdentsRecursive(scope, bindContext, liveDecls, isRoot = false) {
-  const { conditions, foundScopes } = bindContext;
+  const { dontFollowDecls, foundScopes } = bindContext;
   if (foundScopes.has(scope)) return [];
   foundScopes.add(scope);
   const newGlobals = [];
@@ -5546,7 +5853,12 @@ function bindIdentsRecursive(scope, bindContext, liveDecls, isRoot = false) {
       }
     }
   });
-  const newFromRefs = newGlobals.flatMap((decl) => {
+  const newFromRefs = dontFollowDecls ? [] : handleDecls(newGlobals, bindContext);
+  return [newGlobals, newFromChildren, newFromRefs].flat();
+}
+function handleDecls(newGlobals, bindContext) {
+  const { conditions } = bindContext;
+  return newGlobals.flatMap((decl) => {
     const foundsScope = decl.dependentScope;
     if (foundsScope) {
       const rootDecls = globalDeclToRootLiveDecls(decl, conditions);
@@ -5557,7 +5869,6 @@ function bindIdentsRecursive(scope, bindContext, liveDecls, isRoot = false) {
     }
     return [];
   });
-  return [newGlobals, newFromChildren, newFromRefs].flat();
 }
 function handleRef(ident2, liveDecls, bindContext) {
   const { registry, conditions, unbound } = bindContext;
@@ -5570,7 +5881,7 @@ function handleRef(ident2, liveDecls, bindContext) {
     } else if (stdWgsl(ident2.originalName)) {
       ident2.std = true;
     } else if (!unbound) {
-      failMissingIdent(ident2);
+      failIdent(ident2, `unresolved identifier '${ident2.originalName}'`);
     }
   }
 }
@@ -5619,16 +5930,6 @@ function globalDeclToRootLiveDecls(decl, conditions) {
   root._scopeDecls = liveDecls;
   return liveDecls;
 }
-function failMissingIdent(ident2) {
-  const { refIdentElem } = ident2;
-  if (refIdentElem) {
-    const { srcModule, start, end } = refIdentElem;
-    const { debugFilePath: filePath } = srcModule;
-    const msg = `unresolved identifier '${ident2.originalName}' in file: ${filePath}`;
-    srcLog(srcModule.src, [start, end], msg);
-    throw new Error(msg);
-  }
-}
 function setMangledName(proposedName, decl, globalNames, srcModule, mangler) {
   if (!decl.mangledName) {
     let mangledName;
@@ -5674,8 +5975,8 @@ function findQualifiedImport(refIdent2, parsed, conditions, virtuals, unbound) {
       if (unbound) {
         unbound.push(modulePathParts);
       } else {
-        const msg = `ident ${modulePathParts.join("::")}, but module not found`;
-        console.log(msg);
+        const msg = `module not found for '${modulePathParts.join("::")}'`;
+        failIdent(refIdent2, msg);
       }
     }
     return result;
@@ -5753,16 +6054,21 @@ function lowerAndEmitElem(e, ctx) {
       return;
     // terminal elements copy strings to the output
     case "text":
-      return emitText(e, ctx);
+      emitText(e, ctx);
+      return;
     case "name":
-      return emitName(e, ctx);
+      emitName(e, ctx);
+      return;
     case "synthetic":
-      return emitSynthetic(e, ctx);
+      emitSynthetic(e, ctx);
+      return;
     // identifiers are copied to the output, but with potentially mangled names
     case "ref":
-      return emitRefIdent(e, ctx);
+      emitRefIdent(e, ctx);
+      return;
     case "decl":
-      return emitDeclIdent(e, ctx);
+      emitDeclIdent(e, ctx);
+      return;
     // container elements just emit their child elements
     case "param":
     case "var":
@@ -5776,7 +6082,8 @@ function lowerAndEmitElem(e, ctx) {
     case "statement":
     case "stuff":
     case "switch-clause":
-      return emitContents(e, ctx);
+      emitContents(e, ctx);
+      return;
     // root level container elements get some extra newlines to make the output prettier
     case "override":
     case "const":
@@ -5784,17 +6091,22 @@ function lowerAndEmitElem(e, ctx) {
     case "alias":
     case "gvar":
       emitRootElemNl(ctx);
-      return emitContents(e, ctx);
+      emitContents(e, ctx);
+      return;
     case "fn":
       emitRootElemNl(ctx);
-      return emitFn(e, ctx);
+      emitFn(e, ctx);
+      return;
     case "struct":
       emitRootElemNl(ctx);
-      return emitStruct(e, ctx);
+      emitStruct(e, ctx);
+      return;
     case "attribute":
-      return emitAttribute(e, ctx);
+      emitAttribute(e, ctx);
+      return;
     case "directive":
-      return emitDirective(e, ctx);
+      emitDirective(e, ctx);
+      return;
     default:
       assertUnreachable2(e);
   }
@@ -5869,12 +6181,8 @@ function emitStruct(e, ctx) {
 function warnEmptyStruct(e) {
   const { name: name2, members } = e;
   const condStr = members.length ? "(with current conditions)" : "";
-  const { debugFilePath: filePath } = name2.srcModule;
-  srcLog(
-    name2.srcModule.src,
-    e.start,
-    `struct ${name2.ident.originalName} in ${filePath} has no members ${condStr}`
-  );
+  const message = `struct '${name2.ident.originalName}' has no members ${condStr}`;
+  failIdentElem(name2, message);
 }
 function emitSynthetic(e, ctx) {
   const { text: text2 } = e;
@@ -6319,7 +6627,7 @@ var LinkedWesl = class {
       code: this.dest
     });
     device.popErrorScope();
-    let { promise, resolve: resolve5 } = Promise.withResolvers();
+    const { promise, resolve: resolve5 } = Promise.withResolvers();
     device.injectError("validation", promise);
     module.getCompilationInfo().then((compilationInfo) => {
       if (compilationInfo.messages.length === 0) {
@@ -6363,7 +6671,7 @@ var LinkedWesl = class {
     const srcPosition = srcMap.destToSrc(message.offset);
     const srcEndPosition = message.length > 0 ? srcMap.destToSrc(message.offset + message.length) : srcPosition;
     const length = srcEndPosition.position - srcPosition.position;
-    let [lineNum, linePos] = offsetToLineNumber(
+    const [lineNum, linePos] = offsetToLineNumber(
       srcPosition.position,
       srcPosition.src.text
     );
@@ -6386,7 +6694,7 @@ function compilationInfoToErrorMessage(compilationInfo, shaderModule) {
   if (compilationInfo.messages.length === 0) return null;
   let result = `Compilation log for [Invalid ShaderModule (${shaderModule.label || "unlabled"})]:
 `;
-  let errorCount = compilationInfo.messages.filter(
+  const errorCount = compilationInfo.messages.filter(
     (v) => v.type === "error"
   ).length;
   if (errorCount > 0) {
@@ -6450,19 +6758,20 @@ function selectModule(parsed, selectPath, packageName = "package") {
   return parsed.modules[modulePath];
 }
 function parseIntoRegistry(srcFiles, registry, packageName = "package", debugWeslRoot) {
-  if (debugWeslRoot === void 0) {
-    debugWeslRoot = "";
-  } else if (!debugWeslRoot.endsWith("/")) {
-    debugWeslRoot += "/";
+  let weslRoot2 = debugWeslRoot;
+  if (weslRoot2 === void 0) {
+    weslRoot2 = "";
+  } else if (!weslRoot2.endsWith("/")) {
+    weslRoot2 += "/";
   }
   const srcModules = Object.entries(srcFiles).map(
     ([filePath, src]) => {
       const modulePath = fileToModulePath(filePath, packageName);
-      return { modulePath, debugFilePath: debugWeslRoot + filePath, src };
+      return { modulePath, debugFilePath: weslRoot2 + filePath, src };
     }
   );
   srcModules.forEach((mod) => {
-    const parsed = parseSrcModule(mod, void 0);
+    const parsed = parseSrcModule(mod);
     if (registry.modules[mod.modulePath]) {
       throw new Error(`duplicate module path: '${mod.modulePath}'`);
     }
@@ -6497,7 +6806,8 @@ async function link(params) {
   const registry = parsedRegistry();
   parseIntoRegistry(weslSrc, registry, "package", debugWeslRoot);
   parseLibsIntoRegistry(libs, registry);
-  return new LinkedWesl(linkRegistry({ registry, ...params }));
+  const srcMap = linkRegistry({ registry, ...params });
+  return new LinkedWesl(srcMap);
 }
 function linkRegistry(params) {
   const bound = bindAndTransform(params);
@@ -6521,7 +6831,7 @@ function bindAndTransform(params) {
   if (constants) {
     virtualLibs = { ...virtualLibs, constants: constantsGenerator(constants) };
   }
-  let virtuals = virtualLibs && mapValues(virtualLibs, (fn2) => ({ fn: fn2 }));
+  const virtuals = virtualLibs && mapValues(virtualLibs, (fn2) => ({ fn: fn2 }));
   const bindParams = { rootAst, registry, conditions, virtuals, mangler };
   const bindResults = bindIdents(bindParams);
   const { globalNames, decls: newDecls, newStatements } = bindResults;
@@ -9897,26 +10207,8 @@ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLI
 /*! Bundled license information:
 
 yargs-parser/build/lib/string-utils.js:
-  (**
-   * @license
-   * Copyright (c) 2016, Contributors
-   * SPDX-License-Identifier: ISC
-   *)
-
 yargs-parser/build/lib/tokenize-arg-string.js:
-  (**
-   * @license
-   * Copyright (c) 2016, Contributors
-   * SPDX-License-Identifier: ISC
-   *)
-
 yargs-parser/build/lib/yargs-parser-types.js:
-  (**
-   * @license
-   * Copyright (c) 2016, Contributors
-   * SPDX-License-Identifier: ISC
-   *)
-
 yargs-parser/build/lib/yargs-parser.js:
   (**
    * @license