@monorepolint/utils 0.5.0-alpha.1 → 0.5.0-alpha.103

package/build/js/index.js

@@ -0,0 +1,957 @@
+var __accessCheck = (obj, member, msg) => {
+  if (!member.has(obj))
+    throw TypeError("Cannot " + msg);
+};
+var __privateGet = (obj, member, getter) => {
+  __accessCheck(obj, member, "read from private field");
+  return getter ? getter.call(obj) : member.get(obj);
+};
+var __privateAdd = (obj, member, value) => {
+  if (member.has(obj))
+    throw TypeError("Cannot add the same private member more than once");
+  member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+};
+var __privateSet = (obj, member, value, setter) => {
+  __accessCheck(obj, member, "write to private field");
+  setter ? setter.call(obj, value) : member.set(obj, value);
+  return value;
+};
+var __privateMethod = (obj, member, method) => {
+  __accessCheck(obj, member, "access private method");
+  return method;
+};
+
+// src/getWorkspacePackageDirs.ts
+import { existsSync } from "fs";
+import * as glob from "glob";
+import * as path from "path";
+import * as fs from "fs";
+import * as readYamlFile from "read-yaml-file";
+import { findPackages } from "find-packages";
+async function findPNPMWorkspacePackages(workspaceRoot) {
+  workspaceRoot = fs.realpathSync(workspaceRoot);
+  const workspaceManifest = await readYamlFile.default(
+    path.join(workspaceRoot, "pnpm-workspace.yaml")
+  );
+  return findPackages(workspaceRoot, {
+    ignore: ["**/node_modules/**", "**/bower_components/**"],
+    includeRoot: true,
+    patterns: workspaceManifest.packages
+  });
+}
+async function getWorkspacePackageDirs(host, workspaceDir, resolvePaths = false) {
+  const packageJson = host.readJson(path.join(workspaceDir, "package.json"));
+  const isPnpmWorkspace = host.exists(path.join(workspaceDir, "pnpm-workspace.yaml"));
+  if (isPnpmWorkspace) {
+    const workspacePackages = await findPNPMWorkspacePackages(workspaceDir);
+    if (workspacePackages.length === 0) {
+      throw new Error("Invalid workspaceDir: " + workspaceDir);
+    }
+    return workspacePackages.map((project) => project.dir).filter((d) => d !== workspaceDir);
+  }
+  if (!packageJson.workspaces) {
+    throw new Error("Unsupported! Monorepo is not backed by either pnpm nor yarn workspaces.");
+  }
+  const ret = [];
+  const packageGlobs = Array.isArray(packageJson.workspaces) ? packageJson.workspaces : packageJson.workspaces.packages || [];
+  for (const pattern of packageGlobs) {
+    for (const packagePath of glob.sync(pattern, { cwd: workspaceDir })) {
+      const packageJsonPath = path.join(workspaceDir, packagePath, "package.json");
+      if (existsSync(packageJsonPath)) {
+        if (resolvePaths === true) {
+          ret.push(path.resolve(path.join(workspaceDir, packagePath)));
+        } else {
+          ret.push(packagePath);
+        }
+      }
+    }
+  }
+  return ret;
+}
+
+// src/mutateJson.ts
+function mutateJson(path4, host, mutator) {
+  let file = host.readJson(path4);
+  file = mutator(file);
+  host.writeJson(path4, file);
+}
+
+// src/findWorkspaceDir.ts
+import * as path2 from "path";
+import * as fs2 from "fs";
+import { findUp } from "find-up";
+async function findPnpmWorkspaceDir(cwd) {
+  const workspaceManifestLocation = await findUp("pnpm-workspace.yaml", {
+    cwd: await fs2.promises.realpath(cwd)
+  });
+  return workspaceManifestLocation && path2.dirname(workspaceManifestLocation);
+}
+async function findWorkspaceDir(host, dir) {
+  const maybePnpmWorkspaceDir = await findPnpmWorkspaceDir(dir);
+  if (maybePnpmWorkspaceDir != null) {
+    return maybePnpmWorkspaceDir;
+  }
+  const packagePath = path2.join(dir, "package.json");
+  if (host.exists(packagePath)) {
+    const packageJson = host.readJson(packagePath);
+    if (packageJson.workspaces !== void 0) {
+      return dir;
+    }
+  }
+  const nextDir = path2.normalize(path2.join(dir, ".."));
+  if (nextDir === dir) {
+    return void 0;
+  }
+  return findWorkspaceDir(host, nextDir);
+}
+
+// src/getPackageNameToDir.ts
+import { join as pathJoin } from "path";
+async function getPackageNameToDir(host, workspaceDir, resolvePaths = false) {
+  const ret = /* @__PURE__ */ new Map();
+  const workspacePackages = await getWorkspacePackageDirs(host, workspaceDir, resolvePaths);
+  for (const packageDir of workspacePackages) {
+    const packagePath = pathJoin(packageDir, "package.json");
+    const { name } = host.readJson(packagePath);
+    if (name === void 0) {
+      throw new Error(`Package needs a name: ${packagePath}`);
+    }
+    ret.set(name, packageDir);
+  }
+  return ret;
+}
+
+// src/SimpleHost.ts
+import * as realFs from "fs";
+var SimpleHost = class {
+  constructor(fs3 = realFs) {
+    this.fs = fs3;
+  }
+  mkdir(directoryPath, opts) {
+    this.fs.mkdirSync(directoryPath, { recursive: opts?.recursive ?? false });
+  }
+  rmdir(directoryPath) {
+    this.fs.rmdirSync(directoryPath);
+  }
+  exists(path4) {
+    return this.fs.existsSync(path4);
+  }
+  writeFile(path4, body, opts) {
+    if (opts) {
+      this.fs.writeFileSync(path4, body, { encoding: opts.encoding });
+    } else {
+      this.fs.writeFileSync(path4, body);
+    }
+  }
+  readFile(path4, opts) {
+    if (opts?.asJson) {
+      return JSON.parse(this.fs.readFileSync(path4, "utf-8"));
+    }
+    return this.fs.readFileSync(path4, opts?.encoding);
+  }
+  deleteFile(path4) {
+    this.fs.unlinkSync(path4);
+  }
+  readJson(filename) {
+    const contents = this.fs.readFileSync(filename, "utf-8");
+    return JSON.parse(contents);
+  }
+  writeJson(path4, o) {
+    return this.fs.writeFileSync(path4, JSON.stringify(o, void 0, 2) + "\n");
+  }
+  flush() {
+    return Promise.resolve();
+  }
+};
+
+// src/CachingHost.ts
+import * as realFs2 from "fs";
+import * as path3 from "path";
+function assertNoTombstone(node) {
+  if (node.tombstone) {
+    throw new Error(`Unexpected tombstone ${JSON.stringify(node)}`);
+  }
+}
+function assertNotType(node, type) {
+  if (node.type === type) {
+    throw new Error(`Unexpected node type ${JSON.stringify(node)}`);
+  }
+}
+function assertType(node, type) {
+  if (node.type !== type) {
+    throw new Error(`Unexpected node type ${JSON.stringify(node)}`);
+  }
+}
+function assertExists(node) {
+  if (!node) {
+    throw new Error(`Expected node to exist`);
+  }
+}
+function assertHasParent(node) {
+  if (!node.parent) {
+    throw new Error("Expected node to have a parent directory");
+  }
+}
+var _trees, _replaceNode, replaceNode_fn, _unstubDirectory, unstubDirectory_fn, _stubify, stubify_fn, _getNearestAncestorNode, getNearestAncestorNode_fn, _getNode, getNode_fn, _getNodeResolvingSymlinks, getNodeResolvingSymlinks_fn, _flushFileNode, flushFileNode_fn, _flushSymlinkNode, flushSymlinkNode_fn, _flushDirNode, flushDirNode_fn;
+var CachingHost = class {
+  constructor(fs3 = realFs2) {
+    this.fs = fs3;
+    __privateAdd(this, _replaceNode);
+    __privateAdd(this, _unstubDirectory);
+    __privateAdd(this, _stubify);
+    __privateAdd(this, _getNearestAncestorNode);
+    __privateAdd(this, _getNode);
+    __privateAdd(this, _getNodeResolvingSymlinks);
+    __privateAdd(this, _flushFileNode);
+    __privateAdd(this, _flushSymlinkNode);
+    __privateAdd(this, _flushDirNode);
+    __privateAdd(this, _trees, /* @__PURE__ */ new Map());
+  }
+  mkdir(filePath, opts = { recursive: false }) {
+    const canonicalPath = path3.resolve(filePath);
+    const { node, pathWithSymlinks } = __privateMethod(this, _getNearestAncestorNode, getNearestAncestorNode_fn).call(this, canonicalPath);
+    if (filePath === pathWithSymlinks) {
+      assertType(node, "dir");
+      assertHasParent(node);
+      if (!node.tombstone)
+        return;
+    } else if (path3.dirname(filePath) === pathWithSymlinks) {
+      assertType(node, "dir");
+      assertNoTombstone(node);
+      node.dir.set(path3.basename(filePath), {
+        type: "dir",
+        fullPath: filePath,
+        parent: node,
+        dir: /* @__PURE__ */ new Map(),
+        needsFlush: true
+      });
+      return;
+    }
+    if (!opts.recursive && path3.dirname(canonicalPath) !== pathWithSymlinks) {
+      throw new Error("no such file or directory");
+    }
+    const rootPath = pathWithSymlinks;
+    let maybePath = canonicalPath;
+    const toMake = [];
+    while (maybePath !== rootPath) {
+      toMake.unshift(path3.resolve(node.fullPath, path3.relative(rootPath, maybePath)));
+      maybePath = path3.dirname(maybePath);
+    }
+    for (const dirToMake of toMake) {
+      this.mkdir(dirToMake);
+    }
+  }
+  rmdir(directoryPath) {
+    const node = __privateMethod(this, _getNode, getNode_fn).call(this, directoryPath);
+    if (!node || node.tombstone) {
+      return;
+    }
+    assertType(node, "dir");
+    if (node.stub) {
+      __privateMethod(this, _unstubDirectory, unstubDirectory_fn).call(this, node);
+    }
+    if (node.dir.size === 0) {
+      __privateMethod(this, _replaceNode, replaceNode_fn).call(this, node, {
+        type: "dir",
+        tombstone: true,
+        needsFlush: true
+      });
+    } else {
+      throw new Error("directory not empty");
+    }
+  }
+  exists(filePath) {
+    const node = __privateMethod(this, _getNode, getNode_fn).call(this, filePath);
+    return !!node && !node.tombstone;
+  }
+  readFile(filePath, opts) {
+    let node = __privateMethod(this, _getNodeResolvingSymlinks, getNodeResolvingSymlinks_fn).call(this, filePath);
+    if (!node) {
+      return void 0;
+    }
+    assertNotType(node, "dir");
+    assertNoTombstone(node);
+    if (node.stub) {
+      node = __privateMethod(this, _replaceNode, replaceNode_fn).call(this, node, {
+        type: "file",
+        file: this.fs.readFileSync(filePath),
+        needsFlush: false
+      });
+    }
+    if (!opts) {
+      return Buffer.from(node.file);
+    } else if (opts.asJson) {
+      return JSON.parse(node.file.toString("utf-8"));
+    } else {
+      return node.file.toString(opts.encoding);
+    }
+  }
+  writeFile(filePath, body, opts) {
+    const fileContentsAsBuffer = typeof body === "string" ? Buffer.from(body, opts?.encoding) : Buffer.from(body);
+    const canonicalPath = path3.resolve(filePath);
+    const existingNode = __privateMethod(this, _getNodeResolvingSymlinks, getNodeResolvingSymlinks_fn).call(this, canonicalPath);
+    if (existingNode) {
+      if (existingNode.type === "dir") {
+        throw new Error("cant write file to a dir");
+      }
+      __privateMethod(this, _replaceNode, replaceNode_fn).call(this, existingNode, {
+        file: fileContentsAsBuffer,
+        type: "file",
+        needsFlush: true
+      });
+      return;
+    }
+    const maybeDirNode = __privateMethod(this, _getNodeResolvingSymlinks, getNodeResolvingSymlinks_fn).call(this, path3.dirname(canonicalPath));
+    assertExists(maybeDirNode);
+    assertType(maybeDirNode, "dir");
+    assertNoTombstone(maybeDirNode);
+    maybeDirNode.dir.set(path3.basename(canonicalPath), {
+      type: "file",
+      fullPath: canonicalPath,
+      parent: maybeDirNode,
+      file: fileContentsAsBuffer,
+      needsFlush: true
+    });
+  }
+  deleteFile(filePath) {
+    const canonicalPath = path3.resolve(filePath);
+    const node = __privateMethod(this, _getNode, getNode_fn).call(this, canonicalPath);
+    if (!node || node.type === "file" && node.tombstone === true)
+      return;
+    assertNotType(node, "dir");
+    __privateMethod(this, _replaceNode, replaceNode_fn).call(this, node, {
+      type: "file",
+      tombstone: true,
+      needsFlush: true
+    });
+  }
+  readJson(filePath) {
+    return this.readFile(filePath, { asJson: true });
+  }
+  writeJson(filePath, o) {
+    return this.writeFile(filePath, JSON.stringify(o, void 0, 2) + "\n", {
+      encoding: "utf-8"
+    });
+  }
+  flush() {
+    const promises2 = [];
+    for (const rootNode of __privateGet(this, _trees).values()) {
+      promises2.push(__privateMethod(this, _flushDirNode, flushDirNode_fn).call(this, rootNode));
+    }
+    return Promise.all(promises2);
+  }
+};
+_trees = new WeakMap();
+_replaceNode = new WeakSet();
+replaceNode_fn = function(node, partialNewNode) {
+  if (!node.parent)
+    throw new Error("Cannot replace root node");
+  const newNode = {
+    ...partialNewNode,
+    fullPath: node.fullPath,
+    parent: node.parent,
+    dir: node.dir
+  };
+  node.parent.dir.set(path3.basename(node.fullPath), newNode);
+  return newNode;
+};
+_unstubDirectory = new WeakSet();
+unstubDirectory_fn = function(node) {
+  for (const child of this.fs.readdirSync(node.fullPath)) {
+    __privateMethod(this, _getNode, getNode_fn).call(this, path3.join(node.fullPath, child));
+  }
+  node.stub = false;
+};
+_stubify = new WeakSet();
+stubify_fn = function(filePath, parent) {
+  const canonicalPath = path3.resolve(filePath);
+  if (!parent && canonicalPath !== path3.parse(canonicalPath).root) {
+    throw new Error(`parent can only be null if path is root. Instead got: ${canonicalPath}`);
+  }
+  const stat = this.fs.lstatSync(canonicalPath);
+  let node;
+  if (stat.isDirectory()) {
+    node = {
+      fullPath: canonicalPath,
+      type: "dir",
+      stub: true,
+      dir: /* @__PURE__ */ new Map(),
+      parent,
+      needsFlush: false
+    };
+  } else if (stat.isSymbolicLink()) {
+    node = {
+      fullPath: canonicalPath,
+      type: "symlink",
+      symlink: this.fs.readlinkSync(canonicalPath),
+      parent,
+      needsFlush: false
+    };
+  } else if (stat.isFile()) {
+    node = {
+      fullPath: canonicalPath,
+      type: "file",
+      stub: true,
+      parent,
+      needsFlush: false
+    };
+  } else {
+    throw new Error(`what is not a file nor symlink nor directory? nothing we care about: ${canonicalPath}`);
+  }
+  if (!parent && node.type === "dir") {
+    __privateGet(this, _trees).set(canonicalPath, node);
+    return node;
+  } else if (parent) {
+    parent.dir.set(path3.basename(canonicalPath), node);
+  } else {
+    throw new Error(`root can only be a dir, got ${JSON.stringify(node)} for path: ${canonicalPath}`);
+  }
+  return node;
+};
+_getNearestAncestorNode = new WeakSet();
+getNearestAncestorNode_fn = function(filePath) {
+  const canonicalPath = path3.resolve(filePath);
+  const { root } = path3.parse(canonicalPath);
+  const parts = [];
+  let maybePath = canonicalPath;
+  while (maybePath !== root) {
+    parts.unshift(path3.basename(maybePath));
+    maybePath = path3.dirname(maybePath);
+  }
+  let curPath = root;
+  let curNode = __privateGet(this, _trees).get(root) ?? __privateMethod(this, _stubify, stubify_fn).call(this, curPath, void 0);
+  try {
+    for (const part of parts) {
+      assertNoTombstone(curNode);
+      assertNotType(curNode, "file");
+      if (curNode.type === "symlink") {
+        const linkedNode = __privateMethod(this, _getNodeResolvingSymlinks, getNodeResolvingSymlinks_fn).call(this, path3.resolve(path3.dirname(curPath), curNode.symlink));
+        assertExists(linkedNode);
+        assertNoTombstone(linkedNode);
+        assertType(linkedNode, "dir");
+        curNode = linkedNode;
+      }
+      assertType(curNode, "dir");
+      curNode = curNode.dir.get(part) ?? __privateMethod(this, _stubify, stubify_fn).call(this, path3.join(curNode.fullPath, part), curNode);
+      curPath = path3.join(curPath, part);
+    }
+  } catch (e) {
+  }
+  return { pathWithSymlinks: curPath, node: curNode };
+};
+_getNode = new WeakSet();
+getNode_fn = function(filePath) {
+  const canonicalPath = path3.resolve(filePath);
+  const { pathWithSymlinks, node } = __privateMethod(this, _getNearestAncestorNode, getNearestAncestorNode_fn).call(this, canonicalPath);
+  if (pathWithSymlinks === canonicalPath) {
+    return node;
+  }
+  return void 0;
+};
+_getNodeResolvingSymlinks = new WeakSet();
+getNodeResolvingSymlinks_fn = function(filePath, follows = 100) {
+  const node = __privateMethod(this, _getNode, getNode_fn).call(this, filePath);
+  if (!node || node.type !== "symlink")
+    return node;
+  if (follows === 0)
+    throw new Error("Exhausted symlink follows");
+  return __privateMethod(this, _getNodeResolvingSymlinks, getNodeResolvingSymlinks_fn).call(this, node.symlink, follows--);
+};
+_flushFileNode = new WeakSet();
+flushFileNode_fn = async function(node) {
+  if (node.tombstone) {
+    try {
+      await this.fs.promises.access(node.fullPath);
+      return this.fs.promises.unlink(node.fullPath);
+    } catch (e) {
+      return;
+    }
+  } else if (node.stub === true || node.needsFlush === false) {
+    return;
+  } else {
+    return this.fs.promises.writeFile(node.fullPath, node.file);
+  }
+};
+_flushSymlinkNode = new WeakSet();
+flushSymlinkNode_fn = async function(node) {
+  if (!node.needsFlush)
+    return;
+  try {
+    const linkValue = await this.fs.promises.readlink(node.fullPath);
+    if (linkValue === node.symlink) {
+      return;
+    }
+  } catch (e) {
+  }
+  return this.fs.promises.symlink(node.symlink, node.fullPath);
+};
+_flushDirNode = new WeakSet();
+flushDirNode_fn = async function(node) {
+  if (!node.tombstone && node.needsFlush) {
+    try {
+      await this.fs.promises.access(node.fullPath);
+    } catch (e) {
+      await this.fs.promises.mkdir(node.fullPath);
+    }
+  }
+  const promises2 = [];
+  for (const child of node.dir.values()) {
+    if (node.tombstone && !child.tombstone) {
+      throw new Error("Unexpected failure during sanity check. A non-deleted child is on a deleted dir");
+    }
+    if (child.type === "dir") {
+      promises2.push(__privateMethod(this, _flushDirNode, flushDirNode_fn).call(this, child));
+    } else if (child.type === "file") {
+      promises2.push(__privateMethod(this, _flushFileNode, flushFileNode_fn).call(this, child));
+    } else if (child.type === "symlink") {
+      promises2.push(__privateMethod(this, _flushSymlinkNode, flushSymlinkNode_fn).call(this, child));
+    } else {
+      throw new Error("should never happen");
+    }
+  }
+  await Promise.all(promises2);
+  if (node.tombstone) {
+    return this.fs.promises.rmdir(node.fullPath);
+  }
+  return;
+};
+
+// src/matchesAnyGlob.ts
+import micromatch from "micromatch";
+
+// src/nanosecondsToSanity.ts
+function nanosecondsToSanity(n, precision = 9) {
+  return n / BigInt(1e9) + "." + ("" + n % BigInt(1e9)).padStart(9, "0").substring(0, precision) + "s";
+}
+
+// src/Table.ts
+var _rows, _config, _columnWidths, _footer, _footerRowConfig, _totalWidth, _sumColumn, sumColumn_fn, _updateFooterRow, updateFooterRow_fn, _calculateColumnWidths, calculateColumnWidths_fn, _printSeparator, printSeparator_fn, _printHeaderRow, printHeaderRow_fn, _printFooterRow, printFooterRow_fn, _getCellValueAsString, getCellValueAsString_fn, _getCellValueAligned, getCellValueAligned_fn;
+var Table = class {
+  constructor(config) {
+    __privateAdd(this, _sumColumn);
+    __privateAdd(this, _updateFooterRow);
+    __privateAdd(this, _calculateColumnWidths);
+    __privateAdd(this, _printSeparator);
+    __privateAdd(this, _printHeaderRow);
+    __privateAdd(this, _printFooterRow);
+    __privateAdd(this, _getCellValueAsString);
+    __privateAdd(this, _getCellValueAligned);
+    __privateAdd(this, _rows, []);
+    __privateAdd(this, _config, void 0);
+    __privateAdd(this, _columnWidths, []);
+    __privateAdd(this, _footer, []);
+    __privateAdd(this, _footerRowConfig, void 0);
+    __privateAdd(this, _totalWidth, 0);
+    __privateSet(this, _config, {
+      padding: 2,
+      ...config
+    });
+    __privateGet(this, _columnWidths).fill(0, 0, config.columns.length);
+    if (config.showFooter) {
+      __privateSet(this, _footerRowConfig, []);
+      for (const columnConfig of config.columns) {
+        if (columnConfig.footer === void 0) {
+          throw new Error("Must specify footer fields when showFooter is true");
+        } else if (typeof columnConfig.footer === "string") {
+          __privateGet(this, _footerRowConfig).push({
+            type: "string",
+            alignment: "left",
+            aggregate: "static",
+            value: columnConfig.footer
+          });
+        } else if ("value" in columnConfig.footer) {
+          __privateGet(this, _footerRowConfig).push({
+            type: "string",
+            alignment: "left",
+            ...columnConfig.footer
+          });
+        } else if ("aggregate" in columnConfig.footer) {
+          if (columnConfig.type !== "bigint")
+            throw new Error("expecting bigint for aggregate");
+          __privateGet(this, _footerRowConfig).push({
+            type: columnConfig.type,
+            renderAs: columnConfig.renderAs,
+            precision: columnConfig.precision,
+            alignment: "right",
+            ...columnConfig.footer
+          });
+        }
+      }
+    }
+  }
+  addRow(...data) {
+    __privateGet(this, _rows).push(data);
+  }
+  print() {
+    if (__privateGet(this, _config).sortColumn !== void 0) {
+    }
+    __privateMethod(this, _updateFooterRow, updateFooterRow_fn).call(this);
+    __privateMethod(this, _calculateColumnWidths, calculateColumnWidths_fn).call(this);
+    console.log();
+    console.log(`${__privateGet(this, _config).title}`);
+    console.log("".padStart(__privateGet(this, _totalWidth), "="));
+    const paddingString = "".padStart(__privateGet(this, _config).padding, " ");
+    if (__privateGet(this, _config).showHeader) {
+      __privateMethod(this, _printHeaderRow, printHeaderRow_fn).call(this);
+    }
+    for (let r = 0; r < __privateGet(this, _rows).length; r++) {
+      let rowText = "";
+      for (let c = 0; c < __privateGet(this, _config).columns.length; c++) {
+        rowText += this.getEntryAsStringAligned(c, r) + paddingString;
+      }
+      rowText.trim();
+      console.log(rowText);
+    }
+    if (__privateGet(this, _config).showFooter)
+      __privateMethod(this, _printFooterRow, printFooterRow_fn).call(this);
+    console.log();
+  }
+  getEntryAsString(colNum, rowNum) {
+    const config = __privateGet(this, _config).columns[colNum];
+    if (config.type === "bigint" && config.renderAs === "nanoseconds") {
+      return nanosecondsToSanity(__privateGet(this, _rows)[rowNum][colNum], config.precision ?? 9);
+    } else {
+      return "" + __privateGet(this, _rows)[rowNum][colNum];
+    }
+  }
+  getEntryAsStringAligned(colNum, rowNum) {
+    const config = __privateGet(this, _config).columns[colNum];
+    let result;
+    if (config.type === "bigint" && config.renderAs === "nanoseconds") {
+      result = nanosecondsToSanity(__privateGet(this, _rows)[rowNum][colNum], config.precision ?? 9);
+    } else {
+      result = "" + __privateGet(this, _rows)[rowNum][colNum];
+    }
+    if (config.alignment === "left") {
+      return result.padEnd(__privateGet(this, _columnWidths)[colNum]);
+    } else {
+      return result.padStart(__privateGet(this, _columnWidths)[colNum]);
+    }
+  }
+  getColumnWidth(colNum, config) {
+    let maxWidth = Math.max(
+      (config.header ?? "").length,
+      __privateGet(this, _footer) && __privateGet(this, _footerRowConfig) ? __privateMethod(this, _getCellValueAsString, getCellValueAsString_fn).call(this, __privateGet(this, _footer)[colNum], __privateGet(this, _footerRowConfig)[colNum]).length : 0
+    );
+    for (let r = 0; r < __privateGet(this, _rows).length; r++) {
+      maxWidth = Math.max(maxWidth, this.getEntryAsString(colNum, r).length);
+    }
+    return maxWidth;
+  }
+};
+_rows = new WeakMap();
+_config = new WeakMap();
+_columnWidths = new WeakMap();
+_footer = new WeakMap();
+_footerRowConfig = new WeakMap();
+_totalWidth = new WeakMap();
+_sumColumn = new WeakSet();
+sumColumn_fn = function(c) {
+  let total = BigInt(0);
+  for (const row of __privateGet(this, _rows)) {
+    total += row[c];
+  }
+  return total;
+};
+_updateFooterRow = new WeakSet();
+updateFooterRow_fn = function() {
+  const footerRowConfig = __privateGet(this, _footerRowConfig);
+  if (footerRowConfig) {
+    for (let c = 0; c < footerRowConfig.length; c++) {
+      const footerColConfig = footerRowConfig[c];
+      switch (footerColConfig.aggregate) {
+        case "sum":
+          __privateGet(this, _footer)[c] = __privateMethod(this, _sumColumn, sumColumn_fn).call(this, c);
+          break;
+        case "average":
+          __privateGet(this, _footer)[c] = __privateMethod(this, _sumColumn, sumColumn_fn).call(this, c) / BigInt(__privateGet(this, _rows).length);
+          break;
+        case "static":
+          __privateGet(this, _footer)[c] = footerColConfig.value;
+          break;
+      }
+    }
+  }
+};
+_calculateColumnWidths = new WeakSet();
+calculateColumnWidths_fn = function() {
+  __privateGet(this, _columnWidths).fill(0, 0, __privateGet(this, _config).columns.length);
+  for (let c = 0; c < __privateGet(this, _config).columns.length; c++) {
+    const colConfig = __privateGet(this, _config).columns[c];
+    __privateGet(this, _columnWidths)[c] = Math.max(
+      (__privateGet(this, _config).columns[c].header ?? "").length,
+      ...__privateGet(this, _rows).map((a) => __privateMethod(this, _getCellValueAsString, getCellValueAsString_fn).call(this, a[c], colConfig).length),
+      __privateGet(this, _footer) && __privateGet(this, _footerRowConfig) ? __privateMethod(this, _getCellValueAsString, getCellValueAsString_fn).call(this, __privateGet(this, _footer)?.[c] ?? "", __privateGet(this, _footerRowConfig)[c]).length : 0
+    );
+  }
+  __privateSet(this, _totalWidth, 0);
+  for (const colWidth of __privateGet(this, _columnWidths)) {
+    __privateSet(this, _totalWidth, __privateGet(this, _totalWidth) + colWidth);
+  }
+  __privateSet(this, _totalWidth, __privateGet(this, _totalWidth) + (__privateGet(this, _columnWidths).length - 1) * __privateGet(this, _config).padding);
+};
+_printSeparator = new WeakSet();
+printSeparator_fn = function(fillString) {
+  const paddingString = "".padStart(__privateGet(this, _config).padding, " ");
+  let hr2 = "";
+  for (let c = 0; c < __privateGet(this, _columnWidths).length; c++) {
+    hr2 += "".padStart(__privateGet(this, _columnWidths)[c], fillString) + paddingString;
+  }
+  hr2 = hr2.trimRight();
+  console.log(hr2);
+};
+_printHeaderRow = new WeakSet();
+printHeaderRow_fn = function() {
+  if (__privateGet(this, _config).showHeader) {
+    const colConfigs = __privateGet(this, _config).columns;
+    const paddingString = "".padStart(__privateGet(this, _config).padding, " ");
+    let hr = "";
+    for (let c = 0; c < colConfigs.length; c++) {
+      const heading = colConfigs[c].header ?? "";
+      hr += heading.padEnd(__privateGet(this, _columnWidths)[c], " ") + paddingString;
+    }
+    hr = hr.trimRight();
+    console.log(hr);
+    __privateMethod(this, _printSeparator, printSeparator_fn).call(this, "-");
+  }
+};
+_printFooterRow = new WeakSet();
+printFooterRow_fn = function() {
+  const footerRow = __privateGet(this, _footer);
+  if (footerRow) {
+    __privateMethod(this, _printSeparator, printSeparator_fn).call(this, "=");
+    const paddingString = "".padStart(__privateGet(this, _config).padding, " ");
+    let hr = "";
+    for (let c = 0; c < footerRow.length; c++) {
+      hr += __privateMethod(this, _getCellValueAligned, getCellValueAligned_fn).call(this, footerRow[c], __privateGet(this, _footerRowConfig)[c], c) + paddingString;
+    }
+    hr = hr.trimRight();
+    console.log(hr);
+  }
+};
+_getCellValueAsString = new WeakSet();
+getCellValueAsString_fn = function(value, config) {
+  if (config.type === "bigint" && config.renderAs === "nanoseconds") {
+    return nanosecondsToSanity(value, config.precision ?? 9);
+  } else {
+    return "" + value;
+  }
+};
+_getCellValueAligned = new WeakSet();
+getCellValueAligned_fn = function(value, config, column) {
+  let result;
+  if (config.type === "bigint" && config.renderAs === "nanoseconds") {
+    result = nanosecondsToSanity(value, config.precision ?? 9);
+  } else {
+    result = "" + value;
+  }
+  if (config.alignment === "left") {
+    return result.padEnd(__privateGet(this, _columnWidths)[column]);
+  } else {
+    return result.padStart(__privateGet(this, _columnWidths)[column]);
+  }
+};
+
+// src/matchesAnyGlob.ts
+var cache = /* @__PURE__ */ new Map();
+var singleMatcherCache = /* @__PURE__ */ new Map();
+var compiledGlobCache = /* @__PURE__ */ new Map();
+var haystackMiss = 0;
+var haystackHit = 0;
+var matchTime = BigInt(0);
+var singleMatcherHits = 0;
+var singleMatcherMisses = 0;
+var singleMatcherSaves = 0;
+var matchesAnyGlob = function matchesAnyGlobFunc(needle, haystack) {
+  matchTime -= process.hrtime.bigint();
+  let cacheForHaystack = cache.get(haystack);
+  if (cacheForHaystack === void 0) {
+    cacheForHaystack = /* @__PURE__ */ new Map();
+    cache.set(haystack, cacheForHaystack);
+  }
+  let result = cacheForHaystack.get(needle);
+  if (result === void 0) {
+    haystackMiss++;
+    result = false;
+    for (const pattern of haystack) {
+      let patternCache = singleMatcherCache.get(pattern);
+      if (patternCache === void 0) {
+        patternCache = /* @__PURE__ */ new Map();
+        singleMatcherCache.set(pattern, patternCache);
+      }
+      result = patternCache.get(needle);
+      if (result === void 0) {
+        let regexp = compiledGlobCache.get(pattern);
+        if (regexp === void 0) {
+          regexp = micromatch.makeRe(pattern);
+          compiledGlobCache.set(pattern, regexp);
+        }
+        singleMatcherMisses++;
+        result = regexp.test(needle);
+        patternCache.set(needle, result);
+      } else {
+        singleMatcherHits++;
+        singleMatcherSaves++;
+      }
+      if (result)
+        break;
+    }
+    cacheForHaystack.set(needle, result);
+  } else {
+    singleMatcherSaves += haystack.length;
+    haystackHit++;
+  }
+  matchTime += process.hrtime.bigint();
+  return result;
+};
+matchesAnyGlob.printStats = () => {
+  const table = new Table({
+    title: "matchesAnyGlob stats",
+    showHeader: true,
+    showFooter: false,
+    columns: [
+      { header: "Stat", type: "string" },
+      { header: "Value", type: "string" }
+    ]
+  });
+  table.addRow("Haystack Miss", "" + haystackMiss);
+  table.addRow("Haystack Hit", "" + haystackHit);
+  table.addRow("Single Glob Hits", "" + singleMatcherHits);
+  table.addRow("Single Glob Misses", "" + singleMatcherMisses);
+  table.addRow("Single Glob Saves", "" + singleMatcherSaves);
+  table.addRow("Total Time", nanosecondsToSanity(matchTime, 6));
+  table.print();
+};
+
+// src/AggregateTiming.ts
+var _data, _last;
+var AggregateTiming = class {
+  constructor(title) {
+    this.title = title;
+    __privateAdd(this, _data, /* @__PURE__ */ new Map());
+    __privateAdd(this, _last, void 0);
+  }
+  start(name) {
+    const time = process.hrtime.bigint();
+    if (__privateGet(this, _last)) {
+      __privateGet(this, _last).total += time;
+    }
+    let data = __privateGet(this, _data).get(name);
+    if (data === void 0) {
+      data = { count: 1, total: -time };
+      __privateGet(this, _data).set(name, data);
+    } else {
+      data.total -= time;
+      data.count++;
+    }
+    __privateSet(this, _last, data);
+  }
+  stop() {
+    const time = process.hrtime.bigint();
+    if (__privateGet(this, _last)) {
+      __privateGet(this, _last).total += time;
+      __privateSet(this, _last, void 0);
+    }
+  }
+  printResults() {
+    const table = new Table({
+      sortColumn: -1,
+      showFooter: true,
+      showHeader: true,
+      title: this.title,
+      columns: [
+        {
+          header: "Duration",
+          type: "bigint",
+          renderAs: "nanoseconds",
+          footer: { aggregate: "sum" }
+        },
+        { header: "Task", type: "string", alignment: "left", footer: "TOTAL" },
+        { header: "Count", type: "bigint", footer: { aggregate: "sum" } },
+        { header: "Avg", type: "bigint", footer: { aggregate: "average" } }
+      ]
+    });
+    for (const [name, value] of __privateGet(this, _data)) {
+      table.addRow(
+        value.total,
+        name,
+        BigInt(value.count),
+        value.total / BigInt(value.count)
+      );
+    }
+    table.print();
+  }
+};
+_data = new WeakMap();
+_last = new WeakMap();
+
+// src/Timing.ts
+var _starts;
+var Timing = class {
+  constructor(title) {
+    this.title = title;
+    __privateAdd(this, _starts, []);
+    this.stop();
+  }
+  start(name) {
+    __privateGet(this, _starts).push({ name, start: process.hrtime.bigint() });
+  }
+  stop() {
+    __privateGet(this, _starts).push({ start: process.hrtime.bigint() });
+  }
+  printResults() {
+    const table = new Table({
+      sortColumn: -1,
+      showFooter: true,
+      showHeader: true,
+      title: this.title,
+      columns: [
+        {
+          header: "Duration",
+          type: "bigint",
+          renderAs: "nanoseconds",
+          precision: 4,
+          footer: { aggregate: "sum" }
+        },
+        { header: "Task", type: "string", footer: "TOTAL" }
+      ]
+    });
+    this.stop();
+    let cur = __privateGet(this, _starts)[0];
+    for (const entry of __privateGet(this, _starts)) {
+      if (cur.name) {
+        const span = entry.start - cur.start;
+        table.addRow(span, cur.name);
+      }
+      cur = entry;
+    }
+    table.print();
+  }
+};
+_starts = new WeakMap();
+export {
+  AggregateTiming,
+  CachingHost,
+  SimpleHost,
+  Table,
+  Timing,
+  findWorkspaceDir,
+  getPackageNameToDir,
+  getWorkspacePackageDirs,
+  matchesAnyGlob,
+  mutateJson,
+  nanosecondsToSanity
+};
+/*!
+ * Copyright 2019 Palantir Technologies, Inc.
+ *
+ * Licensed under the MIT license. See LICENSE file in the project root for details.
+ *
+ */
+/*!
+ * Copyright 2022 Palantir Technologies, Inc.
+ *
+ * Licensed under the MIT license. See LICENSE file in the project root for details.
+ *
+ */
+//# sourceMappingURL=index.js.map