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

package/build/js/index.js

@@ -1,31 +1,8 @@
-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 path from "node:path";
+import * as fs from "node:fs";
 import * as readYamlFile from "read-yaml-file";
 import { findPackages } from "find-packages";
 async function findPNPMWorkspacePackages(workspaceRoot) {
@@ -128,7 +105,7 @@ var SimpleHost = class {
     this.fs = fs3;
   }
   mkdir(directoryPath, opts) {
-    this.fs.mkdirSync(directoryPath, { recursive: opts?.recursive ?? false });
+    this.fs.mkdirSync(directoryPath, { recursive: (opts == null ? void 0 : opts.recursive) ?? false });
   }
   rmdir(directoryPath) {
     this.fs.rmdirSync(directoryPath);
@@ -144,10 +121,10 @@ var SimpleHost = class {
     }
   }
   readFile(path4, opts) {
-    if (opts?.asJson) {
+    if (opts == null ? void 0 : opts.asJson) {
       return JSON.parse(this.fs.readFileSync(path4, "utf-8"));
     }
-    return this.fs.readFileSync(path4, opts?.encoding);
+    return this.fs.readFileSync(path4, opts == null ? void 0 : opts.encoding);
   }
   deleteFile(path4) {
     this.fs.unlinkSync(path4);
@@ -165,8 +142,8 @@ var SimpleHost = class {
 };
 
 // src/CachingHost.ts
-import * as realFs2 from "fs";
-import * as path3 from "path";
+import * as realFs2 from "node:fs";
+import * as path3 from "node:path";
 function assertNoTombstone(node) {
   if (node.tombstone) {
     throw new Error(`Unexpected tombstone ${JSON.stringify(node)}`);
@@ -192,24 +169,123 @@ function assertHasParent(node) {
     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());
+  }
+  #trees = /* @__PURE__ */ new Map();
+  #replaceNode(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(node) {
+    for (const child of this.fs.readdirSync(node.fullPath)) {
+      this.#getNode(path3.join(node.fullPath, child));
+    }
+    node.stub = false;
+  }
+  #stubify(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") {
+      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(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 = this.#trees.get(root) ?? this.#stubify(curPath, void 0);
+    try {
+      for (const part of parts) {
+        assertNoTombstone(curNode);
+        assertNotType(curNode, "file");
+        if (curNode.type === "symlink") {
+          const linkedNode = this.#getNodeResolvingSymlinks(path3.resolve(path3.dirname(curPath), curNode.symlink));
+          assertExists(linkedNode);
+          assertNoTombstone(linkedNode);
+          assertType(linkedNode, "dir");
+          curNode = linkedNode;
+        }
+        assertType(curNode, "dir");
+        curNode = curNode.dir.get(part) ?? this.#stubify(path3.join(curNode.fullPath, part), curNode);
+        curPath = path3.join(curPath, part);
+      }
+    } catch (e) {
+    }
+    return { pathWithSymlinks: curPath, node: curNode };
+  }
+  #getNode(filePath) {
+    const canonicalPath = path3.resolve(filePath);
+    const { pathWithSymlinks, node } = this.#getNearestAncestorNode(canonicalPath);
+    if (pathWithSymlinks === canonicalPath) {
+      return node;
+    }
+    return void 0;
+  }
+  #getNodeResolvingSymlinks(filePath, follows = 100) {
+    const node = this.#getNode(filePath);
+    if (!node || node.type !== "symlink")
+      return node;
+    if (follows === 0)
+      throw new Error("Exhausted symlink follows");
+    return this.#getNodeResolvingSymlinks(node.symlink, follows--);
   }
   mkdir(filePath, opts = { recursive: false }) {
     const canonicalPath = path3.resolve(filePath);
-    const { node, pathWithSymlinks } = __privateMethod(this, _getNearestAncestorNode, getNearestAncestorNode_fn).call(this, canonicalPath);
+    const { node, pathWithSymlinks } = this.#getNearestAncestorNode(canonicalPath);
     if (filePath === pathWithSymlinks) {
       assertType(node, "dir");
       assertHasParent(node);
@@ -242,16 +318,16 @@ var CachingHost = class {
     }
   }
   rmdir(directoryPath) {
-    const node = __privateMethod(this, _getNode, getNode_fn).call(this, directoryPath);
+    const node = this.#getNode(directoryPath);
     if (!node || node.tombstone) {
       return;
     }
     assertType(node, "dir");
     if (node.stub) {
-      __privateMethod(this, _unstubDirectory, unstubDirectory_fn).call(this, node);
+      this.#unstubDirectory(node);
     }
     if (node.dir.size === 0) {
-      __privateMethod(this, _replaceNode, replaceNode_fn).call(this, node, {
+      this.#replaceNode(node, {
         type: "dir",
         tombstone: true,
         needsFlush: true
@@ -261,18 +337,18 @@ var CachingHost = class {
     }
   }
   exists(filePath) {
-    const node = __privateMethod(this, _getNode, getNode_fn).call(this, filePath);
+    const node = this.#getNode(filePath);
     return !!node && !node.tombstone;
   }
   readFile(filePath, opts) {
-    let node = __privateMethod(this, _getNodeResolvingSymlinks, getNodeResolvingSymlinks_fn).call(this, filePath);
+    let node = this.#getNodeResolvingSymlinks(filePath);
     if (!node) {
       return void 0;
     }
     assertNotType(node, "dir");
     assertNoTombstone(node);
     if (node.stub) {
-      node = __privateMethod(this, _replaceNode, replaceNode_fn).call(this, node, {
+      node = this.#replaceNode(node, {
         type: "file",
         file: this.fs.readFileSync(filePath),
         needsFlush: false
@@ -287,21 +363,21 @@ var CachingHost = class {
     }
   }
   writeFile(filePath, body, opts) {
-    const fileContentsAsBuffer = typeof body === "string" ? Buffer.from(body, opts?.encoding) : Buffer.from(body);
+    const fileContentsAsBuffer = typeof body === "string" ? Buffer.from(body, opts == null ? void 0 : opts.encoding) : Buffer.from(body);
     const canonicalPath = path3.resolve(filePath);
-    const existingNode = __privateMethod(this, _getNodeResolvingSymlinks, getNodeResolvingSymlinks_fn).call(this, canonicalPath);
+    const existingNode = this.#getNodeResolvingSymlinks(canonicalPath);
     if (existingNode) {
       if (existingNode.type === "dir") {
         throw new Error("cant write file to a dir");
       }
-      __privateMethod(this, _replaceNode, replaceNode_fn).call(this, existingNode, {
+      this.#replaceNode(existingNode, {
         file: fileContentsAsBuffer,
         type: "file",
         needsFlush: true
       });
       return;
     }
-    const maybeDirNode = __privateMethod(this, _getNodeResolvingSymlinks, getNodeResolvingSymlinks_fn).call(this, path3.dirname(canonicalPath));
+    const maybeDirNode = this.#getNodeResolvingSymlinks(path3.dirname(canonicalPath));
     assertExists(maybeDirNode);
     assertType(maybeDirNode, "dir");
     assertNoTombstone(maybeDirNode);
@@ -315,11 +391,11 @@ var CachingHost = class {
   }
   deleteFile(filePath) {
     const canonicalPath = path3.resolve(filePath);
-    const node = __privateMethod(this, _getNode, getNode_fn).call(this, canonicalPath);
+    const node = this.#getNode(canonicalPath);
     if (!node || node.type === "file" && node.tombstone === true)
       return;
     assertNotType(node, "dir");
-    __privateMethod(this, _replaceNode, replaceNode_fn).call(this, node, {
+    this.#replaceNode(node, {
       type: "file",
       tombstone: true,
       needsFlush: true
@@ -333,187 +409,68 @@ var CachingHost = class {
       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;
+  async #flushFileNode(node) {
+    if (node.tombstone) {
+      try {
+        await this.fs.promises.access(node.fullPath);
+        return this.fs.promises.unlink(node.fullPath);
+      } catch (e) {
+        return;
       }
-      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) {
+    } else if (node.stub === true || node.needsFlush === false) {
       return;
+    } else {
+      return this.fs.promises.writeFile(node.fullPath, node.file);
     }
-  } 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) {
+  async #flushSymlinkNode(node) {
+    if (!node.needsFlush)
       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);
+      const linkValue = await this.fs.promises.readlink(node.fullPath);
+      if (linkValue === node.symlink) {
+        return;
+      }
     } catch (e) {
-      await this.fs.promises.mkdir(node.fullPath);
     }
+    return this.fs.promises.symlink(node.symlink, 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");
+  async #flushDirNode(node) {
+    if (!node.tombstone && node.needsFlush) {
+      try {
+        await this.fs.promises.access(node.fullPath);
+      } catch (e) {
+        await this.fs.promises.mkdir(node.fullPath);
+      }
     }
-    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");
+    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(this.#flushDirNode(child));
+      } else if (child.type === "file") {
+        promises2.push(this.#flushFileNode(child));
+      } else if (child.type === "symlink") {
+        promises2.push(this.#flushSymlinkNode(child));
+      } else {
+        throw new Error("should never happen");
+      }
     }
+    await Promise.all(promises2);
+    if (node.tombstone) {
+      return this.fs.promises.rmdir(node.fullPath);
+    }
+    return;
   }
-  await Promise.all(promises2);
-  if (node.tombstone) {
-    return this.fs.promises.rmdir(node.fullPath);
+  flush() {
+    const promises2 = [];
+    for (const rootNode of this.#trees.values()) {
+      promises2.push(this.#flushDirNode(rootNode));
+    }
+    return Promise.all(promises2);
   }
-  return;
 };
 
 // src/matchesAnyGlob.ts
@@ -525,42 +482,33 @@ function nanosecondsToSanity(n, precision = 9) {
 }
 
 // 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 {
+  #rows = [];
+  #config;
+  #columnWidths = [];
+  #footer = [];
+  #footerRowConfig;
+  #totalWidth = 0;
   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, {
+    this.#config = {
       padding: 2,
       ...config
-    });
-    __privateGet(this, _columnWidths).fill(0, 0, config.columns.length);
+    };
+    this.#columnWidths.fill(0, 0, config.columns.length);
     if (config.showFooter) {
-      __privateSet(this, _footerRowConfig, []);
+      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({
+          this.#footerRowConfig.push({
             type: "string",
             alignment: "left",
             aggregate: "static",
             value: columnConfig.footer
           });
         } else if ("value" in columnConfig.footer) {
-          __privateGet(this, _footerRowConfig).push({
+          this.#footerRowConfig.push({
             type: "string",
             alignment: "left",
             ...columnConfig.footer
@@ -568,7 +516,7 @@ var Table = class {
         } else if ("aggregate" in columnConfig.footer) {
           if (columnConfig.type !== "bigint")
             throw new Error("expecting bigint for aggregate");
-          __privateGet(this, _footerRowConfig).push({
+          this.#footerRowConfig.push({
             type: columnConfig.type,
             renderAs: columnConfig.renderAs,
             precision: columnConfig.precision,
@@ -580,177 +528,164 @@ var Table = class {
     }
   }
   addRow(...data) {
-    __privateGet(this, _rows).push(data);
+    this.#rows.push(data);
+  }
+  #sumColumn(c) {
+    let total = BigInt(0);
+    for (const row of this.#rows) {
+      total += row[c];
+    }
+    return total;
+  }
+  #updateFooterRow() {
+    const footerRowConfig = this.#footerRowConfig;
+    if (footerRowConfig) {
+      for (let c = 0; c < footerRowConfig.length; c++) {
+        const footerColConfig = footerRowConfig[c];
+        switch (footerColConfig.aggregate) {
+          case "sum":
+            this.#footer[c] = this.#sumColumn(c);
+            break;
+          case "average":
+            this.#footer[c] = this.#sumColumn(c) / BigInt(this.#rows.length);
+            break;
+          case "static":
+            this.#footer[c] = footerColConfig.value;
+            break;
+        }
+      }
+    }
+  }
+  #calculateColumnWidths() {
+    var _a;
+    this.#columnWidths.fill(0, 0, this.#config.columns.length);
+    for (let c = 0; c < this.#config.columns.length; c++) {
+      const colConfig = this.#config.columns[c];
+      this.#columnWidths[c] = Math.max(
+        (this.#config.columns[c].header ?? "").length,
+        ...this.#rows.map((a) => this.#getCellValueAsString(a[c], colConfig).length),
+        this.#footer && this.#footerRowConfig ? this.#getCellValueAsString(((_a = this.#footer) == null ? void 0 : _a[c]) ?? "", this.#footerRowConfig[c]).length : 0
+      );
+    }
+    this.#totalWidth = 0;
+    for (const colWidth of this.#columnWidths) {
+      this.#totalWidth += colWidth;
+    }
+    this.#totalWidth += (this.#columnWidths.length - 1) * this.#config.padding;
+  }
+  #printSeparator(fillString) {
+    const paddingString = "".padStart(this.#config.padding, " ");
+    let hr2 = "";
+    for (let c = 0; c < this.#columnWidths.length; c++) {
+      hr2 += "".padStart(this.#columnWidths[c], fillString) + paddingString;
+    }
+    hr2 = hr2.trimRight();
+    console.log(hr2);
+  }
+  #printHeaderRow() {
+    if (this.#config.showHeader) {
+      const colConfigs = this.#config.columns;
+      const paddingString = "".padStart(this.#config.padding, " ");
+      let hr = "";
+      for (let c = 0; c < colConfigs.length; c++) {
+        const heading = colConfigs[c].header ?? "";
+        hr += heading.padEnd(this.#columnWidths[c], " ") + paddingString;
+      }
+      hr = hr.trimRight();
+      console.log(hr);
+      this.#printSeparator("-");
+    }
+  }
+  #printFooterRow() {
+    const footerRow = this.#footer;
+    if (footerRow) {
+      this.#printSeparator("=");
+      const paddingString = "".padStart(this.#config.padding, " ");
+      let hr = "";
+      for (let c = 0; c < footerRow.length; c++) {
+        hr += this.#getCellValueAligned(footerRow[c], this.#footerRowConfig[c], c) + paddingString;
+      }
+      hr = hr.trimRight();
+      console.log(hr);
+    }
   }
   print() {
-    if (__privateGet(this, _config).sortColumn !== void 0) {
+    if (this.#config.sortColumn !== void 0) {
     }
-    __privateMethod(this, _updateFooterRow, updateFooterRow_fn).call(this);
-    __privateMethod(this, _calculateColumnWidths, calculateColumnWidths_fn).call(this);
+    this.#updateFooterRow();
+    this.#calculateColumnWidths();
     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);
+    console.log(`${this.#config.title}`);
+    console.log("".padStart(this.#totalWidth, "="));
+    const paddingString = "".padStart(this.#config.padding, " ");
+    if (this.#config.showHeader) {
+      this.#printHeaderRow();
     }
-    for (let r = 0; r < __privateGet(this, _rows).length; r++) {
+    for (let r = 0; r < this.#rows.length; r++) {
       let rowText = "";
-      for (let c = 0; c < __privateGet(this, _config).columns.length; c++) {
+      for (let c = 0; c < 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);
+    if (this.#config.showFooter)
+      this.#printFooterRow();
     console.log();
   }
+  #getCellValueAsString(value, config) {
+    if (config.type === "bigint" && config.renderAs === "nanoseconds") {
+      return nanosecondsToSanity(value, config.precision ?? 9);
+    } else {
+      return "" + value;
+    }
+  }
+  #getCellValueAligned(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(this.#columnWidths[column]);
+    } else {
+      return result.padStart(this.#columnWidths[column]);
+    }
+  }
   getEntryAsString(colNum, rowNum) {
-    const config = __privateGet(this, _config).columns[colNum];
+    const config = this.#config.columns[colNum];
     if (config.type === "bigint" && config.renderAs === "nanoseconds") {
-      return nanosecondsToSanity(__privateGet(this, _rows)[rowNum][colNum], config.precision ?? 9);
+      return nanosecondsToSanity(this.#rows[rowNum][colNum], config.precision ?? 9);
     } else {
-      return "" + __privateGet(this, _rows)[rowNum][colNum];
+      return "" + this.#rows[rowNum][colNum];
     }
   }
   getEntryAsStringAligned(colNum, rowNum) {
-    const config = __privateGet(this, _config).columns[colNum];
+    const config = this.#config.columns[colNum];
     let result;
     if (config.type === "bigint" && config.renderAs === "nanoseconds") {
-      result = nanosecondsToSanity(__privateGet(this, _rows)[rowNum][colNum], config.precision ?? 9);
+      result = nanosecondsToSanity(this.#rows[rowNum][colNum], config.precision ?? 9);
     } else {
-      result = "" + __privateGet(this, _rows)[rowNum][colNum];
+      result = "" + this.#rows[rowNum][colNum];
     }
     if (config.alignment === "left") {
-      return result.padEnd(__privateGet(this, _columnWidths)[colNum]);
+      return result.padEnd(this.#columnWidths[colNum]);
     } else {
-      return result.padStart(__privateGet(this, _columnWidths)[colNum]);
+      return result.padStart(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
+      this.#footer && this.#footerRowConfig ? this.#getCellValueAsString(this.#footer[colNum], this.#footerRowConfig[colNum]).length : 0
     );
-    for (let r = 0; r < __privateGet(this, _rows).length; r++) {
+    for (let r = 0; r < 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();
@@ -824,33 +759,32 @@ matchesAnyGlob.printStats = () => {
 };
 
 // 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);
   }
+  #data = /* @__PURE__ */ new Map();
+  #last;
   start(name) {
     const time = process.hrtime.bigint();
-    if (__privateGet(this, _last)) {
-      __privateGet(this, _last).total += time;
+    if (this.#last) {
+      this.#last.total += time;
     }
-    let data = __privateGet(this, _data).get(name);
+    let data = this.#data.get(name);
     if (data === void 0) {
       data = { count: 1, total: -time };
-      __privateGet(this, _data).set(name, data);
+      this.#data.set(name, data);
     } else {
       data.total -= time;
       data.count++;
     }
-    __privateSet(this, _last, data);
+    this.#last = data;
   }
   stop() {
     const time = process.hrtime.bigint();
-    if (__privateGet(this, _last)) {
-      __privateGet(this, _last).total += time;
-      __privateSet(this, _last, void 0);
+    if (this.#last) {
+      this.#last.total += time;
+      this.#last = void 0;
     }
   }
   printResults() {
@@ -871,7 +805,7 @@ var AggregateTiming = class {
         { header: "Avg", type: "bigint", footer: { aggregate: "average" } }
       ]
     });
-    for (const [name, value] of __privateGet(this, _data)) {
+    for (const [name, value] of this.#data) {
       table.addRow(
         value.total,
         name,
@@ -882,22 +816,19 @@ var AggregateTiming = class {
     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();
   }
+  #starts = [];
   start(name) {
-    __privateGet(this, _starts).push({ name, start: process.hrtime.bigint() });
+    this.#starts.push({ name, start: process.hrtime.bigint() });
   }
   stop() {
-    __privateGet(this, _starts).push({ start: process.hrtime.bigint() });
+    this.#starts.push({ start: process.hrtime.bigint() });
   }
   printResults() {
     const table = new Table({
@@ -917,8 +848,8 @@ var Timing = class {
       ]
     });
     this.stop();
-    let cur = __privateGet(this, _starts)[0];
-    for (const entry of __privateGet(this, _starts)) {
+    let cur = this.#starts[0];
+    for (const entry of this.#starts) {
       if (cur.name) {
         const span = entry.start - cur.start;
         table.addRow(span, cur.name);
@@ -928,7 +859,6 @@ var Timing = class {
     table.print();
   }
 };
-_starts = new WeakMap();
 export {
   AggregateTiming,
   CachingHost,