wesl-link 0.6.2 → 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) {
@@ -2714,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`, [
@@ -3036,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;
@@ -3369,9 +3620,6 @@ function findGroupDex(indices) {
   }
 }
 
-// src/cli.ts
-import path from "path";
-
 // ../wesl/src/Assertions.ts
 function assertThat2(condition, msg) {
   if (!condition) {
@@ -3416,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;
@@ -3467,19 +3715,20 @@ function encodeVlq(value) {
 }
 function encode_integer(num) {
   let result = "";
+  let enc;
   if (num < 0) {
-    num = -num << 1 | 1;
+    enc = -num << 1 | 1;
   } else {
-    num <<= 1;
+    enc = num << 1;
   }
   do {
-    let clamped = num & 31;
-    num >>>= 5;
-    if (num > 0) {
+    let clamped = enc & 31;
+    enc >>>= 5;
+    if (enc > 0) {
       clamped |= 32;
     }
     result += integer_to_char[clamped];
-  } while (num > 0);
+  } while (enc > 0);
   return result;
 }
 
@@ -4151,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);
@@ -4390,6 +4639,7 @@ var weslMatcher = new RegexMatchers({
   blankspaces,
   commentStart,
   symbol: matchOneOf(symbolSet),
+  // biome-ignore lint/correctness/noEmptyCharacterClassInRegex: TODO
   invalid: /[^]/
 });
 function weslExtension(combinator) {
@@ -4445,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);
@@ -4866,10 +5117,7 @@ var struct_member = tagScope(
   ).collect(collectStructMember)
 ).ctag("members");
 var struct_decl = seq(
-  weslExtension(opt_attributes).collect(
-    (cc) => cc.tags.attribute,
-    "attributes"
-  ),
+  weslExtension(opt_attributes).collect((cc) => cc.tags.attribute, "attributes"),
   "struct",
   req(globalTypeNameDecl, "invalid struct, expected name"),
   seq(
@@ -5174,10 +5422,7 @@ var global_value_decl = or(
   ).collect(collectVarLike("const"))
 ).collect(partialScopeCollect);
 var global_alias = seq(
-  weslExtension(opt_attributes).collect(
-    (cc) => cc.tags.attribute,
-    "attributes"
-  ),
+  weslExtension(opt_attributes).collect((cc) => cc.tags.attribute, "attributes"),
   "alias",
   req(word, "invalid alias, expected name").collect(
     globalDeclCollect,
@@ -5418,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 };
@@ -5910,9 +6155,7 @@ function emitAttributes(attributes, ctx) {
 function emitStruct(e, ctx) {
   const { name: name2, members, start, end } = e;
   const { srcBuilder } = ctx;
-  const validMembers = members.filter(
-    (m) => conditionsValid(m, ctx.conditions)
-  );
+  const validMembers = members.filter((m) => conditionsValid(m, ctx.conditions));
   const validLength = validMembers.length;
   if (validLength === 0) {
     warnEmptyStruct(e);
@@ -6515,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}'`);
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wesl-link",
-  "version": "0.6.2",
+  "version": "0.6.6",
   "type": "module",
   "repository": "https://github.com/wgsl-tooling-wg/wesl-js/tree/main/packages/cli",
   "homepage": "https://github.com/wgsl-tooling-wg/wesl-js/tree/main/packages/cli#readme",
@@ -9,12 +9,12 @@
   ],
   "bin": "bin/wesl-link",
   "dependencies": {
-    "@types/diff": "^7.0.2",
-    "diff": "^7.0.0",
-    "wesl": "0.6.2"
+    "@types/diff": "^8.0.0",
+    "diff": "^8.0.1",
+    "wesl": "0.6.6"
   },
   "devDependencies": {
-    "mini-parse": "0.6.2"
+    "mini-parse": "0.6.6"
   },
   "scripts": {
     "echo": "echo",