@bemoje/devkit 1.0.0 → 1.0.1

package/dist/devkit.cjs

@@ -26,6 +26,7 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
 var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
   // If the importer is in node compatibility mode or this is not an ESM
   // file that has been converted to a CommonJS file using a Babel-
@@ -6554,7 +6555,7 @@ var require_upath = __commonJS({
     var propName;
     var propValue;
     var toUnix;
-    var upath26;
+    var upath32;
     var slice = [].slice;
     var indexOf = [].indexOf || function(item) {
       for (var i = 0, l = this.length; i < l; i++) {
@@ -6571,8 +6572,8 @@ var require_upath = __commonJS({
     isString = /* @__PURE__ */ __name(function(val) {
       return typeof val === "string" || !!val && typeof val === "object" && Object.prototype.toString.call(val) === "[object String]";
     }, "isString");
-    upath26 = exports2;
-    upath26.VERSION = typeof VERSION !== "undefined" && VERSION !== null ? VERSION : "NO-VERSION";
+    upath32 = exports2;
+    upath32.VERSION = typeof VERSION !== "undefined" && VERSION !== null ? VERSION : "NO-VERSION";
     toUnix = /* @__PURE__ */ __name(function(p) {
       p = p.replace(/\\/g, "/");
       p = p.replace(/(?<!^)\/+/g, "/");
@@ -6581,7 +6582,7 @@ var require_upath = __commonJS({
     for (propName in path7) {
       propValue = path7[propName];
       if (isFunction2(propValue)) {
-        upath26[propName] = /* @__PURE__ */ function(propName2) {
+        upath32[propName] = /* @__PURE__ */ function(propName2) {
           return function() {
             var args, result;
             args = 1 <= arguments.length ? slice.call(arguments, 0) : [];
@@ -6601,16 +6602,16 @@ var require_upath = __commonJS({
           };
         }(propName);
       } else {
-        upath26[propName] = propValue;
+        upath32[propName] = propValue;
       }
     }
-    upath26.sep = "/";
+    upath32.sep = "/";
     extraFunctions = {
       toUnix,
       normalizeSafe: /* @__PURE__ */ __name(function(p) {
         var result;
         p = toUnix(p);
-        result = upath26.normalize(p);
+        result = upath32.normalize(p);
         if (p.startsWith("./") && !result.startsWith("./") && !result.startsWith("..")) {
           result = "./" + result;
         } else if (p.startsWith("//") && !result.startsWith("//")) {
@@ -6623,7 +6624,7 @@ var require_upath = __commonJS({
         return result;
       }, "normalizeSafe"),
       normalizeTrim: /* @__PURE__ */ __name(function(p) {
-        p = upath26.normalizeSafe(p);
+        p = upath32.normalizeSafe(p);
         if (p.endsWith("/")) {
           return p.slice(0, +(p.length - 2) + 1 || 9e9);
         } else {
@@ -6633,7 +6634,7 @@ var require_upath = __commonJS({
       joinSafe: /* @__PURE__ */ __name(function() {
         var p, p0, result;
         p = 1 <= arguments.length ? slice.call(arguments, 0) : [];
-        result = upath26.join.apply(null, p);
+        result = upath32.join.apply(null, p);
         if (p.length > 0) {
           p0 = toUnix(p[0]);
           if (p0.startsWith("./") && !result.startsWith("./") && !result.startsWith("..")) {
@@ -6663,7 +6664,7 @@ var require_upath = __commonJS({
         if (maxSize == null) {
           maxSize = 7;
         }
-        oldExt = upath26.extname(filename);
+        oldExt = upath32.extname(filename);
         if (isValidExt(oldExt, ignoreExts, maxSize)) {
           return filename.slice(0, +(filename.length - oldExt.length - 1) + 1 || 9e9);
         } else {
@@ -6675,8 +6676,8 @@ var require_upath = __commonJS({
           return filename;
         } else {
           ext2 = ext2[0] === "." ? ext2 : "." + ext2;
-          if (upath26.extname(filename) === ext2) {
-            return upath26.trimExt(filename, [], ext2.length);
+          if (upath32.extname(filename) === ext2) {
+            return upath32.trimExt(filename, [], ext2.length);
           } else {
             return filename;
           }
@@ -6686,18 +6687,18 @@ var require_upath = __commonJS({
         if (maxSize == null) {
           maxSize = 7;
         }
-        return upath26.trimExt(filename, ignoreExts, maxSize) + (!ext2 ? "" : ext2[0] === "." ? ext2 : "." + ext2);
+        return upath32.trimExt(filename, ignoreExts, maxSize) + (!ext2 ? "" : ext2[0] === "." ? ext2 : "." + ext2);
       }, "changeExt"),
       defaultExt: /* @__PURE__ */ __name(function(filename, ext2, ignoreExts, maxSize) {
         var oldExt;
         if (maxSize == null) {
           maxSize = 7;
         }
-        oldExt = upath26.extname(filename);
+        oldExt = upath32.extname(filename);
         if (isValidExt(oldExt, ignoreExts, maxSize)) {
           return filename;
         } else {
-          return upath26.addExt(filename, ext2);
+          return upath32.addExt(filename, ext2);
         }
       }, "defaultExt")
     };
@@ -6713,10 +6714,10 @@ var require_upath = __commonJS({
       if (!hasProp.call(extraFunctions, name))
         continue;
       extraFn = extraFunctions[name];
-      if (upath26[name] !== void 0) {
+      if (upath32[name] !== void 0) {
         throw new Error("path." + name + " already exists.");
       } else {
-        upath26[name] = extraFn;
+        upath32[name] = extraFn;
       }
     }
   }
@@ -6756,12 +6757,12 @@ var require_polyfills = __commonJS({
     "use strict";
     var constants = require("constants");
     var origCwd = process.cwd;
-    var cwd2 = null;
+    var cwd3 = null;
     var platform = process.env.GRACEFUL_FS_PLATFORM || process.platform;
     process.cwd = function() {
-      if (!cwd2)
-        cwd2 = origCwd.call(process);
-      return cwd2;
+      if (!cwd3)
+        cwd3 = origCwd.call(process);
+      return cwd3;
     };
     try {
       process.cwd();
@@ -6770,7 +6771,7 @@ var require_polyfills = __commonJS({
     if (typeof process.chdir === "function") {
       chdir = process.chdir;
       process.chdir = function(d) {
-        cwd2 = null;
+        cwd3 = null;
         chdir.call(process, d);
       };
       if (Object.setPrototypeOf) Object.setPrototypeOf(process.chdir, chdir);
@@ -19731,14 +19732,14 @@ m2: ${this.mapper2.__debugToString().split("\n").join("\n    ")}`;
           );
           const nodes = [];
           const edges = [];
-          const root = buildGraphNode(flowNode, /* @__PURE__ */ new Set());
+          const root2 = buildGraphNode(flowNode, /* @__PURE__ */ new Set());
           for (const node of nodes) {
             node.text = renderFlowNode(node.flowNode, node.circular);
             computeLevel(node);
           }
-          const height = computeHeight(root);
+          const height = computeHeight(root2);
           const columnWidths = computeColumnWidths(height);
-          computeLanes(root, 0);
+          computeLanes(root2, 0);
           return renderGraph();
           function isFlowSwitchClause(f) {
             return !!(f.flags & 128);
@@ -24663,10 +24664,10 @@ ${lanes.join("\n")}
       }
       __name(getAnyExtensionFromPath, "getAnyExtensionFromPath");
       function pathComponents(path7, rootLength) {
-        const root = path7.substring(0, rootLength);
+        const root2 = path7.substring(0, rootLength);
         const rest = path7.substring(rootLength).split(directorySeparator);
         if (rest.length && !lastOrUndefined(rest)) rest.pop();
-        return [root, ...rest];
+        return [root2, ...rest];
       }
       __name(pathComponents, "pathComponents");
       function getPathComponents(path7, currentDirectory = "") {
@@ -24676,8 +24677,8 @@ ${lanes.join("\n")}
       __name(getPathComponents, "getPathComponents");
       function getPathFromPathComponents(pathComponents2, length2) {
         if (pathComponents2.length === 0) return "";
-        const root = pathComponents2[0] && ensureTrailingDirectorySeparator(pathComponents2[0]);
-        return root + pathComponents2.slice(1, length2).join(directorySeparator);
+        const root2 = pathComponents2[0] && ensureTrailingDirectorySeparator(pathComponents2[0]);
+        return root2 + pathComponents2.slice(1, length2).join(directorySeparator);
       }
       __name(getPathFromPathComponents, "getPathFromPathComponents");
       function normalizeSlashes(path7) {
@@ -36051,8 +36052,8 @@ ${lanes.join("\n")}
       }
       __name(isPushOrUnshiftIdentifier, "isPushOrUnshiftIdentifier");
       function isPartOfParameterDeclaration(node) {
-        const root = getRootDeclaration(node);
-        return root.kind === 169;
+        const root2 = getRootDeclaration(node);
+        return root2.kind === 169;
       }
       __name(isPartOfParameterDeclaration, "isPartOfParameterDeclaration");
       function getRootDeclaration(node) {
@@ -38884,7 +38885,7 @@ ${lanes.join("\n")}
         return true;
       }
       __name(hasZeroOrOneAsteriskCharacter, "hasZeroOrOneAsteriskCharacter");
-      function createSymlinkCache(cwd2, getCanonicalFileName) {
+      function createSymlinkCache(cwd3, getCanonicalFileName) {
         let symlinkedDirectories;
         let symlinkedDirectoriesByRealpath;
         let symlinkedFiles;
@@ -38895,7 +38896,7 @@ ${lanes.join("\n")}
           getSymlinkedDirectoriesByRealpath: /* @__PURE__ */ __name(() => symlinkedDirectoriesByRealpath, "getSymlinkedDirectoriesByRealpath"),
           setSymlinkedFile: /* @__PURE__ */ __name((path7, real) => (symlinkedFiles || (symlinkedFiles = /* @__PURE__ */ new Map())).set(path7, real), "setSymlinkedFile"),
           setSymlinkedDirectory: /* @__PURE__ */ __name((symlink, real) => {
-            let symlinkPath = toPath2(symlink, cwd2, getCanonicalFileName);
+            let symlinkPath = toPath2(symlink, cwd3, getCanonicalFileName);
             if (!containsIgnoredPath(symlinkPath)) {
               symlinkPath = ensureTrailingDirectorySeparator(symlinkPath);
               if (real !== false && !(symlinkedDirectories == null ? void 0 : symlinkedDirectories.has(symlinkPath))) {
@@ -38924,14 +38925,14 @@ ${lanes.join("\n")}
         function processResolution(cache, resolution) {
           if (!resolution || !resolution.originalPath || !resolution.resolvedFileName) return;
           const { resolvedFileName, originalPath } = resolution;
-          cache.setSymlinkedFile(toPath2(originalPath, cwd2, getCanonicalFileName), resolvedFileName);
-          const [commonResolved, commonOriginal] = guessDirectorySymlink(resolvedFileName, originalPath, cwd2, getCanonicalFileName) || emptyArray;
+          cache.setSymlinkedFile(toPath2(originalPath, cwd3, getCanonicalFileName), resolvedFileName);
+          const [commonResolved, commonOriginal] = guessDirectorySymlink(resolvedFileName, originalPath, cwd3, getCanonicalFileName) || emptyArray;
           if (commonResolved && commonOriginal) {
             cache.setSymlinkedDirectory(
               commonOriginal,
               {
                 real: ensureTrailingDirectorySeparator(commonResolved),
-                realPath: ensureTrailingDirectorySeparator(toPath2(commonResolved, cwd2, getCanonicalFileName))
+                realPath: ensureTrailingDirectorySeparator(toPath2(commonResolved, cwd3, getCanonicalFileName))
               }
             );
           }
@@ -38939,9 +38940,9 @@ ${lanes.join("\n")}
         __name(processResolution, "processResolution");
       }
       __name(createSymlinkCache, "createSymlinkCache");
-      function guessDirectorySymlink(a, b, cwd2, getCanonicalFileName) {
-        const aParts = getPathComponents(getNormalizedAbsolutePath(a, cwd2));
-        const bParts = getPathComponents(getNormalizedAbsolutePath(b, cwd2));
+      function guessDirectorySymlink(a, b, cwd3, getCanonicalFileName) {
+        const aParts = getPathComponents(getNormalizedAbsolutePath(a, cwd3));
+        const bParts = getPathComponents(getNormalizedAbsolutePath(b, cwd3));
         let isDirectory = false;
         while (aParts.length >= 2 && bParts.length >= 2 && !isNodeModulesOrScopedPackageDirectory(aParts[aParts.length - 2], getCanonicalFileName) && !isNodeModulesOrScopedPackageDirectory(bParts[bParts.length - 2], getCanonicalFileName) && getCanonicalFileName(aParts[aParts.length - 1]) === getCanonicalFileName(bParts[bParts.length - 1])) {
           aParts.pop();
@@ -40544,9 +40545,9 @@ ${lanes.join("\n")}
                 case 338:
                 case 340:
                 case 351:
-                  const root = getJSDocRoot(location);
-                  if (root) {
-                    location = root.parent;
+                  const root2 = getJSDocRoot(location);
+                  if (root2) {
+                    location = root2.parent;
                   }
                   break;
                 case 169:
@@ -62720,16 +62721,16 @@ ${lanes.join("\n")}
           return void 0;
         }
         const result = parseJsonText(configFileName, configFileText);
-        const cwd2 = host.getCurrentDirectory();
-        result.path = toPath2(configFileName, cwd2, createGetCanonicalFileName(host.useCaseSensitiveFileNames));
+        const cwd3 = host.getCurrentDirectory();
+        result.path = toPath2(configFileName, cwd3, createGetCanonicalFileName(host.useCaseSensitiveFileNames));
         result.resolvedPath = result.path;
         result.originalFileName = result.fileName;
         return parseJsonSourceFileConfigFileContent(
           result,
           host,
-          getNormalizedAbsolutePath(getDirectoryPath(configFileName), cwd2),
+          getNormalizedAbsolutePath(getDirectoryPath(configFileName), cwd3),
           optionsToExtend,
-          getNormalizedAbsolutePath(configFileName, cwd2),
+          getNormalizedAbsolutePath(configFileName, cwd3),
           /*resolutionStack*/
           void 0,
           extraFileExtensions,
@@ -64977,11 +64978,11 @@ ${lanes.join("\n")}
         if (host.directoryExists && host.getDirectories) {
           const typeRoots = getEffectiveTypeRoots(options, host);
           if (typeRoots) {
-            for (const root of typeRoots) {
-              if (host.directoryExists(root)) {
-                for (const typeDirectivePath of host.getDirectories(root)) {
+            for (const root2 of typeRoots) {
+              if (host.directoryExists(root2)) {
+                for (const typeDirectivePath of host.getDirectories(root2)) {
                   const normalized = normalizePath(typeDirectivePath);
-                  const packageJsonPath = combinePaths(root, normalized, "package.json");
+                  const packageJsonPath = combinePaths(root2, normalized, "package.json");
                   const isNotNeededPackage = host.fileExists(packageJsonPath) && readJson2(packageJsonPath, host).typings === null;
                   if (!isNotNeededPackage) {
                     const baseFileName = getBaseFileName(normalized);
@@ -66808,8 +66809,8 @@ ${lanes.join("\n")}
             return getNormalizedAbsolutePath(path7, (_b = (_a = state.host).getCurrentDirectory) == null ? void 0 : _b.call(_a));
           }
           __name(toAbsolutePath, "toAbsolutePath");
-          function combineDirectoryPath(root, dir) {
-            return ensureTrailingDirectorySeparator(combinePaths(root, dir));
+          function combineDirectoryPath(root2, dir) {
+            return ensureTrailingDirectorySeparator(combinePaths(root2, dir));
           }
           __name(combineDirectoryPath, "combineDirectoryPath");
           function tryLoadInputFileForPath(finalPath, entry, packagePath, isImports2) {
@@ -71416,21 +71417,21 @@ ${lanes.join("\n")}
       function forEachFileNameOfModule(importingFileName, importedFileName, host, preferSymlinks, cb2) {
         var _a;
         const getCanonicalFileName = hostGetCanonicalFileName(host);
-        const cwd2 = host.getCurrentDirectory();
+        const cwd3 = host.getCurrentDirectory();
         const referenceRedirect = host.isSourceOfProjectReferenceRedirect(importedFileName) ? host.getProjectReferenceRedirect(importedFileName) : void 0;
-        const importedPath = toPath2(importedFileName, cwd2, getCanonicalFileName);
+        const importedPath = toPath2(importedFileName, cwd3, getCanonicalFileName);
         const redirects = host.redirectTargetsMap.get(importedPath) || emptyArray;
         const importedFileNames = [...referenceRedirect ? [referenceRedirect] : emptyArray, importedFileName, ...redirects];
-        const targets = importedFileNames.map((f) => getNormalizedAbsolutePath(f, cwd2));
+        const targets = importedFileNames.map((f) => getNormalizedAbsolutePath(f, cwd3));
         let shouldFilterIgnoredPaths = !every(targets, containsIgnoredPath);
         if (!preferSymlinks) {
           const result2 = forEach(targets, (p) => !(shouldFilterIgnoredPaths && containsIgnoredPath(p)) && cb2(p, referenceRedirect === p));
           if (result2) return result2;
         }
         const symlinkedDirectories = (_a = host.getSymlinkCache) == null ? void 0 : _a.call(host).getSymlinkedDirectoriesByRealpath();
-        const fullImportedFileName = getNormalizedAbsolutePath(importedFileName, cwd2);
+        const fullImportedFileName = getNormalizedAbsolutePath(importedFileName, cwd3);
         const result = symlinkedDirectories && forEachAncestorDirectory(getDirectoryPath(fullImportedFileName), (realPathDirectory) => {
-          const symlinkDirectories = symlinkedDirectories.get(ensureTrailingDirectorySeparator(toPath2(realPathDirectory, cwd2, getCanonicalFileName)));
+          const symlinkDirectories = symlinkedDirectories.get(ensureTrailingDirectorySeparator(toPath2(realPathDirectory, cwd3, getCanonicalFileName)));
           if (!symlinkDirectories) return void 0;
           if (startsWithDirectory(importingFileName, realPathDirectory, getCanonicalFileName)) {
             return false;
@@ -74089,10 +74090,10 @@ ${lanes.join("\n")}
             }
             if (associatedDeclarationForContainingInitializerOrBindingName && !withinDeferredContext && (meaning & 111551) === 111551) {
               const candidate = getMergedSymbol(getLateBoundSymbol(result));
-              const root = getRootDeclaration(associatedDeclarationForContainingInitializerOrBindingName);
+              const root2 = getRootDeclaration(associatedDeclarationForContainingInitializerOrBindingName);
               if (candidate === getSymbolOfDeclaration(associatedDeclarationForContainingInitializerOrBindingName)) {
                 error2(errorLocation, Diagnostics.Parameter_0_cannot_reference_itself, declarationNameToString(associatedDeclarationForContainingInitializerOrBindingName.name));
-              } else if (candidate.valueDeclaration && candidate.valueDeclaration.pos > associatedDeclarationForContainingInitializerOrBindingName.pos && root.parent.locals && getSymbol2(root.parent.locals, candidate.escapedName, meaning) === candidate) {
+              } else if (candidate.valueDeclaration && candidate.valueDeclaration.pos > associatedDeclarationForContainingInitializerOrBindingName.pos && root2.parent.locals && getSymbol2(root2.parent.locals, candidate.escapedName, meaning) === candidate) {
                 error2(errorLocation, Diagnostics.Parameter_0_cannot_reference_identifier_1_declared_after_it, declarationNameToString(associatedDeclarationForContainingInitializerOrBindingName.name), declarationNameToString(errorLocation));
               }
             }
@@ -74915,9 +74916,9 @@ ${lanes.join("\n")}
               return getTargetofModuleDefault(moduleSymbol, node, dontResolveAlias);
             }
           }
-          const root = isBindingElement(node) ? getRootDeclaration(node) : node.parent.parent.parent;
-          const commonJSPropertyAccess = getCommonJSPropertyAccess(root);
-          const resolved = getExternalModuleMember(root, commonJSPropertyAccess || node, dontResolveAlias);
+          const root2 = isBindingElement(node) ? getRootDeclaration(node) : node.parent.parent.parent;
+          const commonJSPropertyAccess = getCommonJSPropertyAccess(root2);
+          const resolved = getExternalModuleMember(root2, commonJSPropertyAccess || node, dontResolveAlias);
           const name = node.propertyName || node.name;
           if (commonJSPropertyAccess && resolved && isIdentifier(name)) {
             return resolveSymbol(getPropertyOfType(getTypeOfSymbol(resolved), name.escapedText), dontResolveAlias);
@@ -77813,10 +77814,10 @@ ${lanes.join("\n")}
               }
             }
             __name(typeReferenceToTypeNode, "typeReferenceToTypeNode");
-            function appendReferenceToType(root, ref) {
-              if (isImportTypeNode(root)) {
-                let typeArguments = root.typeArguments;
-                let qualifier = root.qualifier;
+            function appendReferenceToType(root2, ref) {
+              if (isImportTypeNode(root2)) {
+                let typeArguments = root2.typeArguments;
+                let qualifier = root2.qualifier;
                 if (qualifier) {
                   if (isIdentifier(qualifier)) {
                     if (typeArguments !== getIdentifierTypeArguments(qualifier)) {
@@ -77834,16 +77835,16 @@ ${lanes.join("\n")}
                   qualifier = qualifier ? factory.createQualifiedName(qualifier, id) : id;
                 }
                 return factory.updateImportTypeNode(
-                  root,
-                  root.argument,
-                  root.attributes,
+                  root2,
+                  root2.argument,
+                  root2.attributes,
                   qualifier,
                   typeArguments,
-                  root.isTypeOf
+                  root2.isTypeOf
                 );
               } else {
-                let typeArguments = root.typeArguments;
-                let typeName = root.typeName;
+                let typeArguments = root2.typeArguments;
+                let typeName = root2.typeName;
                 if (isIdentifier(typeName)) {
                   if (typeArguments !== getIdentifierTypeArguments(typeName)) {
                     typeName = setIdentifierTypeArguments(factory.cloneNode(typeName), typeArguments);
@@ -77859,7 +77860,7 @@ ${lanes.join("\n")}
                   typeName = factory.createQualifiedName(typeName, id);
                 }
                 return factory.updateTypeReferenceNode(
-                  root,
+                  root2,
                   typeName,
                   typeArguments
                 );
@@ -80076,10 +80077,10 @@ ${lanes.join("\n")}
                 if (accessibleResult.accessibility === 0) {
                   const chain = lookupSymbolChainWorker(sym, context, meaning);
                   if (!(sym.flags & 4)) {
-                    const root = chain[0];
+                    const root2 = chain[0];
                     const contextFile = getSourceFileOfNode(oldcontext.enclosingDeclaration);
-                    if (some(root.declarations, (d) => getSourceFileOfNode(d) === contextFile)) {
-                      includePrivateSymbol(root);
+                    if (some(root2.declarations, (d) => getSourceFileOfNode(d) === contextFile)) {
+                      includePrivateSymbol(root2);
                     }
                   }
                 } else if ((_b = oldcontext.tracker.inner) == null ? void 0 : _b.trackSymbol) {
@@ -83027,8 +83028,8 @@ ${lanes.join("\n")}
         }
         __name(widenTypeForVariableLikeDeclaration, "widenTypeForVariableLikeDeclaration");
         function declarationBelongsToPrivateAmbientMember(declaration) {
-          const root = getRootDeclaration(declaration);
-          const memberDeclaration = root.kind === 169 ? root.parent : root;
+          const root2 = getRootDeclaration(declaration);
+          const memberDeclaration = root2.kind === 169 ? root2.parent : root2;
           return isPrivateWithinAmbient(memberDeclaration);
         }
         __name(declarationBelongsToPrivateAmbientMember, "declarationBelongsToPrivateAmbientMember");
@@ -86648,9 +86649,9 @@ ${lanes.join("\n")}
           }
           const typeNode = getEffectiveReturnTypeNode(declaration);
           if (isJSDocSignature(declaration)) {
-            const root = getJSDocRoot(declaration);
-            if (root && isConstructorDeclaration(root.parent) && !typeNode) {
-              return getDeclaredTypeOfClassOrInterface(getMergedSymbol(root.parent.parent.symbol));
+            const root2 = getJSDocRoot(declaration);
+            if (root2 && isConstructorDeclaration(root2.parent) && !typeNode) {
+              return getDeclaredTypeOfClassOrInterface(getMergedSymbol(root2.parent.parent.symbol));
             }
           }
           if (isJSDocConstructSignature(declaration)) {
@@ -89728,7 +89729,7 @@ ${lanes.join("\n")}
           return isGenericType(type) || checkTuples && isTupleType(type) && some(getElementTypes(type), isGenericType);
         }
         __name(isDeferredType, "isDeferredType");
-        function getConditionalType(root, mapper, forConstraint, aliasSymbol, aliasTypeArguments) {
+        function getConditionalType(root2, mapper, forConstraint, aliasSymbol, aliasTypeArguments) {
           let result;
           let extraTypes;
           let tailCount = 0;
@@ -89737,22 +89738,22 @@ ${lanes.join("\n")}
               error2(currentNode, Diagnostics.Type_instantiation_is_excessively_deep_and_possibly_infinite);
               return errorType;
             }
-            const checkType = instantiateType(getActualTypeVariable(root.checkType), mapper);
-            const extendsType = instantiateType(root.extendsType, mapper);
+            const checkType = instantiateType(getActualTypeVariable(root2.checkType), mapper);
+            const extendsType = instantiateType(root2.extendsType, mapper);
             if (checkType === errorType || extendsType === errorType) {
               return errorType;
             }
             if (checkType === wildcardType || extendsType === wildcardType) {
               return wildcardType;
             }
-            const checkTypeNode = skipTypeParentheses(root.node.checkType);
-            const extendsTypeNode = skipTypeParentheses(root.node.extendsType);
+            const checkTypeNode = skipTypeParentheses(root2.node.checkType);
+            const extendsTypeNode = skipTypeParentheses(root2.node.extendsType);
             const checkTuples = isSimpleTupleType(checkTypeNode) && isSimpleTupleType(extendsTypeNode) && length(checkTypeNode.elements) === length(extendsTypeNode.elements);
             const checkTypeDeferred = isDeferredType(checkType, checkTuples);
             let combinedMapper;
-            if (root.inferTypeParameters) {
+            if (root2.inferTypeParameters) {
               const context = createInferenceContext(
-                root.inferTypeParameters,
+                root2.inferTypeParameters,
                 /*signature*/
                 void 0,
                 0
@@ -89772,17 +89773,17 @@ ${lanes.join("\n")}
               }
               combinedMapper = mapper ? combineTypeMappers(context.mapper, mapper) : context.mapper;
             }
-            const inferredExtendsType = combinedMapper ? instantiateType(root.extendsType, combinedMapper) : extendsType;
+            const inferredExtendsType = combinedMapper ? instantiateType(root2.extendsType, combinedMapper) : extendsType;
             if (!checkTypeDeferred && !isDeferredType(inferredExtendsType, checkTuples)) {
               if (!(inferredExtendsType.flags & 3) && (checkType.flags & 1 || !isTypeAssignableTo(getPermissiveInstantiation(checkType), getPermissiveInstantiation(inferredExtendsType)))) {
                 if (checkType.flags & 1 || forConstraint && !(inferredExtendsType.flags & 131072) && someType(getPermissiveInstantiation(inferredExtendsType), (t) => isTypeAssignableTo(t, getPermissiveInstantiation(checkType)))) {
-                  (extraTypes || (extraTypes = [])).push(instantiateType(getTypeFromTypeNode(root.node.trueType), combinedMapper || mapper));
+                  (extraTypes || (extraTypes = [])).push(instantiateType(getTypeFromTypeNode(root2.node.trueType), combinedMapper || mapper));
                 }
-                const falseType2 = getTypeFromTypeNode(root.node.falseType);
+                const falseType2 = getTypeFromTypeNode(root2.node.falseType);
                 if (falseType2.flags & 16777216) {
                   const newRoot = falseType2.root;
-                  if (newRoot.node.parent === root.node && (!newRoot.isDistributive || newRoot.checkType === root.checkType)) {
-                    root = newRoot;
+                  if (newRoot.node.parent === root2.node && (!newRoot.isDistributive || newRoot.checkType === root2.checkType)) {
+                    root2 = newRoot;
                     continue;
                   }
                   if (canTailRecurse(falseType2, mapper)) {
@@ -89793,7 +89794,7 @@ ${lanes.join("\n")}
                 break;
               }
               if (inferredExtendsType.flags & 3 || isTypeAssignableTo(getRestrictiveInstantiation(checkType), getRestrictiveInstantiation(inferredExtendsType))) {
-                const trueType2 = getTypeFromTypeNode(root.node.trueType);
+                const trueType2 = getTypeFromTypeNode(root2.node.trueType);
                 const trueMapper = combinedMapper || mapper;
                 if (canTailRecurse(trueType2, trueMapper)) {
                   continue;
@@ -89806,13 +89807,13 @@ ${lanes.join("\n")}
               16777216
               /* Conditional */
             );
-            result.root = root;
-            result.checkType = instantiateType(root.checkType, mapper);
-            result.extendsType = instantiateType(root.extendsType, mapper);
+            result.root = root2;
+            result.checkType = instantiateType(root2.checkType, mapper);
+            result.extendsType = instantiateType(root2.extendsType, mapper);
             result.mapper = mapper;
             result.combinedMapper = combinedMapper;
-            result.aliasSymbol = aliasSymbol || root.aliasSymbol;
-            result.aliasTypeArguments = aliasSymbol ? aliasTypeArguments : instantiateTypes(root.aliasTypeArguments, mapper);
+            result.aliasSymbol = aliasSymbol || root2.aliasSymbol;
+            result.aliasTypeArguments = aliasSymbol ? aliasTypeArguments : instantiateTypes(root2.aliasTypeArguments, mapper);
             break;
           }
           return extraTypes ? getUnionType(append(extraTypes, result)) : result;
@@ -89825,7 +89826,7 @@ ${lanes.join("\n")}
                 const newRootMapper = createTypeMapper(newRoot.outerTypeParameters, typeArguments);
                 const newCheckType = newRoot.isDistributive ? getMappedType(newRoot.checkType, newRootMapper) : void 0;
                 if (!newCheckType || newCheckType === newRoot.checkType || !(newCheckType.flags & (1048576 | 131072))) {
-                  root = newRoot;
+                  root2 = newRoot;
                   mapper = newRootMapper;
                   aliasSymbol = void 0;
                   aliasTypeArguments = void 0;
@@ -89865,8 +89866,8 @@ ${lanes.join("\n")}
           return result;
         }
         __name(getInferTypeParameters, "getInferTypeParameters");
-        function isDistributionDependent(root) {
-          return root.isDistributive && (isTypeParameterPossiblyReferenced(root.checkType, root.node.trueType) || isTypeParameterPossiblyReferenced(root.checkType, root.node.falseType));
+        function isDistributionDependent(root2) {
+          return root2.isDistributive && (isTypeParameterPossiblyReferenced(root2.checkType, root2.node.trueType) || isTypeParameterPossiblyReferenced(root2.checkType, root2.node.falseType));
         }
         __name(isDistributionDependent, "isDistributionDependent");
         function getTypeFromConditionalTypeNode(node) {
@@ -89881,7 +89882,7 @@ ${lanes.join("\n")}
               true
             );
             const outerTypeParameters = aliasTypeArguments ? allOuterTypeParameters : filter2(allOuterTypeParameters, (tp) => isTypeParameterPossiblyReferenced(tp, node));
-            const root = {
+            const root2 = {
               node,
               checkType,
               extendsType: getTypeFromTypeNode(node.extendsType),
@@ -89893,15 +89894,15 @@ ${lanes.join("\n")}
               aliasTypeArguments
             };
             links.resolvedType = getConditionalType(
-              root,
+              root2,
               /*mapper*/
               void 0,
               /*forConstraint*/
               false
             );
             if (outerTypeParameters) {
-              root.instantiations = /* @__PURE__ */ new Map();
-              root.instantiations.set(getTypeListId(outerTypeParameters), links.resolvedType);
+              root2.instantiations = /* @__PURE__ */ new Map();
+              root2.instantiations.set(getTypeListId(outerTypeParameters), links.resolvedType);
             }
           }
           return links.resolvedType;
@@ -90844,17 +90845,17 @@ ${lanes.join("\n")}
         }
         __name(instantiateAnonymousType, "instantiateAnonymousType");
         function getConditionalTypeInstantiation(type, mapper, forConstraint, aliasSymbol, aliasTypeArguments) {
-          const root = type.root;
-          if (root.outerTypeParameters) {
-            const typeArguments = map3(root.outerTypeParameters, (t) => getMappedType(t, mapper));
+          const root2 = type.root;
+          if (root2.outerTypeParameters) {
+            const typeArguments = map3(root2.outerTypeParameters, (t) => getMappedType(t, mapper));
             const id = (forConstraint ? "C" : "") + getTypeListId(typeArguments) + getAliasId(aliasSymbol, aliasTypeArguments);
-            let result = root.instantiations.get(id);
+            let result = root2.instantiations.get(id);
             if (!result) {
-              const newMapper = createTypeMapper(root.outerTypeParameters, typeArguments);
-              const checkType = root.checkType;
-              const distributionType = root.isDistributive ? getReducedType(getMappedType(checkType, newMapper)) : void 0;
-              result = distributionType && checkType !== distributionType && distributionType.flags & (1048576 | 131072) ? mapTypeWithAlias(distributionType, (t) => getConditionalType(root, prependTypeMapping(checkType, t, newMapper), forConstraint), aliasSymbol, aliasTypeArguments) : getConditionalType(root, newMapper, forConstraint, aliasSymbol, aliasTypeArguments);
-              root.instantiations.set(id, result);
+              const newMapper = createTypeMapper(root2.outerTypeParameters, typeArguments);
+              const checkType = root2.checkType;
+              const distributionType = root2.isDistributive ? getReducedType(getMappedType(checkType, newMapper)) : void 0;
+              result = distributionType && checkType !== distributionType && distributionType.flags & (1048576 | 131072) ? mapTypeWithAlias(distributionType, (t) => getConditionalType(root2, prependTypeMapping(checkType, t, newMapper), forConstraint), aliasSymbol, aliasTypeArguments) : getConditionalType(root2, newMapper, forConstraint, aliasSymbol, aliasTypeArguments);
+              root2.instantiations.set(id, result);
             }
             return result;
           }
@@ -97962,10 +97963,10 @@ ${lanes.join("\n")}
         }
         __name(isEvolvingArrayTypeList, "isEvolvingArrayTypeList");
         function isEvolvingArrayOperationTarget(node) {
-          const root = getReferenceRoot(node);
-          const parent2 = root.parent;
+          const root2 = getReferenceRoot(node);
+          const parent2 = root2.parent;
           const isLengthPushOrUnshift = isPropertyAccessExpression(parent2) && (parent2.name.escapedText === "length" || parent2.parent.kind === 213 && isIdentifier(parent2.name) && isPushOrUnshiftIdentifier(parent2.name));
-          const isElementAssignment = parent2.kind === 212 && parent2.expression === root && parent2.parent.kind === 226 && parent2.parent.operatorToken.kind === 64 && parent2.parent.left === parent2 && !isAssignmentTarget(parent2.parent) && isTypeAssignableToKind(
+          const isElementAssignment = parent2.kind === 212 && parent2.expression === root2 && parent2.parent.kind === 226 && parent2.parent.operatorToken.kind === 64 && parent2.parent.left === parent2 && !isAssignmentTarget(parent2.parent) && isTypeAssignableToKind(
             getTypeOfExpression(parent2.argumentExpression),
             296
             /* NumberLike */
@@ -112433,8 +112434,8 @@ ${lanes.join("\n")}
               return false;
             }
           }
-          const root = getRootDeclaration(node);
-          if (isParameter(root) && nodeIsMissing(root.parent.body)) {
+          const root2 = getRootDeclaration(node);
+          if (isParameter(root2) && nodeIsMissing(root2.parent.body)) {
             return false;
           }
           return true;
@@ -114114,8 +114115,8 @@ ${lanes.join("\n")}
           __name(createCheckTypeParameterDiagnostic, "createCheckTypeParameterDiagnostic");
         }
         __name(checkTypeParameters, "checkTypeParameters");
-        function checkTypeParametersNotReferenced(root, typeParameters, index) {
-          visit(root);
+        function checkTypeParametersNotReferenced(root2, typeParameters, index) {
+          visit(root2);
           function visit(node) {
             if (node.kind === 183) {
               const type = getTypeFromTypeReference(node);
@@ -115044,10 +115045,10 @@ ${lanes.join("\n")}
         }
         __name(evaluateEntityNameExpression, "evaluateEntityNameExpression");
         function evaluateElementAccessExpression(expr, location) {
-          const root = expr.expression;
-          if (isEntityNameExpression(root) && isStringLiteralLike(expr.argumentExpression)) {
+          const root2 = expr.expression;
+          if (isEntityNameExpression(root2) && isStringLiteralLike(expr.argumentExpression)) {
             const rootSymbol = resolveEntityName(
-              root,
+              root2,
               111551,
               /*ignoreErrors*/
               true
@@ -117518,11 +117519,11 @@ ${lanes.join("\n")}
             default:
               return Debug.assertNever(flag, `Unhandled node check flag calculation: ${Debug.formatNodeCheckFlags(flag)}`);
           }
-          function forEachNodeRecursively(root, cb2) {
-            const rootResult = cb2(root, root.parent);
+          function forEachNodeRecursively(root2, cb2) {
+            const rootResult = cb2(root2, root2.parent);
             if (rootResult === "skip") return void 0;
             if (rootResult) return rootResult;
-            return forEachChildRecursively(root, cb2);
+            return forEachChildRecursively(root2, cb2);
           }
           __name(forEachNodeRecursively, "forEachNodeRecursively");
           function checkSuperExpressions(node2) {
@@ -159464,9 +159465,9 @@ ${lanes.join("\n")}
       function parseConfigHostFromCompilerHostLike(host, directoryStructureHost = host) {
         return {
           fileExists: /* @__PURE__ */ __name((f) => directoryStructureHost.fileExists(f), "fileExists"),
-          readDirectory(root, extensions, excludes, includes, depth) {
+          readDirectory(root2, extensions, excludes, includes, depth) {
             Debug.assertIsDefined(directoryStructureHost.readDirectory, "'CompilerHost.readDirectory' must be implemented to correctly process 'projectReferences'");
-            return directoryStructureHost.readDirectory(root, extensions, excludes, includes, depth);
+            return directoryStructureHost.readDirectory(root2, extensions, excludes, includes, depth);
           },
           readFile: /* @__PURE__ */ __name((f) => directoryStructureHost.readFile(f), "readFile"),
           directoryExists: maybeBind(directoryStructureHost, directoryStructureHost.directoryExists),
@@ -160520,7 +160521,7 @@ ${lanes.join("\n")}
         const fileNames = [];
         const fileNameToFileId = /* @__PURE__ */ new Map();
         const rootFileNames = new Set(state.program.getRootFileNames().map((f) => toPath2(f, currentDirectory, state.program.getCanonicalFileName)));
-        const root = [];
+        const root2 = [];
         if (state.compilerOptions.outFile) {
           const fileInfos2 = arrayFrom(state.fileInfos.entries(), ([key, value]) => {
             const fileId = toFileId(key);
@@ -160530,7 +160531,7 @@ ${lanes.join("\n")}
           const program22 = {
             fileNames,
             fileInfos: fileInfos2,
-            root,
+            root: root2,
             resolvedRoot: toResolvedRoot(),
             options: convertToProgramBuildInfoCompilerOptions(state.compilerOptions),
             outSignature: state.outSignature,
@@ -160633,7 +160634,7 @@ ${lanes.join("\n")}
         const program2 = {
           fileNames,
           fileInfos,
-          root,
+          root: root2,
           resolvedRoot: toResolvedRoot(),
           options: convertToProgramBuildInfoCompilerOptions(state.compilerOptions),
           fileIdsList,
@@ -160680,15 +160681,15 @@ ${lanes.join("\n")}
             (r) => r.kind === 0
             /* RootFile */
           )) return;
-          if (!root.length) return root.push(fileId);
-          const last2 = root[root.length - 1];
+          if (!root2.length) return root2.push(fileId);
+          const last2 = root2[root2.length - 1];
           const isLastStartEnd = isArray(last2);
           if (isLastStartEnd && last2[1] === fileId - 1) return last2[1] = fileId;
-          if (isLastStartEnd || root.length === 1 || last2 !== fileId - 1) return root.push(fileId);
-          const lastButOne = root[root.length - 2];
-          if (!isNumber(lastButOne) || lastButOne !== last2 - 1) return root.push(fileId);
-          root[root.length - 2] = [lastButOne, fileId];
-          return root.length = root.length - 1;
+          if (isLastStartEnd || root2.length === 1 || last2 !== fileId - 1) return root2.push(fileId);
+          const lastButOne = root2[root2.length - 2];
+          if (!isNumber(lastButOne) || lastButOne !== last2 - 1) return root2.push(fileId);
+          root2[root2.length - 2] = [lastButOne, fileId];
+          return root2.length = root2.length - 1;
         }
         __name(tryAddRoot, "tryAddRoot");
         function toResolvedRoot() {
@@ -161320,9 +161321,9 @@ ${lanes.join("\n")}
         });
         return { fileInfos, roots };
         function addRoot(fileId, path7) {
-          const root = resolvedRoots.get(fileId);
-          if (root) {
-            roots.set(toPath2(program2.fileNames[root - 1], buildInfoDirectory, getCanonicalFileName), path7);
+          const root2 = resolvedRoots.get(fileId);
+          if (root2) {
+            roots.set(toPath2(program2.fileNames[root2 - 1], buildInfoDirectory, getCanonicalFileName), path7);
           } else {
             roots.set(path7, void 0);
           }
@@ -162697,15 +162698,15 @@ ${lanes.join("\n")}
         return errorCount === 1 ? Diagnostics.Found_1_error_Watching_for_file_changes : Diagnostics.Found_0_errors_Watching_for_file_changes;
       }
       __name(getWatchErrorSummaryDiagnosticMessage, "getWatchErrorSummaryDiagnosticMessage");
-      function prettyPathForFileError(error2, cwd2) {
+      function prettyPathForFileError(error2, cwd3) {
         const line = formatColorAndReset(
           ":" + error2.line,
           "\x1B[90m"
           /* Grey */
         );
-        if (pathIsAbsolute(error2.fileName) && pathIsAbsolute(cwd2)) {
+        if (pathIsAbsolute(error2.fileName) && pathIsAbsolute(cwd3)) {
           return getRelativePathFromDirectory(
-            cwd2,
+            cwd3,
             error2.fileName,
             /*ignoreCase*/
             false
@@ -164371,8 +164372,8 @@ ${lanes.join("\n")}
         const circularityReportStack = [];
         let buildOrder;
         let circularDiagnostics;
-        for (const root of roots) {
-          visit(root);
+        for (const root2 of roots) {
+          visit(root2);
         }
         return circularDiagnostics ? { buildOrder: buildOrder || emptyArray, circularDiagnostics } : buildOrder || emptyArray;
         function visit(configFileName, inCircularContext) {
@@ -168595,29 +168596,29 @@ ${lanes.join("\n")}
       }
       __name(isNamespaceReference, "isNamespaceReference");
       function isQualifiedNameNamespaceReference(node) {
-        let root = node;
+        let root2 = node;
         let isLastClause = true;
-        if (root.parent.kind === 166) {
-          while (root.parent && root.parent.kind === 166) {
-            root = root.parent;
+        if (root2.parent.kind === 166) {
+          while (root2.parent && root2.parent.kind === 166) {
+            root2 = root2.parent;
           }
-          isLastClause = root.right === node;
+          isLastClause = root2.right === node;
         }
-        return root.parent.kind === 183 && !isLastClause;
+        return root2.parent.kind === 183 && !isLastClause;
       }
       __name(isQualifiedNameNamespaceReference, "isQualifiedNameNamespaceReference");
       function isPropertyAccessNamespaceReference(node) {
-        let root = node;
+        let root2 = node;
         let isLastClause = true;
-        if (root.parent.kind === 211) {
-          while (root.parent && root.parent.kind === 211) {
-            root = root.parent;
+        if (root2.parent.kind === 211) {
+          while (root2.parent && root2.parent.kind === 211) {
+            root2 = root2.parent;
           }
-          isLastClause = root.name === node;
+          isLastClause = root2.name === node;
         }
-        if (!isLastClause && root.parent.kind === 233 && root.parent.parent.kind === 298) {
-          const decl = root.parent.parent.parent;
-          return decl.kind === 263 && root.parent.parent.token === 119 || decl.kind === 264 && root.parent.parent.token === 96;
+        if (!isLastClause && root2.parent.kind === 233 && root2.parent.parent.kind === 298) {
+          const decl = root2.parent.parent.parent;
+          return decl.kind === 263 && root2.parent.parent.token === 119 || decl.kind === 264 && root2.parent.parent.token === 96;
         }
         return false;
       }
@@ -175581,14 +175582,14 @@ interface Symbol {
       __name(pushChild, "pushChild");
       function rootNavigationBarNode(sourceFile) {
         Debug.assert(!parentsStack.length);
-        const root = { node: sourceFile, name: void 0, additionalNodes: void 0, parent: void 0, children: void 0, indent: 0 };
-        parent = root;
+        const root2 = { node: sourceFile, name: void 0, additionalNodes: void 0, parent: void 0, children: void 0, indent: 0 };
+        parent = root2;
         for (const statement of sourceFile.statements) {
           addChildrenRecursively(statement);
         }
         endNode();
         Debug.assert(!parent && !parentsStack.length);
-        return root;
+        return root2;
       }
       __name(rootNavigationBarNode, "rootNavigationBarNode");
       function addLeafNode(node, name) {
@@ -176162,7 +176163,7 @@ interface Symbol {
         }
       }
       __name(getItemName, "getItemName");
-      function primaryNavBarMenuItems(root) {
+      function primaryNavBarMenuItems(root2) {
         const primaryNavBarMenuItems2 = [];
         function recur(item) {
           if (shouldAppearInPrimaryNavBarMenu(item)) {
@@ -176175,7 +176176,7 @@ interface Symbol {
           }
         }
         __name(recur, "recur");
-        recur(root);
+        recur(root2);
         return primaryNavBarMenuItems2;
         function shouldAppearInPrimaryNavBarMenu(item) {
           if (item.children) {
@@ -202990,12 +202991,12 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
       function getCompletionEntriesFromTypings(host, options, scriptPath, fragmentDirectory, extensionOptions, result = createNameAndKindSet()) {
         const seen = /* @__PURE__ */ new Map();
         const typeRoots = tryAndIgnoreErrors(() => getEffectiveTypeRoots(options, host)) || emptyArray;
-        for (const root of typeRoots) {
-          getCompletionEntriesFromDirectories(root);
+        for (const root2 of typeRoots) {
+          getCompletionEntriesFromDirectories(root2);
         }
         if (getPnpApi(scriptPath)) {
-          for (const root of getPnpTypeRoots(scriptPath)) {
-            getCompletionEntriesFromDirectories(root);
+          for (const root2 of getPnpTypeRoots(scriptPath)) {
+            getCompletionEntriesFromDirectories(root2);
           }
         } else {
           for (const packageJson2 of findPackageJsons(scriptPath, host)) {
@@ -205554,13 +205555,13 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
             checker,
             isForRename,
             !(isForRename && providePrefixAndSuffixText),
-            (sym, root, base) => {
+            (sym, root2, base) => {
               if (base) {
                 if (isStaticSymbol(symbol) !== isStaticSymbol(base)) {
                   base = void 0;
                 }
               }
-              result.push(base || root || sym);
+              result.push(base || root2 || sym);
             },
             // when try to find implementation, implementations is true, and not allowed to find base class
             /*allowBaseTypes*/
@@ -219146,13 +219147,13 @@ ${options.prefix}` : "\n" : options.prefix
         /** @internal */
         installPackage(req) {
           const { fileName, packageName, projectName, projectRootPath, id } = req;
-          const cwd2 = forEachAncestorDirectory(getDirectoryPath(fileName), (directory) => {
+          const cwd3 = forEachAncestorDirectory(getDirectoryPath(fileName), (directory) => {
             if (this.installTypingHost.fileExists(combinePaths(directory, "package.json"))) {
               return directory;
             }
           }) || projectRootPath;
-          if (cwd2) {
-            this.installWorker(-1, [packageName], cwd2, (success) => {
+          if (cwd3) {
+            this.installWorker(-1, [packageName], cwd3, (success) => {
               const message = success ? `Package ${packageName} installed.` : `There was an error installing ${packageName}.`;
               const response = {
                 kind: ActionPackageInstalled,
@@ -219385,8 +219386,8 @@ ${options.prefix}` : "\n" : options.prefix
             kind: ActionSet
           };
         }
-        installTypingsAsync(requestId, packageNames, cwd2, onRequestCompleted) {
-          this.pendingRunRequests.unshift({ requestId, packageNames, cwd: cwd2, onRequestCompleted });
+        installTypingsAsync(requestId, packageNames, cwd3, onRequestCompleted) {
+          this.pendingRunRequests.unshift({ requestId, packageNames, cwd: cwd3, onRequestCompleted });
           this.executeWithThrottling();
         }
         executeWithThrottling() {
@@ -221059,9 +221060,9 @@ ${options.prefix}` : "\n" : options.prefix
           this.closeWatchingTypingLocations();
           this.cleanupProgram();
           forEach(this.externalFiles, (externalFile) => this.detachScriptInfoIfNotRoot(externalFile));
-          this.rootFilesMap.forEach((root) => {
+          this.rootFilesMap.forEach((root2) => {
             var _a2;
-            return (_a2 = root.info) == null ? void 0 : _a2.detachFromProject(this);
+            return (_a2 = root2.info) == null ? void 0 : _a2.detachFromProject(this);
           });
           this.projectService.pendingEnsureProjectForOpenFiles = true;
           this.rootFilesMap = void 0;
@@ -226119,9 +226120,9 @@ Dynamic files must always be opened with service's current directory or service
           const normalizedNames = rootFiles.map((f) => normalizeSlashes(f.fileName));
           for (const name of Object.keys(this.safelist)) {
             const rule2 = this.safelist[name];
-            for (const root of normalizedNames) {
-              if (rule2.match.test(root)) {
-                this.logger.info(`Excluding files based on rule ${name} matching file '${root}'`);
+            for (const root2 of normalizedNames) {
+              if (rule2.match.test(root2)) {
+                this.logger.info(`Excluding files based on rule ${name} matching file '${root2}'`);
                 if (rule2.types) {
                   for (const type of rule2.types) {
                     if (!typeAcqInclude.includes(type)) {
@@ -226131,7 +226132,7 @@ Dynamic files must always be opened with service's current directory or service
                 }
                 if (rule2.exclude) {
                   for (const exclude of rule2.exclude) {
-                    const processedRule = root.replace(rule2.match, (...groups) => {
+                    const processedRule = root2.replace(rule2.match, (...groups) => {
                       return exclude.map((groupNumberOrString) => {
                         if (typeof groupNumberOrString === "number") {
                           if (!isString(groups[groupNumberOrString])) {
@@ -226148,7 +226149,7 @@ Dynamic files must always be opened with service's current directory or service
                     }
                   }
                 } else {
-                  const escaped = _ProjectService2.escapeFilenameForRegex(root);
+                  const escaped = _ProjectService2.escapeFilenameForRegex(root2);
                   if (!excludeRules.includes(escaped)) {
                     excludeRules.push(escaped);
                   }
@@ -233872,7 +233873,7 @@ var {
 } = import_index.default;
 
 // src/core/version.ts
-var version_default = `1.0.0`;
+var version_default = `1.0.1`;
 
 // src/core/description.ts
 var description_default = `Development utilities for the monorepo.`;
@@ -239653,9 +239654,9 @@ var ValueMutateError = class extends TypeBoxError {
     super(message);
   }
 };
-function ObjectType5(root, path7, current, next) {
+function ObjectType5(root2, path7, current, next) {
   if (!IsStandardObject2(current)) {
-    pointer_exports.Set(root, path7, Clone2(next));
+    pointer_exports.Set(root2, path7, Clone2(next));
   } else {
     const currentKeys = Object.getOwnPropertyNames(current);
     const nextKeys = Object.getOwnPropertyNames(next);
@@ -239670,47 +239671,47 @@ function ObjectType5(root, path7, current, next) {
       }
     }
     for (const nextKey of nextKeys) {
-      Visit16(root, `${path7}/${nextKey}`, current[nextKey], next[nextKey]);
+      Visit16(root2, `${path7}/${nextKey}`, current[nextKey], next[nextKey]);
     }
   }
 }
 __name(ObjectType5, "ObjectType");
-function ArrayType5(root, path7, current, next) {
+function ArrayType5(root2, path7, current, next) {
   if (!IsArray(current)) {
-    pointer_exports.Set(root, path7, Clone2(next));
+    pointer_exports.Set(root2, path7, Clone2(next));
   } else {
     for (let index = 0; index < next.length; index++) {
-      Visit16(root, `${path7}/${index}`, current[index], next[index]);
+      Visit16(root2, `${path7}/${index}`, current[index], next[index]);
     }
     current.splice(next.length);
   }
 }
 __name(ArrayType5, "ArrayType");
-function TypedArrayType3(root, path7, current, next) {
+function TypedArrayType3(root2, path7, current, next) {
   if (IsTypedArray(current) && current.length === next.length) {
     for (let i = 0; i < current.length; i++) {
       current[i] = next[i];
     }
   } else {
-    pointer_exports.Set(root, path7, Clone2(next));
+    pointer_exports.Set(root2, path7, Clone2(next));
   }
 }
 __name(TypedArrayType3, "TypedArrayType");
-function ValueType3(root, path7, current, next) {
+function ValueType3(root2, path7, current, next) {
   if (current === next)
     return;
-  pointer_exports.Set(root, path7, next);
+  pointer_exports.Set(root2, path7, next);
 }
 __name(ValueType3, "ValueType");
-function Visit16(root, path7, current, next) {
+function Visit16(root2, path7, current, next) {
   if (IsArray(next))
-    return ArrayType5(root, path7, current, next);
+    return ArrayType5(root2, path7, current, next);
   if (IsTypedArray(next))
-    return TypedArrayType3(root, path7, current, next);
+    return TypedArrayType3(root2, path7, current, next);
   if (IsStandardObject2(next))
-    return ObjectType5(root, path7, current, next);
+    return ObjectType5(root2, path7, current, next);
   if (IsValueType(next))
-    return ValueType3(root, path7, current, next);
+    return ValueType3(root2, path7, current, next);
 }
 __name(Visit16, "Visit");
 function IsNonMutableValue(value) {
@@ -239961,12 +239962,12 @@ function FromProperties8(value) {
   return Acc;
 }
 __name(FromProperties8, "FromProperties");
-function ConditionalReadonly(T, root) {
-  return root === true ? T : Readonly(T);
+function ConditionalReadonly(T, root2) {
+  return root2 === true ? T : Readonly(T);
 }
 __name(ConditionalReadonly, "ConditionalReadonly");
-function FromValue2(value, root) {
-  return IsAsyncIterator2(value) ? ConditionalReadonly(Any(), root) : IsIterator2(value) ? ConditionalReadonly(Any(), root) : IsArray2(value) ? Readonly(Tuple(FromArray15(value))) : IsUint8Array2(value) ? Uint8Array2() : IsDate2(value) ? Date2() : IsObject2(value) ? ConditionalReadonly(Object2(FromProperties8(value)), root) : IsFunction2(value) ? ConditionalReadonly(Function2([], Unknown()), root) : IsUndefined2(value) ? Undefined() : IsNull2(value) ? Null() : IsSymbol2(value) ? Symbol2() : IsBigInt2(value) ? BigInt2() : IsNumber2(value) ? Literal(value) : IsBoolean2(value) ? Literal(value) : IsString2(value) ? Literal(value) : Object2({});
+function FromValue2(value, root2) {
+  return IsAsyncIterator2(value) ? ConditionalReadonly(Any(), root2) : IsIterator2(value) ? ConditionalReadonly(Any(), root2) : IsArray2(value) ? Readonly(Tuple(FromArray15(value))) : IsUint8Array2(value) ? Uint8Array2() : IsDate2(value) ? Date2() : IsObject2(value) ? ConditionalReadonly(Object2(FromProperties8(value)), root2) : IsFunction2(value) ? ConditionalReadonly(Function2([], Unknown()), root2) : IsUndefined2(value) ? Undefined() : IsNull2(value) ? Null() : IsSymbol2(value) ? Symbol2() : IsBigInt2(value) ? BigInt2() : IsNumber2(value) ? Literal(value) : IsBoolean2(value) ? Literal(value) : IsString2(value) ? Literal(value) : Object2({});
 }
 __name(FromValue2, "FromValue");
 function Const(T, options) {
@@ -241465,7 +241466,7 @@ var esm_default = {
 };
 
 // ../../libs/monorepo/src/MonoRepo.ts
-var import_upath11 = __toESM(require_upath(), 1);
+var import_upath16 = __toESM(require_upath(), 1);
 
 // ../../libs/composition/src/View.ts
 var TARGET_SYMBOL = Symbol("target");
@@ -244343,7 +244344,7 @@ __name(createLazyPropDecorator, "createLazyPropDecorator");
 // ../../libs/monorepo/src/repo/Workspace.ts
 var import_node_child_process2 = require("node:child_process");
 var import_node_util5 = require("node:util");
-var import_upath10 = __toESM(require_upath(), 1);
+var import_upath15 = __toESM(require_upath(), 1);
 
 // ../../node_modules/es-toolkit/dist/promise/semaphore.mjs
 var Semaphore = class {
@@ -244428,7 +244429,67 @@ __name(countUniques, "countUniques");
 
 // ../../libs/monorepo/src/file/File.ts
 var import_node_fs = __toESM(require("node:fs"), 1);
+
+// ../../libs/path/src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  cwd: () => cwd,
+  default: () => src_default,
+  dirnameDeep: () => dirnameDeep,
+  hasBasename: () => hasBasename,
+  hasExtname: () => hasExtname,
+  hasParentDirname: () => hasParentDirname,
+  isDotFile: () => isDotFile,
+  isExtValid: () => isExtValid,
+  isRelative: () => isRelative,
+  isUnc: () => isUnc,
+  isValidWin32: () => isValidWin32,
+  prefixFilename: () => prefixFilename,
+  root: () => root,
+  suffixFilename: () => suffixFilename,
+  toCwdRelative: () => toCwdRelative,
+  toWin32: () => toWin32
+});
+
+// ../../libs/path/src/lib/cwd.ts
+var cwd_exports = {};
+__export(cwd_exports, {
+  cwd: () => cwd
+});
+var import_upath5 = __toESM(require_upath(), 1);
+function cwd(...p) {
+  return import_upath5.default.joinSafe(process.cwd(), ...p);
+}
+__name(cwd, "cwd");
+
+// ../../libs/path/src/lib/dirnameDeep.ts
+var dirnameDeep_exports = {};
+__export(dirnameDeep_exports, {
+  dirnameDeep: () => dirnameDeep
+});
 var import_upath6 = __toESM(require_upath(), 1);
+function dirnameDeep(p, depth) {
+  const parent = import_upath6.default.dirname(p);
+  return depth && depth > 1 ? dirnameDeep(parent, depth - 1) : parent;
+}
+__name(dirnameDeep, "dirnameDeep");
+
+// ../../libs/path/src/lib/hasBasename.ts
+var hasBasename_exports = {};
+__export(hasBasename_exports, {
+  hasBasename: () => hasBasename
+});
+var import_upath7 = __toESM(require_upath(), 1);
+function hasBasename(tsFilepath, basenames) {
+  return [basenames].flat(2).includes(import_upath7.default.basename(tsFilepath));
+}
+__name(hasBasename, "hasBasename");
+
+// ../../libs/path/src/lib/hasExtname.ts
+var hasExtname_exports = {};
+__export(hasExtname_exports, {
+  hasExtname: () => hasExtname
+});
 
 // ../../libs/fn/src/preserveNameAndLength.ts
 function preserveNameAndLength(source, target, adjustLengthBy = 0) {
@@ -244464,18 +244525,156 @@ hasExtname.markdown = bindArg(hasExtname, 1, ["md", "markdown"]);
 hasExtname.ts = bindArg(hasExtname, 1, ["ts", "mts", "tsx"]);
 
 // ../../libs/path/src/lib/hasParentDirname.ts
+var hasParentDirname_exports = {};
+__export(hasParentDirname_exports, {
+  hasParentDirname: () => hasParentDirname
+});
 function hasParentDirname(fspath, name) {
   return new RegExp("(^|[/\\\\])" + name + "[/\\\\]").test(fspath);
 }
 __name(hasParentDirname, "hasParentDirname");
 
+// ../../libs/path/src/lib/isDotFile.ts
+var isDotFile_exports = {};
+__export(isDotFile_exports, {
+  isDotFile: () => isDotFile
+});
+function isDotFile(filepath) {
+  return /(?:^|[\\/])(\.(?!\.)[^\\/]+)$/.test(filepath);
+}
+__name(isDotFile, "isDotFile");
+
+// ../../libs/path/src/lib/isExtValid.ts
+var isExtValid_exports = {};
+__export(isExtValid_exports, {
+  isExtValid: () => isExtValid
+});
+function isExtValid(ext2) {
+  return !!ext2 && ext2 !== "." && !/[<>"|?*:]/.test(ext2);
+}
+__name(isExtValid, "isExtValid");
+
+// ../../libs/path/src/lib/isRelative.ts
+var isRelative_exports = {};
+__export(isRelative_exports, {
+  isRelative: () => isRelative
+});
+var import_node_path2 = __toESM(require("node:path"), 1);
+function isRelative(p) {
+  return !import_node_path2.default.isAbsolute(p);
+}
+__name(isRelative, "isRelative");
+
+// ../../libs/path/src/lib/isUnc.ts
+var isUnc_exports = {};
+__export(isUnc_exports, {
+  isUnc: () => isUnc
+});
+function isUnc(filepath) {
+  return /^[\\/]{2,}[^\\/]+[\\/]+[^\\/]+/.test(filepath);
+}
+__name(isUnc, "isUnc");
+
+// ../../libs/path/src/lib/isValidWin32.ts
+var isValidWin32_exports = {};
+__export(isValidWin32_exports, {
+  isValidWin32: () => isValidWin32
+});
+function isValidWin32(path7, options) {
+  if (path7.length === 0) return false;
+  if (path7.indexOf("/") !== -1 && path7.indexOf("\\") !== -1) return false;
+  const maxLength = (options && options.extendedMaxLength ? 32767 : 260) - 12;
+  if (path7.length > maxLength) return false;
+  const noDriveLetter = /^\w:(\\|\/)/g.test(path7) ? path7.substring(2) : path7;
+  if (/[<>"|?*:]/g.test(noDriveLetter)) return false;
+  if (/(\\|\/)(CON|PRN|AUX|NUL|COM[1-9]|LPT[1-9])((\\|\/)|$)/g.test(path7)) return false;
+  return true;
+}
+__name(isValidWin32, "isValidWin32");
+
+// ../../libs/path/src/lib/prefixFilename.ts
+var prefixFilename_exports = {};
+__export(prefixFilename_exports, {
+  prefixFilename: () => prefixFilename
+});
+var import_upath8 = __toESM(require_upath(), 1);
+function prefixFilename(filePath, prefix) {
+  const ext2 = import_upath8.default.extname(filePath);
+  const fileNameWithoutExt = import_upath8.default.basename(filePath, ext2);
+  return import_upath8.default.joinSafe(import_upath8.default.dirname(filePath), prefix + fileNameWithoutExt + ext2);
+}
+__name(prefixFilename, "prefixFilename");
+
+// ../../libs/path/src/lib/root.ts
+var root_exports = {};
+__export(root_exports, {
+  root: () => root
+});
+var import_upath9 = __toESM(require_upath(), 1);
+function root(p) {
+  return import_upath9.default.parse(p).root;
+}
+__name(root, "root");
+
+// ../../libs/path/src/lib/suffixFilename.ts
+var suffixFilename_exports = {};
+__export(suffixFilename_exports, {
+  suffixFilename: () => suffixFilename
+});
+var import_upath10 = __toESM(require_upath(), 1);
+function suffixFilename(filePath, suffix) {
+  const split = import_upath10.default.basename(filePath).split(".");
+  split[0] += suffix;
+  return import_upath10.default.joinSafe(import_upath10.default.dirname(filePath), split.join("."));
+}
+__name(suffixFilename, "suffixFilename");
+
 // ../../libs/path/src/lib/toCwdRelative.ts
-var import_upath5 = __toESM(require_upath(), 1);
+var toCwdRelative_exports = {};
+__export(toCwdRelative_exports, {
+  toCwdRelative: () => toCwdRelative
+});
+var import_upath11 = __toESM(require_upath(), 1);
 function toCwdRelative(p) {
-  return import_upath5.default.relative(process.cwd(), p);
+  return import_upath11.default.relative(process.cwd(), p);
 }
 __name(toCwdRelative, "toCwdRelative");
 
+// ../../libs/path/src/lib/toWin32.ts
+var toWin32_exports = {};
+__export(toWin32_exports, {
+  toWin32: () => toWin32
+});
+function toWin32(p) {
+  return p.replace(/\//g, "\\");
+}
+__name(toWin32, "toWin32");
+
+// ../../libs/path/src/lib/upath.ts
+var upath_exports = {};
+__reExport(upath_exports, __toESM(require_upath(), 1));
+
+// ../../libs/path/src/index.ts
+__reExport(src_exports, upath_exports);
+var src_default = {
+  ...cwd_exports,
+  ...dirnameDeep_exports,
+  ...hasBasename_exports,
+  ...hasExtname_exports,
+  ...hasParentDirname_exports,
+  ...isDotFile_exports,
+  ...isExtValid_exports,
+  ...isRelative_exports,
+  ...isUnc_exports,
+  ...isValidWin32_exports,
+  ...prefixFilename_exports,
+  ...root_exports,
+  ...suffixFilename_exports,
+  ...toCwdRelative_exports,
+  ...toWin32_exports,
+  ...upath_exports
+};
+
 // ../../libs/monorepo/src/util/SemanticExtnamePrefix.ts
 var SemanticExtnamePrefix = {
   d: "d",
@@ -244500,19 +244699,19 @@ var File2 = class extends AbstractBase {
   path;
   constructor(parent, filepath) {
     super(parent);
-    this.path = import_upath6.default.normalize(filepath);
+    this.path = src_default.normalize(filepath);
   }
   get stats() {
     return import_node_fs.default.statSync(this.path);
   }
   get isTs() {
-    return hasExtname(this.path, ["ts", "mts", "tsx"]);
+    return src_default.hasExtname(this.path, ["ts", "mts", "tsx"]);
   }
   get isDotTs() {
-    return hasExtname(this.path, "ts");
+    return src_default.hasExtname(this.path, "ts");
   }
   get isDotTsx() {
-    return hasExtname(this.path, "tsx");
+    return src_default.hasExtname(this.path, "tsx");
   }
   get isExample() {
     return hasExtnamePrefix(this.path, SemanticExtnamePrefix.examples);
@@ -244524,10 +244723,10 @@ var File2 = class extends AbstractBase {
     return hasExtnamePrefix(this.path, SemanticExtnamePrefix.test);
   }
   get isIndexFile() {
-    return import_upath6.default.parse(this.path).name === "index";
+    return src_default.parse(this.path).name === "index";
   }
   get isSourceFile() {
-    return hasParentDirname(this.path, "src") && !hasExtnamePrefix(this.path);
+    return src_default.hasParentDirname(this.path, "src") && !hasExtnamePrefix(this.path);
   }
   /**
    * Read the file contents.
@@ -244999,16 +245198,16 @@ TestFile = __decorateClass([
 
 // ../../libs/fs/src/walkDirectory.ts
 var import_fs_extra3 = __toESM(require_lib(), 1);
-var import_upath7 = __toESM(require_upath(), 1);
+var import_upath12 = __toESM(require_upath(), 1);
 var import_walkdir = __toESM(require_walkdir(), 1);
 function walkDirectory(dirpath, options) {
-  dirpath = import_upath7.default.normalizeSafe(dirpath);
+  dirpath = import_upath12.default.normalizeSafe(dirpath);
   if (!options.stats && !options.only) {
     return import_walkdir.default.sync(dirpath, {
       ...convertToWalkdirOptions(options),
       //
       return_object: false
-    }).map((fspath) => import_upath7.default.normalizeSafe(fspath));
+    }).map((fspath) => import_upath12.default.normalizeSafe(fspath));
   }
   let entries = Object.entries(import_walkdir.default.sync(dirpath, convertToWalkdirOptions(options)));
   if (options.only === "files") {
@@ -245016,7 +245215,7 @@ function walkDirectory(dirpath, options) {
   } else if (options.only === "directories") {
     entries = entries.filter(([_, stats]) => stats.isDirectory());
   }
-  entries = entries.map(([fspath, stats]) => [import_upath7.default.normalizeSafe(fspath), stats]);
+  entries = entries.map(([fspath, stats]) => [import_upath12.default.normalizeSafe(fspath), stats]);
   if (options.stats) {
     return entries;
   } else {
@@ -245036,7 +245235,7 @@ function convertToWalkdirOptions(options) {
   if (options.filter) {
     const filter2 = options.filter;
     result.filter = (dirpath, files2) => {
-      return filter2(import_upath7.default.normalizeSafe(dirpath), import_upath7.default.basename(dirpath)) ? files2 : [];
+      return filter2(import_upath12.default.normalizeSafe(dirpath), import_upath12.default.basename(dirpath)) ? files2 : [];
     };
   }
   return result;
@@ -245045,10 +245244,10 @@ __name(convertToWalkdirOptions, "convertToWalkdirOptions");
 
 // ../../libs/monorepo/src/util/resolveModuleImportPath.ts
 var import_typescript = __toESM(require_typescript(), 1);
-var import_upath9 = __toESM(require_upath(), 1);
+var import_upath14 = __toESM(require_upath(), 1);
 
 // ../../libs/monorepo/src/util/getRepoRootDirpath.ts
-var import_upath8 = __toESM(require_upath(), 1);
+var import_upath13 = __toESM(require_upath(), 1);
 var import_fs_extra4 = __toESM(require_lib(), 1);
 
 // ../../node_modules/mimic-function/index.js
@@ -245132,12 +245331,12 @@ var onetime_default = onetime;
 // ../../libs/monorepo/src/util/getRepoRootDirpath.ts
 var getRepoRootDirpath2 = onetime_default(/* @__PURE__ */ __name(function getRepoRootDirpath3() {
   return (/* @__PURE__ */ __name(function recurse(dirpath = process.cwd()) {
-    dirpath = import_upath8.default.normalizeSafe(dirpath);
-    const pkgpath = import_upath8.default.joinSafe(dirpath, "package.json");
+    dirpath = import_upath13.default.normalizeSafe(dirpath);
+    const pkgpath = import_upath13.default.joinSafe(dirpath, "package.json");
     if (import_fs_extra4.default.existsSync(pkgpath) && import_fs_extra4.default.readJsonSync(pkgpath)?.workspaces) {
       return dirpath;
     }
-    const parent = import_upath8.default.dirname(dirpath);
+    const parent = import_upath13.default.dirname(dirpath);
     if (parent !== dirpath) return recurse(parent);
     throw new Error("Could not find repo root from process.cwd(): " + process.cwd());
   }, "recurse"))();
@@ -245150,7 +245349,7 @@ function resolveModuleImportPath(filepath, importFrom) {
     importFrom,
     filepath,
     {
-      paths: esm_default.readJsonSync(import_upath9.default.joinSafe(rootdir, "tsconfig.paths.json")).compilerOptions.paths,
+      paths: esm_default.readJsonSync(import_upath14.default.joinSafe(rootdir, "tsconfig.paths.json")).compilerOptions.paths,
       allowJs: true,
       allowArbitraryExtensions: true,
       allowImportingTsExtensions: true,
@@ -245161,7 +245360,7 @@ function resolveModuleImportPath(filepath, importFrom) {
     (0, import_typescript.createCompilerHost)({}, true)
   );
   const f = result.resolvedModule?.resolvedFileName;
-  if (f) result.resolvedModule.resolvedFileName = import_upath9.default.relative(rootdir, f);
+  if (f) result.resolvedModule.resolvedFileName = import_upath14.default.relative(rootdir, f);
   return result.resolvedModule;
 }
 __name(resolveModuleImportPath, "resolveModuleImportPath");
@@ -245178,14 +245377,14 @@ var Workspace = class extends AbstractBase {
   path;
   constructor(parent, dirpath) {
     super(parent);
-    this.path = import_upath10.default.normalize(dirpath);
-    this.origin = import_upath10.default.basename(import_upath10.default.dirname(this.path));
+    this.path = import_upath15.default.normalize(dirpath);
+    this.origin = import_upath15.default.basename(import_upath15.default.dirname(this.path));
   }
   /**
    * The workspace's package.json filepath.
    */
   get packageJsonPath() {
-    return import_upath10.default.join(this.path, "package.json");
+    return import_upath15.default.join(this.path, "package.json");
   }
   get packageJson() {
     return readJsonSync(this.packageJsonPath);
@@ -245286,14 +245485,14 @@ var Workspace = class extends AbstractBase {
   get importedDependenciesByFile() {
     return new Map(
       this.tsFiles.map((file) => {
-        return [import_upath10.default.relative(process.cwd(), file.path), file.dependencies];
+        return [import_upath15.default.relative(process.cwd(), file.path), file.dependencies];
       })
     );
   }
   get importedTestDependenciesByFile() {
     return new Map(
       this.testFiles.map((file) => {
-        return [import_upath10.default.relative(process.cwd(), file.path), file.dependencies];
+        return [import_upath15.default.relative(process.cwd(), file.path), file.dependencies];
       })
     );
   }
@@ -245343,7 +245542,7 @@ var Workspace = class extends AbstractBase {
             results.push({
               filepath: file.path,
               replaceValue: imp.module.from,
-              withValue: resolvedFileName.endsWith("index.ts") ? "./" + imp.specifiers?.importedNamesArray[0] : "./" + import_upath10.default.relative(import_upath10.default.dirname(file.path), resolvedFileName)
+              withValue: resolvedFileName.endsWith("index.ts") ? "./" + imp.specifiers?.importedNamesArray[0] : "./" + import_upath15.default.relative(import_upath15.default.dirname(file.path), resolvedFileName)
             });
           }
         }
@@ -245405,7 +245604,7 @@ var Workspace = class extends AbstractBase {
    * Returns the workspace's cwd-relative path.
    */
   toString() {
-    return import_upath10.default.relative(process.cwd(), this.path);
+    return import_upath15.default.relative(process.cwd(), this.path);
   }
 };
 __name(Workspace, "Workspace");
@@ -245447,10 +245646,10 @@ var MonoRepo = class extends AbstractBase {
     return super.findParentDeep((m) => m instanceof MonoRepo) || this;
   }
   get packageJsonPath() {
-    return import_upath11.default.join(this.path, "package.json");
+    return import_upath16.default.join(this.path, "package.json");
   }
   get tsconfigBaseJsonPath() {
-    return import_upath11.default.join(this.path, "tsconfig.json");
+    return import_upath16.default.join(this.path, "tsconfig.json");
   }
   get tsconfigBase() {
     const o = readJsonSync(this.tsconfigBaseJsonPath);
@@ -245459,7 +245658,7 @@ var MonoRepo = class extends AbstractBase {
     return o;
   }
   get tsconfigBasePathsJsonPath() {
-    return import_upath11.default.join(this.path, "tsconfig.paths.json");
+    return import_upath16.default.join(this.path, "tsconfig.paths.json");
   }
   get tsconfigBasePaths() {
     if (!import_node_fs2.default.existsSync(this.tsconfigBasePathsJsonPath)) return {};
@@ -245479,7 +245678,7 @@ var MonoRepo = class extends AbstractBase {
       throw new Error(`MonoRepo package.json missing 'workspaces' field: ${this.packageJsonPath}`);
     }
     return this.packageJson.workspaces.map((workspacePath) => {
-      return import_upath11.default.join(this.path, workspacePath.replace(/\*$/, ""));
+      return import_upath16.default.join(this.path, workspacePath.replace(/\*$/, ""));
     });
   }
   get workspacePaths() {
@@ -245487,7 +245686,7 @@ var MonoRepo = class extends AbstractBase {
       return import_node_fs2.default.readdirSync(workspacePath, { withFileTypes: true }).filter((dirent) => {
         return dirent.isDirectory();
       }).map((dirent) => {
-        return import_upath11.default.join(workspacePath, dirent.name);
+        return import_upath16.default.join(workspacePath, dirent.name);
       });
     }).flat();
   }
@@ -248497,7 +248696,7 @@ var LRUCache = class _LRUCache {
 };
 
 // ../../node_modules/path-scurry/dist/esm/index.js
-var import_node_path2 = require("node:path");
+var import_node_path3 = require("node:path");
 var import_node_url = require("node:url");
 var import_fs2 = require("fs");
 var actualFS = __toESM(require("node:fs"), 1);
@@ -249625,13 +249824,13 @@ var PathBase = class {
    *
    * @internal
    */
-  constructor(name, type = UNKNOWN, root, roots, nocase, children, opts) {
+  constructor(name, type = UNKNOWN, root2, roots, nocase, children, opts) {
     this.name = name;
     this.#matchName = nocase ? normalizeNocase(name) : normalize(name);
     this.#type = type & TYPEMASK;
     this.nocase = nocase;
     this.roots = roots;
-    this.root = root || this;
+    this.root = root2 || this;
     this.#children = children;
     this.#fullpath = opts.fullpath;
     this.#relative = opts.relative;
@@ -250412,8 +250611,8 @@ var PathWin32 = class _PathWin32 extends PathBase {
    *
    * @internal
    */
-  constructor(name, type = UNKNOWN, root, roots, nocase, children, opts) {
-    super(name, type, root, roots, nocase, children, opts);
+  constructor(name, type = UNKNOWN, root2, roots, nocase, children, opts) {
+    super(name, type, root2, roots, nocase, children, opts);
   }
   /**
    * @internal
@@ -250425,7 +250624,7 @@ var PathWin32 = class _PathWin32 extends PathBase {
    * @internal
    */
   getRootString(path7) {
-    return import_node_path2.win32.parse(path7).root;
+    return import_node_path3.win32.parse(path7).root;
   }
   /**
    * @internal
@@ -250435,9 +250634,9 @@ var PathWin32 = class _PathWin32 extends PathBase {
     if (rootPath === this.root.name) {
       return this.root;
     }
-    for (const [compare, root] of Object.entries(this.roots)) {
+    for (const [compare, root2] of Object.entries(this.roots)) {
       if (this.sameRoot(rootPath, compare)) {
-        return this.roots[rootPath] = root;
+        return this.roots[rootPath] = root2;
       }
     }
     return this.roots[rootPath] = new PathScurryWin32(rootPath, this).root;
@@ -250468,8 +250667,8 @@ var PathPosix = class _PathPosix extends PathBase {
    *
    * @internal
    */
-  constructor(name, type = UNKNOWN, root, roots, nocase, children, opts) {
-    super(name, type, root, roots, nocase, children, opts);
+  constructor(name, type = UNKNOWN, root2, roots, nocase, children, opts) {
+    super(name, type, root2, roots, nocase, children, opts);
   }
   /**
    * @internal
@@ -250527,12 +250726,12 @@ var PathScurryBase = class {
    *
    * @internal
    */
-  constructor(cwd2 = process.cwd(), pathImpl, sep2, { nocase, childrenCacheSize = 16 * 1024, fs: fs29 = defaultFS } = {}) {
+  constructor(cwd3 = process.cwd(), pathImpl, sep2, { nocase, childrenCacheSize = 16 * 1024, fs: fs29 = defaultFS } = {}) {
     this.#fs = fsFromOption(fs29);
-    if (cwd2 instanceof URL || cwd2.startsWith("file://")) {
-      cwd2 = (0, import_node_url.fileURLToPath)(cwd2);
+    if (cwd3 instanceof URL || cwd3.startsWith("file://")) {
+      cwd3 = (0, import_node_url.fileURLToPath)(cwd3);
     }
-    const cwdPath = pathImpl.resolve(cwd2);
+    const cwdPath = pathImpl.resolve(cwd3);
     this.roots = /* @__PURE__ */ Object.create(null);
     this.rootPath = this.parseRootPath(cwdPath);
     this.#resolveCache = new ResolveCache();
@@ -251072,9 +251271,9 @@ var PathScurryWin32 = class extends PathScurryBase {
    * separator for generating path strings
    */
   sep = "\\";
-  constructor(cwd2 = process.cwd(), opts = {}) {
+  constructor(cwd3 = process.cwd(), opts = {}) {
     const { nocase = true } = opts;
-    super(cwd2, import_node_path2.win32, "\\", { ...opts, nocase });
+    super(cwd3, import_node_path3.win32, "\\", { ...opts, nocase });
     this.nocase = nocase;
     for (let p = this.cwd; p; p = p.parent) {
       p.nocase = this.nocase;
@@ -251084,7 +251283,7 @@ var PathScurryWin32 = class extends PathScurryBase {
    * @internal
    */
   parseRootPath(dir) {
-    return import_node_path2.win32.parse(dir).root.toUpperCase();
+    return import_node_path3.win32.parse(dir).root.toUpperCase();
   }
   /**
    * @internal
@@ -251107,9 +251306,9 @@ var PathScurryPosix = class extends PathScurryBase {
    * separator for generating path strings
    */
   sep = "/";
-  constructor(cwd2 = process.cwd(), opts = {}) {
+  constructor(cwd3 = process.cwd(), opts = {}) {
     const { nocase = false } = opts;
-    super(cwd2, import_node_path2.posix, "/", { ...opts, nocase });
+    super(cwd3, import_node_path3.posix, "/", { ...opts, nocase });
     this.nocase = nocase;
   }
   /**
@@ -251135,9 +251334,9 @@ var PathScurryDarwin = class extends PathScurryPosix {
   static {
     __name(this, "PathScurryDarwin");
   }
-  constructor(cwd2 = process.cwd(), opts = {}) {
+  constructor(cwd3 = process.cwd(), opts = {}) {
     const { nocase = true } = opts;
-    super(cwd2, { ...opts, nocase });
+    super(cwd3, { ...opts, nocase });
   }
 };
 var Path = process.platform === "win32" ? PathWin32 : PathPosix;
@@ -251497,10 +251696,10 @@ var Processor = class _Processor {
     const processingSet = patterns.map((p) => [target, p]);
     for (let [t, pattern] of processingSet) {
       this.hasWalkedCache.storeWalked(t, pattern);
-      const root = pattern.root();
+      const root2 = pattern.root();
       const absolute = pattern.isAbsolute() && this.opts.absolute !== false;
-      if (root) {
-        t = t.resolve(root === "/" && this.opts.root !== void 0 ? this.opts.root : root);
+      if (root2) {
+        t = t.resolve(root2 === "/" && this.opts.root !== void 0 ? this.opts.root : root2);
         const rest2 = pattern.rest();
         if (!rest2) {
           this.matches.add(t, true, false);
@@ -252350,10 +252549,10 @@ var import_fs_extra6 = __toESM(require_lib(), 1);
 var import_strip_comments2 = __toESM(require_strip_comments(), 1);
 
 // src/lib/topImports.ts
-var import_upath12 = __toESM(require_upath(), 1);
+var import_upath17 = __toESM(require_upath(), 1);
 function topImports(repo, n = 50, normalize2 = (line) => line) {
   const imports = getAllImports(repo);
-  const counters = imports.filter((imp) => import_upath12.default.parse(imp.path).name !== "index").filter((imp) => imp.module.isDependency).flatMap((imp) => {
+  const counters = imports.filter((imp) => import_upath17.default.parse(imp.path).name !== "index").filter((imp) => imp.module.isDependency).flatMap((imp) => {
     return imp.split().map((s) => {
       return normalize2(s.replace(/^import type /, "import ").replace("import * as ", "import "));
     });
@@ -252445,17 +252644,17 @@ __name(list_imported_files, "list_imported_files");
 
 // src/lib/importLibs.ts
 var import_fs_extra7 = __toESM(require_lib(), 1);
-var import_upath13 = __toESM(require_upath(), 1);
+var import_upath18 = __toESM(require_upath(), 1);
 var import_meta2 = {};
 async function importLibs(libDirnames) {
   if (!libDirnames) {
-    const libsDir = import_upath13.default.joinSafe(getRepoRootDirpath(), "libs");
+    const libsDir = import_upath18.default.joinSafe(getRepoRootDirpath(), "libs");
     libDirnames = await import_fs_extra7.default.readdir(libsDir);
   }
   const promises = libDirnames.map(async (ws) => {
-    const absPath = import_upath13.default.joinSafe(getRepoRootDirpath(), ".dist", "libs", ws + ".cjs");
+    const absPath = import_upath18.default.joinSafe(getRepoRootDirpath(), ".dist", "libs", ws + ".cjs");
     const currentDir = typeof import_meta2 !== "undefined" && import_meta2.dirname || typeof __dirname !== "undefined" && __dirname || process.cwd();
-    let importPath = import_upath13.default.relative(currentDir, absPath);
+    let importPath = import_upath18.default.relative(currentDir, absPath);
     if (!importPath.startsWith(".")) importPath = "./" + importPath;
     return [ws, await import(importPath)];
   });
@@ -252509,12 +252708,12 @@ __name(fix_dash_chars, "fix_dash_chars");
 
 // src/commands/missing_coverage_files.ts
 var import_fs_extra9 = __toESM(require_lib(), 1);
-var import_upath14 = __toESM(require_upath(), 1);
+var import_upath19 = __toESM(require_upath(), 1);
 function missing_coverage_files() {
   return new Command("missing-coverage-files").alias("mcf").description("Show files with missing test coverage.").option("--check", "Exit with error code if files with missing coverage are found.").action(async (opts) => {
     await timer(["missing-coverage-files", "Checking library exports for missing coverage..."], async (log) => {
       const repoRoot = getRepoRootDirpath();
-      const vitestConfigFilepath = import_upath14.default.join(repoRoot, "vitest.config.js");
+      const vitestConfigFilepath = import_upath19.default.join(repoRoot, "vitest.config.js");
       if (!import_fs_extra9.default.existsSync(vitestConfigFilepath)) {
         console.error(`Vitest config file not found at ${vitestConfigFilepath}`);
         process.exit(1);
@@ -252524,7 +252723,7 @@ function missing_coverage_files() {
         console.error(`Could not find reportsDirectory in Vitest config at ${vitestConfigFilepath}`);
         process.exit(1);
       }
-      const coverageSummaryJsonFilepath = import_upath14.default.join(coverageDirectory, "coverage-summary.json");
+      const coverageSummaryJsonFilepath = import_upath19.default.join(coverageDirectory, "coverage-summary.json");
       if (!import_fs_extra9.default.existsSync(coverageSummaryJsonFilepath)) {
         console.error(`Coverage summary file not found at ${coverageSummaryJsonFilepath}`);
         process.exit(1);
@@ -252640,17 +252839,17 @@ var import_node_child_process4 = __toESM(require("node:child_process"), 1);
 // src/lib/renderReadme.ts
 var import_fs_extra13 = __toESM(require_lib(), 1);
 var import_node_child_process3 = __toESM(require("node:child_process"), 1);
-var import_upath17 = __toESM(require_upath(), 1);
+var import_upath22 = __toESM(require_upath(), 1);
 
 // src/lib/getRepoPackageJson.ts
 var import_fs_extra11 = __toESM(require_lib(), 1);
-var import_upath15 = __toESM(require_upath(), 1);
+var import_upath20 = __toESM(require_upath(), 1);
 async function getRepoPackageJson() {
   return await import_fs_extra11.default.readJson(getRepoPackageJsonPath());
 }
 __name(getRepoPackageJson, "getRepoPackageJson");
 function getRepoPackageJsonPath() {
-  return import_upath15.default.joinSafe(getRepoRootDirpath(), "package.json");
+  return import_upath20.default.joinSafe(getRepoRootDirpath(), "package.json");
 }
 __name(getRepoPackageJsonPath, "getRepoPackageJsonPath");
 
@@ -252673,7 +252872,7 @@ __name(arrayTableToMarkdown, "arrayTableToMarkdown");
 
 // src/lib/parseLibsTsDocSummaries.ts
 var import_fs_extra12 = __toESM(require_lib(), 1);
-var import_upath16 = __toESM(require_upath(), 1);
+var import_upath21 = __toESM(require_upath(), 1);
 
 // src/lib/tsdoc.ts
 function* tsDocExtractAllComments(code) {
@@ -252729,14 +252928,14 @@ var parseLibsTsDocSummaries = onetime_default(async () => {
   );
   const exportsNotInDedicatedFileSet = new Set(libs.map(([wsPath, expName]) => wsPath + " => " + expName + ".ts"));
   const repoRoot = getRepoRootDirpath();
-  const tsFiles = (await glob(["libs/*/src/**/*.ts"], { absolute: true })).map((fp) => import_upath16.default.relative(repoRoot, fp)).filter(Boolean);
+  const tsFiles = (await glob(["libs/*/src/**/*.ts"], { absolute: true })).map((fp) => import_upath21.default.relative(repoRoot, fp)).filter(Boolean);
   if (tsFiles.length === 0) {
     logError("\u26A0\uFE0F No TypeScript files found.");
     return { validSummaries: [], exportsNotInDedicatedFileSet, filesNotDocumented: [], printLogs };
   }
   const tsFilesAndContent = await Promise.all(
     tsFiles.map(async (filepath) => {
-      const filename = import_upath16.default.trimExt(import_upath16.default.basename(filepath));
+      const filename = import_upath21.default.trimExt(import_upath21.default.basename(filepath));
       const code = await import_fs_extra12.default.readFile(filepath, "utf8");
       return { filepath, filename, code };
     })
@@ -252822,7 +253021,7 @@ async function renderLibsExportedModules() {
       }
       librarySummaries.get(libName).push({
         fileName,
-        functionName: import_upath17.default.basename(fileName),
+        functionName: import_upath22.default.basename(fileName),
         summary: summary || "No description available"
       });
     } catch {
@@ -252912,32 +253111,32 @@ function build_readme() {
 __name(build_readme, "build_readme");
 
 // src/lib/buildLibsWorkspace.ts
-var import_upath21 = __toESM(require_upath(), 1);
+var import_upath26 = __toESM(require_upath(), 1);
 var import_fs_extra17 = __toESM(require_lib(), 1);
 
 // src/lib/buildFile.ts
 var esbuild2 = __toESM(require("esbuild"), 1);
-var import_upath19 = __toESM(require_upath(), 1);
+var import_upath24 = __toESM(require_upath(), 1);
 var import_fs_extra15 = __toESM(require_lib(), 1);
 var import_node_child_process5 = __toESM(require("node:child_process"), 1);
 
 // src/lib/relativeImportPath.ts
-var import_upath18 = __toESM(require_upath(), 1);
+var import_upath23 = __toESM(require_upath(), 1);
 function relativeImportPath(path7, filepathToImport) {
-  path7 = import_upath18.default.resolve(path7);
-  path7 = import_upath18.default.basename(path7).includes(".") ? import_upath18.default.dirname(path7) : path7;
-  filepathToImport = import_upath18.default.resolve(filepathToImport).replace(/([/]?index)?[.]m?tsx?$/i, "");
-  const relative = import_upath18.default.relative(path7, filepathToImport);
+  path7 = import_upath23.default.resolve(path7);
+  path7 = import_upath23.default.basename(path7).includes(".") ? import_upath23.default.dirname(path7) : path7;
+  filepathToImport = import_upath23.default.resolve(filepathToImport).replace(/([/]?index)?[.]m?tsx?$/i, "");
+  const relative = import_upath23.default.relative(path7, filepathToImport);
   return relative.startsWith(".") ? relative : `./${relative}`;
 }
 __name(relativeImportPath, "relativeImportPath");
 
 // src/lib/buildFile.ts
 var import_meta3 = {};
-var cwd = process.cwd();
+var cwd2 = process.cwd();
 async function buildFile(filepath, outfile, tsconfig, optionsOverride = {}) {
-  const parsed = import_upath19.default.parse(outfile);
-  const outfileTemp = import_upath19.default.joinSafe(parsed.dir, parsed.name + "-temp" + import_upath19.default.extname(outfile));
+  const parsed = import_upath24.default.parse(outfile);
+  const outfileTemp = import_upath24.default.joinSafe(parsed.dir, parsed.name + "-temp" + import_upath24.default.extname(outfile));
   const result = await esbuild2.build({
     entryPoints: [filepath],
     bundle: true,
@@ -252957,7 +253156,7 @@ async function buildFile(filepath, outfile, tsconfig, optionsOverride = {}) {
     ...optionsOverride
   });
   process.chdir(getRepoRootDirpath());
-  if (import_upath19.default.basename(filepath) !== "main.ts") {
+  if (import_upath24.default.basename(filepath) !== "main.ts") {
     const currentFile = typeof import_meta3 !== "undefined" && import_meta3.filename || typeof __filename !== "undefined" && __filename || "";
     const importPath = relativeImportPath(currentFile, outfileTemp);
     const loadedBuiltModule = await import(importPath);
@@ -252969,7 +253168,7 @@ async function buildFile(filepath, outfile, tsconfig, optionsOverride = {}) {
       process.exit(1);
     }
   }
-  process.chdir(cwd);
+  process.chdir(cwd2);
   await import_fs_extra15.default.remove(outfile);
   await import_fs_extra15.default.rename(outfileTemp, outfile);
   await import_fs_extra15.default.remove(outfile + ".map");
@@ -252990,19 +253189,19 @@ async function buildStats(outfile) {
 __name(buildStats, "buildStats");
 
 // src/lib/getWsPaths.ts
-var import_upath20 = __toESM(require_upath(), 1);
+var import_upath25 = __toESM(require_upath(), 1);
 function getWsPaths(importMetaDirname) {
-  importMetaDirname = import_upath20.default.normalizeSafe(importMetaDirname);
-  const wsDirname = import_upath20.default.basename(importMetaDirname);
-  const tsconfig = import_upath20.default.joinSafe(importMetaDirname, "tsconfig.json");
-  const pkg = import_upath20.default.joinSafe(importMetaDirname, "package.json");
-  const srcDir = import_upath20.default.joinSafe(importMetaDirname, "src");
+  importMetaDirname = import_upath25.default.normalizeSafe(importMetaDirname);
+  const wsDirname = import_upath25.default.basename(importMetaDirname);
+  const tsconfig = import_upath25.default.joinSafe(importMetaDirname, "tsconfig.json");
+  const pkg = import_upath25.default.joinSafe(importMetaDirname, "package.json");
+  const srcDir = import_upath25.default.joinSafe(importMetaDirname, "src");
   const repoRootDir = getRepoRootDirpath();
-  const distDir = import_upath20.default.joinSafe(repoRootDir, ".dist", "libs");
-  const indexTs2 = import_upath20.default.joinSafe(srcDir, "index.ts");
-  const indexCjs = import_upath20.default.joinSafe(distDir, wsDirname + ".cjs");
-  const indexMjs = import_upath20.default.joinSafe(distDir, wsDirname + ".mjs");
-  const toRelative = /* @__PURE__ */ __name((path7) => import_upath20.default.relative(repoRootDir, path7), "toRelative");
+  const distDir = import_upath25.default.joinSafe(repoRootDir, ".dist", "libs");
+  const indexTs2 = import_upath25.default.joinSafe(srcDir, "index.ts");
+  const indexCjs = import_upath25.default.joinSafe(distDir, wsDirname + ".cjs");
+  const indexMjs = import_upath25.default.joinSafe(distDir, wsDirname + ".mjs");
+  const toRelative = /* @__PURE__ */ __name((path7) => import_upath25.default.relative(repoRootDir, path7), "toRelative");
   return {
     wsDir: importMetaDirname,
     wsDirname,
@@ -253021,7 +253220,7 @@ __name(getWsPaths, "getWsPaths");
 // src/lib/buildLibsWorkspace.ts
 async function buildLibsWorkspace(importMetaDirname, options = {}) {
   const { debug, ...optionsOverride } = options;
-  importMetaDirname = import_upath21.default.normalizeSafe(importMetaDirname);
+  importMetaDirname = import_upath26.default.normalizeSafe(importMetaDirname);
   const wsPaths = getWsPaths(importMetaDirname);
   const repoPkg = import_fs_extra17.default.readJsonSync(wsPaths.pkg);
   await buildFile(
@@ -253046,23 +253245,23 @@ async function buildLibsWorkspace(importMetaDirname, options = {}) {
 __name(buildLibsWorkspace, "buildLibsWorkspace");
 
 // src/commands/build_libs.ts
-var import_upath22 = __toESM(require_upath(), 1);
+var import_upath27 = __toESM(require_upath(), 1);
 var import_fs_extra18 = __toESM(require_lib(), 1);
 function build_libs() {
   return new Command("build-libs").alias("bl").description("Build all libs/ workspaces.").argument("[dirnames...]", "libs dirnames. Defaults to all.").option("--debug", "Enable debug output", false).action(async (dirnames, opts) => {
     await timer(["build libs", `Building libraries...`], async (log) => {
       if (dirnames.length === 0) {
-        dirnames = await import_fs_extra18.default.readdir(import_upath22.default.join(getRepoRootDirpath(), "libs"));
+        dirnames = await import_fs_extra18.default.readdir(import_upath27.default.join(getRepoRootDirpath(), "libs"));
       }
       for (const dirname of dirnames) {
-        if (!await import_fs_extra18.default.pathExists(import_upath22.default.join(getRepoRootDirpath(), "libs", dirname))) {
+        if (!await import_fs_extra18.default.pathExists(import_upath27.default.join(getRepoRootDirpath(), "libs", dirname))) {
           throw new Error(`Directory does not exist: libs/${dirname}`);
         }
       }
       await forEachAsync(
         dirnames,
         async (dirname) => {
-          const wsDir = import_upath22.default.join(getRepoRootDirpath(), "libs", dirname);
+          const wsDir = import_upath27.default.join(getRepoRootDirpath(), "libs", dirname);
           log.info(`Building ${dirname}...`);
           await buildLibsWorkspace(wsDir, { debug: opts.debug });
         },
@@ -253075,18 +253274,18 @@ __name(build_libs, "build_libs");
 
 // src/commands/clear_node_modules.ts
 var import_node_fs3 = __toESM(require("node:fs"), 1);
-var import_upath23 = __toESM(require_upath(), 1);
+var import_upath28 = __toESM(require_upath(), 1);
 var import_node_child_process6 = require("node:child_process");
 function clear_node_modules() {
   return new Command("clear-node-modules").alias("cnm").description("Completely removes and reinstalls all node_modules and lock files.").action(async () => {
     await timer("clear-node-modules", async (log) => {
-      const root = getRepoRootDirpath();
+      const root2 = getRepoRootDirpath();
       const paths = (await glob([
         "{apps,libs,packages}/*/{node_modules,package-lock.json}",
         "yarn.lock",
         "package-lock.json",
         "node_modules"
-      ])).map((dp) => import_upath23.default.normalize(dp)).sort();
+      ])).map((dp) => import_upath28.default.normalize(dp)).sort();
       log.info("Deleting:");
       paths.forEach((p, i) => log.info("", i, p));
       for (const p of paths.filter((p2) => import_node_fs3.default.existsSync(p2))) {
@@ -253095,7 +253294,7 @@ function clear_node_modules() {
       log.info("Clearing yarn cache...");
       (0, import_node_child_process6.execSync)("yarn cache clear", {
         stdio: "inherit",
-        cwd: root
+        cwd: root2
       });
     });
   });
@@ -253104,11 +253303,11 @@ __name(clear_node_modules, "clear_node_modules");
 
 // src/commands/fix_vitest_imports.ts
 var import_fs_extra19 = __toESM(require_lib(), 1);
-var import_upath24 = __toESM(require_upath(), 1);
+var import_upath29 = __toESM(require_upath(), 1);
 function fix_vitest_imports() {
   return new Command("fix-vitest-imports").alias("fvi").description("Ensure all test files have necessary Vitest imports.").argument("[glob]", "File glob pattern", "{libs,apps,packages}/*/src/**/*.test.{ts,tsx}").action(async (fileGlob) => {
     await timer("clean fix-vitest-imports", async (log) => {
-      const filepaths = globSync(fileGlob, { cwd: process.cwd() }).map((fp) => import_upath24.default.normalizeSafe(fp));
+      const filepaths = globSync(fileGlob, { cwd: process.cwd() }).map((fp) => import_upath29.default.normalizeSafe(fp));
       log.info(`Found ${filepaths.length} files matching glob: ${fileGlob}`);
       if (filepaths.length === 0) return;
       const filesWithCode = filepaths.map((filepath) => {
@@ -253134,7 +253333,7 @@ ${o.code}`, "utf-8");
 __name(fix_vitest_imports, "fix_vitest_imports");
 
 // src/commands/fix_index_ts.ts
-var import_upath25 = __toESM(require_upath(), 1);
+var import_upath30 = __toESM(require_upath(), 1);
 
 // src/lib/outputFileIfChanged.ts
 var import_fs_extra20 = __toESM(require_lib(), 1);
@@ -253157,17 +253356,22 @@ function fix_index_ts() {
   return new Command("fix-index-ts").alias("fit").description("Generate barrel export index.ts for a workspace.").argument("[dirnames...]", "Workspace dirnames within libs/*").option("--ignore <dirnames...>", "Workspace dirnames to ignore (relative to repo root)").action(async (dirnames, opts) => {
     await timer(["fix-index-ts", "Generating index.ts files for workspaces..."], async (logger) => {
       const repoRoot = getRepoRootDirpath();
-      const libWorkspacePaths = (dirnames.length ? dirnames : await import_fs_extra21.default.readdir("libs")).filter((dirname) => !opts.ignore || !opts.ignore.includes(dirname)).map((d) => import_upath25.default.joinSafe("libs", d));
+      const libWorkspacePaths = (dirnames.length ? dirnames : await import_fs_extra21.default.readdir("libs")).filter((dirname) => !opts.ignore || !opts.ignore.includes(dirname)).map((d) => import_upath30.default.joinSafe("libs", d));
       await forEachAsync(
         libWorkspacePaths,
         async (wsPath) => {
           const OUTFILE = "src/index.ts";
           const TEST_OUTFILE = "src/index.test.ts";
-          const WS_ROOT = import_upath25.default.joinSafe(repoRoot, wsPath);
-          const filepaths = (await glob("src/**/*.ts", { cwd: WS_ROOT })).map((fp) => import_upath25.default.normalizeSafe(fp)).filter((fp) => !/[./](test|wip|old|examples?|benchmark|temp|internal)[./]/.test(fp));
-          const exportDirpaths = filepaths.filter((fp) => fp.endsWith("/index.ts") && fp !== OUTFILE).map((fp) => import_upath25.default.dirname(fp)).sort();
+          const WS_ROOT = import_upath30.default.joinSafe(repoRoot, wsPath);
+          const filepaths = (await glob("src/**/*.ts", { cwd: WS_ROOT })).map((fp) => import_upath30.default.normalizeSafe(fp)).filter((fp) => !/[./](test|wip|old|examples?|benchmark|temp|internal)[./]/.test(fp));
+          const exportDirpaths = filepaths.filter((fp) => fp.endsWith("/index.ts") && fp !== OUTFILE).map((fp) => import_upath30.default.dirname(fp)).sort();
           const exportFilepaths = filepaths.filter((fp) => !exportDirpaths.some((dp) => fp.startsWith(dp))).filter((fp) => fp !== OUTFILE).map((fp) => fp.replace(/\.ts$/, "")).sort();
-          const lines = [...exportDirpaths, ...exportFilepaths].map((fp) => fp.replace(/^src/, ".")).map((fp) => `export * from '${fp}'`).concat("");
+          const relative = [...exportDirpaths, ...exportFilepaths].map((fp) => fp.replace(/^src/, "."));
+          const lines = relative.flatMap((fp) => `export * from '${fp}'`).concat("").concat(
+            relative.map((fp) => {
+              return `import * as ${import_upath30.default.basename(fp)} from '${fp}'`;
+            })
+          ).concat("", `export default { `, ...relative.map((line, i) => `  ...${import_upath30.default.basename(line)},`), `}`);
           const testLines = [
             `import { describe, expect, it } from 'vitest'`,
             `import * as EXPORTS from './index'`,
@@ -253182,8 +253386,8 @@ function fix_index_ts() {
             `})`,
             ``
           ];
-          await outputFileIfChanged(import_upath25.default.joinSafe(WS_ROOT, OUTFILE), lines.join("\n"), logger);
-          await outputFileIfChanged(import_upath25.default.joinSafe(WS_ROOT, TEST_OUTFILE), testLines.join("\n"), logger);
+          await outputFileIfChanged(import_upath30.default.joinSafe(WS_ROOT, OUTFILE), lines.join("\n"), logger);
+          await outputFileIfChanged(import_upath30.default.joinSafe(WS_ROOT, TEST_OUTFILE), testLines.join("\n"), logger);
         },
         { concurrency: 10 }
       );
@@ -253195,11 +253399,11 @@ __name(fix_index_ts, "fix_index_ts");
 // src/commands/run.ts
 var import_node_child_process7 = __toESM(require("node:child_process"), 1);
 var import_fs_extra22 = __toESM(require_lib(), 1);
-var import_upath26 = __toESM(require_upath(), 1);
+var import_upath31 = __toESM(require_upath(), 1);
 function run() {
   return new Command("run").alias("r").description("Compile and run a file. Supports .ts, .test.ts, .js, .mjs, .cjs, .ps1").argument("<filepath>", "Path to file to run").argument("[args...]", "Additional arguments to pass to the script").allowUnknownOption(true).action(async (filepath, args) => {
-    const root = getRepoRootDirpath();
-    const relative = import_upath26.default.isAbsolute(filepath) ? import_upath26.default.relative(root, filepath) : import_upath26.default.normalizeSafe(filepath);
+    const root2 = getRepoRootDirpath();
+    const relative = import_upath31.default.isAbsolute(filepath) ? import_upath31.default.relative(root2, filepath) : import_upath31.default.normalizeSafe(filepath);
     if (!filepath) {
       console.error("no filepath argument provided");
       process.exit(1);
@@ -253207,21 +253411,21 @@ function run() {
     if (filepath.endsWith(".test.ts")) {
       import_node_child_process7.default.execSync(`yarn vitest --config vitest.config.js --run ${relative}`, {
         stdio: "inherit",
-        cwd: root
+        cwd: root2
       });
       process.exit(0);
     }
     if (filepath.endsWith(".mjs") || filepath.endsWith(".cjs") || filepath.endsWith(".js")) {
       import_node_child_process7.default.execSync(`node ${relative}`, {
         stdio: "inherit",
-        cwd: root
+        cwd: root2
       });
       process.exit(0);
     }
     if (filepath.endsWith(".ps1")) {
       import_node_child_process7.default.execSync(`./${relative}`, {
         stdio: "inherit",
-        cwd: root
+        cwd: root2
       });
       process.exit(0);
     }
@@ -253254,7 +253458,7 @@ enablePrettyStackTrace()`;
       ].map((r) => `-r ${r}`).join(" ");
       import_node_child_process7.default.execSync(`tsx ${requires} ${relative} ${args.join(" ")}`, {
         stdio: "inherit",
-        cwd: root
+        cwd: root2
       });
     } finally {
       if (changedSourceFile) {
@@ -253269,15 +253473,15 @@ var import_node_child_process8 = require("node:child_process");
 
 // src/lib/workspaces.ts
 var import_fs_extra23 = __toESM(require_lib(), 1);
-var import_upath27 = __toESM(require_upath(), 1);
+var import_upath32 = __toESM(require_upath(), 1);
 async function getAllWorkspacePaths() {
   const pkg = await getRepoPackageJson();
-  return (await Promise.all(pkg.workspaces.map((pattern) => glob(pattern)))).flat().map((fp) => import_upath27.default.normalizeSafe(fp));
+  return (await Promise.all(pkg.workspaces.map((pattern) => glob(pattern)))).flat().map((fp) => import_upath32.default.normalizeSafe(fp));
 }
 __name(getAllWorkspacePaths, "getAllWorkspacePaths");
 async function getAllWorkspacePackageJsonPaths() {
   const paths = await getAllWorkspacePaths();
-  return paths.map((p) => import_upath27.default.join(p, "package.json"));
+  return paths.map((p) => import_upath32.default.join(p, "package.json"));
 }
 __name(getAllWorkspacePackageJsonPaths, "getAllWorkspacePackageJsonPaths");
 async function getAllWorkspacePackageJsons() {
@@ -253312,7 +253516,7 @@ __name(exec2, "exec");
 
 // src/commands/create_workspace.ts
 var import_fs_extra24 = __toESM(require_lib(), 1);
-var import_upath28 = __toESM(require_upath(), 1);
+var import_upath33 = __toESM(require_upath(), 1);
 
 // src/lib/cliExec.ts
 var import_node_child_process9 = require("node:child_process");
@@ -253336,15 +253540,15 @@ function create_libs_workspace() {
 }
 __name(create_libs_workspace, "create_libs_workspace");
 function action(workspaceName, options = {}) {
-  const CWD = import_upath28.default.normalize(process.cwd());
-  const rootPath = import_upath28.default.join(CWD, "libs", workspaceName);
-  const srcPath = import_upath28.default.join(rootPath, "src");
-  const eslintConfigJsPath = import_upath28.default.join(rootPath, "eslint.config.mjs");
-  const packageJsonPath = import_upath28.default.join(rootPath, "package.json");
-  const esbuildMjsPath = import_upath28.default.join(rootPath, "esbuild.mjs");
-  const readmeMdPath = import_upath28.default.join(rootPath, "README.md");
-  const tsconfigJsonPath = import_upath28.default.join(rootPath, "tsconfig.json");
-  const indexTsPath = import_upath28.default.join(srcPath, "index.ts");
+  const CWD = import_upath33.default.normalize(process.cwd());
+  const rootPath = import_upath33.default.join(CWD, "libs", workspaceName);
+  const srcPath = import_upath33.default.join(rootPath, "src");
+  const eslintConfigJsPath = import_upath33.default.join(rootPath, "eslint.config.mjs");
+  const packageJsonPath = import_upath33.default.join(rootPath, "package.json");
+  const esbuildMjsPath = import_upath33.default.join(rootPath, "esbuild.mjs");
+  const readmeMdPath = import_upath33.default.join(rootPath, "README.md");
+  const tsconfigJsonPath = import_upath33.default.join(rootPath, "tsconfig.json");
+  const indexTsPath = import_upath33.default.join(srcPath, "index.ts");
   const repoRootPackageJson = import_fs_extra24.default.readJsonSync(repoRootPackageJsonPath);
   const repoScope = repoRootPackageJson.name;
   const scopedLibraryName = `@${repoScope}/${workspaceName}`;
@@ -253406,12 +253610,12 @@ __name(missing_tsdoc_files, "missing_tsdoc_files");
 var import_fs_extra25 = __toESM(require_lib(), 1);
 
 // src/lib/getEmptyWsFiles.ts
-var import_upath29 = __toESM(require_upath(), 1);
+var import_upath34 = __toESM(require_upath(), 1);
 async function getEmptyWsFiles() {
   return (await glob("{libs,apps}/**/*", { withFileTypes: true, stat: true })).filter((d) => {
     return d.isFile() && d.size === 0;
   }).map((d) => {
-    return import_upath29.default.relative(process.cwd(), import_upath29.default.joinSafe(d.parentPath, d.name));
+    return import_upath34.default.relative(process.cwd(), import_upath34.default.joinSafe(d.parentPath, d.name));
   });
 }
 __name(getEmptyWsFiles, "getEmptyWsFiles");