binary-collections 2.0.7 → 2.0.9

package/lib/changelog.js

@@ -0,0 +1,226 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+const fs = require("fs");
+const path = require("path");
+const { EOL } = require("os");
+const { getArgs } = require("./utils");
+const spawn = require("child_process").spawn;
+const pkgPath = path.join(process.cwd(), "package.json");
+if (!fs.existsSync(pkgPath)) {
+    throw new Error(`package.json not found at ${pkgPath}`);
+}
+const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf8"));
+const args = getArgs();
+// Show help if no arguments or --help/-h is passed
+if (args.help || args.h) {
+    showHelp();
+}
+/**
+ * Prints help information for the changelog script.
+ */
+function showHelp() {
+    console.log(`\nUsage: node changelog.js [options]\n`);
+    console.log(`Options:`);
+    console.log(`  --help, -h        Show this help message and exit`);
+    console.log(`\nDescription:`);
+    console.log(`  Generates a CHANGELOG.md file from git commit history.`);
+    console.log(`  - Looks for version bumps and groups commits by version.`);
+    console.log(`  - Skips dependabot and irrelevant commits.`);
+    console.log(`  - Outputs the original git log to tmp/original.md for reference.`);
+    console.log(`\nExample:`);
+    console.log(`  node changelog.js`);
+    console.log(``);
+}
+/**
+ * git
+ * @param {string[]} command
+ * @returns {Promise<string>}
+ */
+const gitExec = (command) => new Promise((resolve, reject) => {
+    const thread = spawn("git", command, { stdio: ["inherit", "pipe", "pipe"] });
+    const stdOut = [];
+    const stdErr = [];
+    thread.stdout.on("data", (data) => {
+        stdOut.push(data.toString("utf8"));
+    });
+    thread.stderr.on("data", (data) => {
+        stdErr.push(data.toString("utf8"));
+    });
+    thread.on("close", () => {
+        if (stdErr.length) {
+            reject(stdErr.join(""));
+            return;
+        }
+        resolve(stdOut.join());
+    });
+});
+/**
+ * Extracts all version numbers in X.X.X format from a multiline string.
+ * @param {string} str
+ * @returns {string[]}
+ */
+function extractVersions(str) {
+    const regex = /\bv?(\d+\.\d+\.\d+)\b/g;
+    const matches = [];
+    let match;
+    while ((match = regex.exec(str)) !== null) {
+        matches.push(match[1]);
+    }
+    return Array.from(new Set(matches));
+}
+// Git log format used:
+// %h   - Abbreviated commit hash
+// %ad  - Author date (formatted as "YYYY-MM-DD HH:MM:SS")
+// %B   - Raw body (commit message)
+// %d   - Ref names (branch, tag, etc.)
+// Fields are separated by " !|! "
+// Example: --pretty=format:"%h !|! %ad !|! %B %d" --date=format:"%Y-%m-%d %H:%M:%S"
+// `--pretty=format:"%h !|! %ad !|! %B %d"`, `--date=format:"%Y-%m-%d %H:%M:%S"`
+// Now includes author and committer name/email in the log format
+(() => __awaiter(this, void 0, void 0, function* () {
+    const log = yield gitExec([
+        "log",
+        "--reverse",
+        `--pretty=format:"=!=%h !|! %ad !|! %an !|! %cn !|! %s !|! %B !|! %d=!="`,
+        `--date=format:"%Y-%m-%d %H:%M:%S"`
+    ]);
+    let markdown = `## CHANGELOG of ${pkg.name}\n\n`;
+    const repo = yield gitExec(["remote", "get-url", "origin"]);
+    const repoUrl = repo.trim().replace(/\.git$/, "");
+    console.log(`Repository URL: ${repoUrl}`);
+    const matches = [...log.matchAll(/=!=(.*?)(?:=!=|=!=,)/gs)];
+    const results = matches.map((m) => m[1].trim());
+    /** @type {Record<string, string[]>} */
+    const versionsCommits = {};
+    let currentVersionCommit = "";
+    for (const str of results) {
+        const splitx = str.split("!|!").map((s) => s.trim());
+        // Now splitx: [hash, date, authorName, committerName, summary, message, ref]
+        const o = {
+            hash: splitx[0] ? splitx[0] : "",
+            date: splitx[1] ? splitx[1].replace(/^"|"$/g, "") : "",
+            authorName: splitx[2] ? splitx[2] : "",
+            committerName: splitx[3] ? splitx[3] : "",
+            summary: splitx[4] ? splitx[4] : "",
+            message: splitx[5] ? splitx[5] : "",
+            ref: splitx[6] ? splitx[6] : ""
+        };
+        let isBumped = /chore\(bump\)|chore: release/i.test(o.summary) || /release/i.test(o.summary) || /tag: v/i.test(o.summary);
+        if (o.summary.trim().startsWith("v")) {
+            isBumped = true; // Treat any commit starting with 'v' as a version bump
+        }
+        if (/^\d+\.\d+\.\d+$/.test(o.summary.trim())) {
+            isBumped = true; // Treat commits with version format as version bumps
+        }
+        if (o.summary.trim().startsWith("fix:")) {
+            isBumped = false; // Do not treat 'fix:' commits as version bumps
+        }
+        if (isBumped && !extractVersions(o.summary).length > 0)
+            isBumped = false; // Ensure we have a version in the summary
+        if (o.hash && o.date && o.message) {
+            // Skip commits by dependabot[bot]
+            if (o.authorName === "dependabot[bot]") {
+                continue;
+            }
+            // Skip commits by regex
+            if (/^chore\(tarball\): update|merge pull request|merge branch|^migrate from|^update$|^update build from https?:\/\//i.test(o.message)) {
+                continue;
+            }
+            // Skip build summary messages like "Build Tue Dec 27 20:18:29 UTC 2022"
+            if (/^Build\s+\w{3}\s+\w{3}\s+\d{1,2}\s+\d{2}:\d{2}:\d{2}\s+\w+\s+\d{4}$/i.test(o.summary)) {
+                continue;
+            }
+            if (/initial commit/i.test(o.message)) {
+                versionsCommits["0.0.0"] = [];
+                currentVersionCommit = "0.0.0";
+                continue;
+            }
+            if (isBumped) {
+                console.log(`Detected version bump: ${o.summary}`);
+                const v = extractVersions(o.message).join(", ");
+                versionsCommits[v] = [];
+                currentVersionCommit = v;
+            }
+            else {
+                if (!currentVersionCommit) {
+                    throw new Error(`No current version commit set for message: ${o.message} (hash: ${o.hash})`);
+                }
+                // Remove all trailing quotes, spaces, and commas from message
+                const cleanMsg = o.message.replace(/["'\s,]+$/g, "");
+                // Overwrite previous entry if message is duplicated (keep latest hash)
+                const commitsArr = versionsCommits[currentVersionCommit];
+                // Find index of previous entry with the same message (message is now on the line after the metadata)
+                const prevIdx = commitsArr.findIndex((entry) => {
+                    // Extract the message part (after the first empty line)
+                    const parts = entry.split(/\r?\n/);
+                    // Find the first non-empty line after the metadata line
+                    let msgLine = "";
+                    for (let i = 1; i < parts.length; i++) {
+                        if (parts[i].trim() !== "") {
+                            msgLine = parts[i].trim();
+                            break;
+                        }
+                    }
+                    return msgLine === cleanMsg;
+                });
+                // Add changelog entry without author/committer info
+                let newEntry;
+                if (cleanMsg.includes("\n")) {
+                    // Multiline message: put message on new line
+                    newEntry = `- [ _${o.date}_ ] [${o.hash}](<${repoUrl}/commit/${o.hash}>)` + EOL + EOL + `${cleanMsg}`;
+                }
+                else {
+                    // Single line message: put message on same line
+                    newEntry = `- [ _${o.date}_ ] [${o.hash}](<${repoUrl}/commit/${o.hash}>) ${cleanMsg}`;
+                }
+                if (prevIdx !== -1) {
+                    // Overwrite previous occurrence with the latest hash/date
+                    commitsArr[prevIdx] = newEntry;
+                }
+                else {
+                    commitsArr.push(newEntry);
+                }
+            }
+        }
+    }
+    // Iterate versionsCommits in reverse order
+    const versions = Object.keys(versionsCommits).sort((a, b) => {
+        const aParts = a.split(".").map(Number);
+        const bParts = b.split(".").map(Number);
+        for (let i = 0; i < Math.max(aParts.length, bParts.length); i++) {
+            const aPart = aParts[i] || 0; // Default to 0 if part is missing
+            const bPart = bParts[i] || 0; // Default to 0 if part is missing
+            if (aPart !== bPart) {
+                return bPart - aPart; // Sort in descending order
+            }
+        }
+        return 0; // They are equal
+    });
+    for (const version of versions) {
+        if (versionsCommits[version].length > 0) {
+            markdown += `\n### ${version}\n\n`;
+            markdown += versionsCommits[version]
+                .map((str) => {
+                const lines = str.trim().split(/\r?\n/);
+                return [lines[0], ...lines.slice(1).map((line) => "    " + line)].join(EOL);
+            })
+                .join(EOL);
+        }
+        else {
+            markdown += `\n### ${version}\n\n`;
+            markdown += `- No changes recorded for this version.\n`;
+        }
+    }
+    fs.mkdirSync(path.join(__dirname, "tmp"), { recursive: true });
+    fs.writeFileSync(path.join(__dirname, "tmp/original.md"), log);
+    fs.writeFileSync(path.join(__dirname, "CHANGELOG.md"), markdown);
+    console.log(`Original log written to tmp/original.md`);
+    console.log(`Changelog updated successfully. You can find it at CHANGELOG.md`);
+}))();

package/lib/changelog.mjs

@@ -0,0 +1,199 @@
+import { createRequire } from 'module'; const require = createRequire(import.meta.url);
+import {
+  require_utils
+} from "./chunk-APBWENF6.mjs";
+import {
+  __dirname,
+  __require,
+  init_esm_shims
+} from "./chunk-AASHBCRW.mjs";
+
+// src/changelog.js
+init_esm_shims();
+var fs = __require("fs");
+var path = __require("path");
+var { EOL } = __require("os");
+var { getArgs } = require_utils();
+var spawn = __require("child_process").spawn;
+var pkgPath = path.join(process.cwd(), "package.json");
+if (!fs.existsSync(pkgPath)) {
+  throw new Error(`package.json not found at ${pkgPath}`);
+}
+var pkg = JSON.parse(fs.readFileSync(pkgPath, "utf8"));
+var args = getArgs();
+if (args.help || args.h) {
+  showHelp();
+}
+function showHelp() {
+  console.log(`
+Usage: node changelog.js [options]
+`);
+  console.log(`Options:`);
+  console.log(`  --help, -h        Show this help message and exit`);
+  console.log(`
+Description:`);
+  console.log(`  Generates a CHANGELOG.md file from git commit history.`);
+  console.log(`  - Looks for version bumps and groups commits by version.`);
+  console.log(`  - Skips dependabot and irrelevant commits.`);
+  console.log(`  - Outputs the original git log to tmp/original.md for reference.`);
+  console.log(`
+Example:`);
+  console.log(`  node changelog.js`);
+  console.log(``);
+}
+var gitExec = (command) => new Promise((resolve, reject) => {
+  const thread = spawn("git", command, { stdio: ["inherit", "pipe", "pipe"] });
+  const stdOut = [];
+  const stdErr = [];
+  thread.stdout.on("data", (data) => {
+    stdOut.push(data.toString("utf8"));
+  });
+  thread.stderr.on("data", (data) => {
+    stdErr.push(data.toString("utf8"));
+  });
+  thread.on("close", () => {
+    if (stdErr.length) {
+      reject(stdErr.join(""));
+      return;
+    }
+    resolve(stdOut.join());
+  });
+});
+function extractVersions(str) {
+  const regex = /\bv?(\d+\.\d+\.\d+)\b/g;
+  const matches = [];
+  let match;
+  while ((match = regex.exec(str)) !== null) {
+    matches.push(match[1]);
+  }
+  return Array.from(new Set(matches));
+}
+(async () => {
+  const log = await gitExec([
+    "log",
+    "--reverse",
+    `--pretty=format:"=!=%h !|! %ad !|! %an !|! %cn !|! %s !|! %B !|! %d=!="`,
+    `--date=format:"%Y-%m-%d %H:%M:%S"`
+  ]);
+  let markdown = `## CHANGELOG of ${pkg.name}
+
+`;
+  const repo = await gitExec(["remote", "get-url", "origin"]);
+  const repoUrl = repo.trim().replace(/\.git$/, "");
+  console.log(`Repository URL: ${repoUrl}`);
+  const matches = [...log.matchAll(/=!=(.*?)(?:=!=|=!=,)/gs)];
+  const results = matches.map((m) => m[1].trim());
+  const versionsCommits = {};
+  let currentVersionCommit = "";
+  for (const str of results) {
+    const splitx = str.split("!|!").map((s) => s.trim());
+    const o = {
+      hash: splitx[0] ? splitx[0] : "",
+      date: splitx[1] ? splitx[1].replace(/^"|"$/g, "") : "",
+      authorName: splitx[2] ? splitx[2] : "",
+      committerName: splitx[3] ? splitx[3] : "",
+      summary: splitx[4] ? splitx[4] : "",
+      message: splitx[5] ? splitx[5] : "",
+      ref: splitx[6] ? splitx[6] : ""
+    };
+    let isBumped = /chore\(bump\)|chore: release/i.test(o.summary) || /release/i.test(o.summary) || /tag: v/i.test(o.summary);
+    if (o.summary.trim().startsWith("v")) {
+      isBumped = true;
+    }
+    if (/^\d+\.\d+\.\d+$/.test(o.summary.trim())) {
+      isBumped = true;
+    }
+    if (o.summary.trim().startsWith("fix:")) {
+      isBumped = false;
+    }
+    if (isBumped && !extractVersions(o.summary).length > 0) isBumped = false;
+    if (o.hash && o.date && o.message) {
+      if (o.authorName === "dependabot[bot]") {
+        continue;
+      }
+      if (/^chore\(tarball\): update|merge pull request|merge branch|^migrate from|^update$|^update build from https?:\/\//i.test(
+        o.message
+      )) {
+        continue;
+      }
+      if (/^Build\s+\w{3}\s+\w{3}\s+\d{1,2}\s+\d{2}:\d{2}:\d{2}\s+\w+\s+\d{4}$/i.test(o.summary)) {
+        continue;
+      }
+      if (/initial commit/i.test(o.message)) {
+        versionsCommits["0.0.0"] = [];
+        currentVersionCommit = "0.0.0";
+        continue;
+      }
+      if (isBumped) {
+        console.log(`Detected version bump: ${o.summary}`);
+        const v = extractVersions(o.message).join(", ");
+        versionsCommits[v] = [];
+        currentVersionCommit = v;
+      } else {
+        if (!currentVersionCommit) {
+          throw new Error(`No current version commit set for message: ${o.message} (hash: ${o.hash})`);
+        }
+        const cleanMsg = o.message.replace(/["'\s,]+$/g, "");
+        const commitsArr = versionsCommits[currentVersionCommit];
+        const prevIdx = commitsArr.findIndex((entry) => {
+          const parts = entry.split(/\r?\n/);
+          let msgLine = "";
+          for (let i = 1; i < parts.length; i++) {
+            if (parts[i].trim() !== "") {
+              msgLine = parts[i].trim();
+              break;
+            }
+          }
+          return msgLine === cleanMsg;
+        });
+        let newEntry;
+        if (cleanMsg.includes("\n")) {
+          newEntry = `- [ _${o.date}_ ] [${o.hash}](<${repoUrl}/commit/${o.hash}>)` + EOL + EOL + `${cleanMsg}`;
+        } else {
+          newEntry = `- [ _${o.date}_ ] [${o.hash}](<${repoUrl}/commit/${o.hash}>) ${cleanMsg}`;
+        }
+        if (prevIdx !== -1) {
+          commitsArr[prevIdx] = newEntry;
+        } else {
+          commitsArr.push(newEntry);
+        }
+      }
+    }
+  }
+  const versions = Object.keys(versionsCommits).sort((a, b) => {
+    const aParts = a.split(".").map(Number);
+    const bParts = b.split(".").map(Number);
+    for (let i = 0; i < Math.max(aParts.length, bParts.length); i++) {
+      const aPart = aParts[i] || 0;
+      const bPart = bParts[i] || 0;
+      if (aPart !== bPart) {
+        return bPart - aPart;
+      }
+    }
+    return 0;
+  });
+  for (const version of versions) {
+    if (versionsCommits[version].length > 0) {
+      markdown += `
+### ${version}
+
+`;
+      markdown += versionsCommits[version].map((str) => {
+        const lines = str.trim().split(/\r?\n/);
+        return [lines[0], ...lines.slice(1).map((line) => "    " + line)].join(EOL);
+      }).join(EOL);
+    } else {
+      markdown += `
+### ${version}
+
+`;
+      markdown += `- No changes recorded for this version.
+`;
+    }
+  }
+  fs.mkdirSync(path.join(__dirname, "tmp"), { recursive: true });
+  fs.writeFileSync(path.join(__dirname, "tmp/original.md"), log);
+  fs.writeFileSync(path.join(__dirname, "CHANGELOG.md"), markdown);
+  console.log(`Original log written to tmp/original.md`);
+  console.log(`Changelog updated successfully. You can find it at CHANGELOG.md`);
+})();

package/lib/chunk-4BYBVEYC.mjs

@@ -0,0 +1,30 @@
+import { createRequire } from 'module'; const require = createRequire(import.meta.url);
+import {
+  __commonJS,
+  __require,
+  init_esm_shims
+} from "./chunk-AASHBCRW.mjs";
+
+// src/binary-collections-config.js
+var require_binary_collections_config = __commonJS({
+  "src/binary-collections-config.js"(exports, module) {
+    init_esm_shims();
+    var path = __require("path");
+    function getTempDir() {
+      return process.env.TEMP_DIR || "tmp";
+    }
+    function getTempPath(...segments) {
+      return path.join(getTempDir(), ...segments);
+    }
+    var TEMP_BASE_DIR = getTempDir();
+    module.exports = {
+      getTempDir,
+      getTempPath,
+      TEMP_BASE_DIR
+    };
+  }
+});
+
+export {
+  require_binary_collections_config
+};

package/lib/{chunk-FB6YIQYR.mjs → chunk-AASHBCRW.mjs}

@@ -34,9 +34,24 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   mod
 ));
 
+// node_modules/tsup/assets/esm_shims.js
+import path from "path";
+import { fileURLToPath } from "url";
+var getFilename, getDirname, __dirname, __filename;
+var init_esm_shims = __esm({
+  "node_modules/tsup/assets/esm_shims.js"() {
+    getFilename = () => fileURLToPath(import.meta.url);
+    getDirname = () => path.dirname(getFilename());
+    __dirname = /* @__PURE__ */ getDirname();
+    __filename = /* @__PURE__ */ getFilename();
+  }
+});
+
 export {
   __require,
-  __esm,
   __commonJS,
-  __toESM
+  __toESM,
+  __dirname,
+  __filename,
+  init_esm_shims
 };

package/lib/chunk-APBWENF6.mjs

@@ -0,0 +1,135 @@
+import { createRequire } from 'module'; const require = createRequire(import.meta.url);
+import {
+  __commonJS,
+  __require,
+  init_esm_shims
+} from "./chunk-AASHBCRW.mjs";
+
+// src/utils.js
+var require_utils = __commonJS({
+  "src/utils.js"(exports, module) {
+    init_esm_shims();
+    var fs = __require("fs");
+    var path = __require("upath");
+    var argv = __require("minimist")(process.argv.slice(2));
+    var { exec } = __require("child_process");
+    var { URL } = __require("url");
+    var { promisify } = __require("util");
+    var execAsync = promisify(exec);
+    async function parseGitRemotes() {
+      try {
+        const { stdout } = await execAsync("git remote -v");
+        const lines = stdout.split("\n");
+        const remotes = {};
+        lines.forEach((line) => {
+          const [name, url] = line.split("	");
+          if (name && url) {
+            const [repoUrl] = url.split(" ");
+            try {
+              const parsedUrl = new URL(repoUrl);
+              const pathParts = parsedUrl.pathname.split("/").filter(Boolean);
+              if (parsedUrl.hostname === "github.com" && pathParts.length === 2) {
+                let repoPath = pathParts.join("/");
+                if (repoPath.endsWith(".git")) {
+                  repoPath = repoPath.slice(0, -4);
+                }
+                remotes[name] = repoPath;
+              }
+            } catch (e) {
+              console.error("URL Parsing Error:", e.message);
+            }
+          }
+        });
+        return remotes;
+      } catch (error) {
+        console.error("Error:", error.message);
+        return {};
+      }
+    }
+    module.exports.parseGitRemotes = parseGitRemotes;
+    function joinPathPreserveDriveLetter(...segments) {
+      let fullPath = __require("path").join(...segments);
+      if (/^[a-z]:\\/.test(fullPath)) {
+        fullPath = fullPath.charAt(0).toUpperCase() + fullPath.slice(1);
+      }
+      return fullPath;
+    }
+    module.exports.joinPathPreserveDriveLetter = joinPathPreserveDriveLetter;
+    function getArgs() {
+      return argv;
+    }
+    module.exports.getArgs = getArgs;
+    function del(fullPath) {
+      if (fs.statSync(fullPath).isDirectory()) {
+        const subdir = fs.readdirSync(fullPath).map((dirPath) => path.resolve(fullPath, dirPath));
+        for (let i = 0; i < subdir.length; i++) {
+          del(subdir[i]);
+        }
+      } else {
+        try {
+          fs.rmSync(fullPath, { recursive: true, force: true, retryDelay: 7e3 });
+          console.log("deleted", fullPath);
+        } catch (_) {
+          console.log("failed delete", fullPath);
+        }
+      }
+    }
+    module.exports.del = del;
+    function delStream(globStream) {
+      globStream.stream().on("data", (result) => {
+        const fullPath = path.resolve(process.cwd(), result);
+        if (fs.statSync(fullPath).isDirectory()) {
+          const subdir = fs.readdirSync(fullPath).map((dirPath) => path.resolve(fullPath, dirPath));
+          for (let i = 0; i < subdir.length; i++) {
+            del(subdir[i]);
+          }
+        }
+        del(fullPath);
+      });
+    }
+    module.exports.delStream = delStream;
+    function getFileTreeString(hashArray) {
+      const tree = {};
+      const hashMap = {};
+      for (const entry of hashArray) {
+        const [filePath, hash] = entry.split(" ");
+        hashMap[filePath] = hash;
+        const parts = filePath.split("/");
+        let current = tree;
+        for (let i = 0; i < parts.length; i++) {
+          const part = parts[i];
+          if (i === parts.length - 1) {
+            current[part] = null;
+          } else {
+            current[part] = current[part] || {};
+            current = current[part];
+          }
+        }
+      }
+      function printNode(node, prefix = "", parentPath = "") {
+        const keys = Object.keys(node).sort();
+        let lines = [];
+        keys.forEach((key, idx) => {
+          const isLast = idx === keys.length - 1;
+          const branch = isLast ? "\u2514\u2500\u2500 " : "\u251C\u2500\u2500 ";
+          const currentPath = parentPath ? parentPath + "/" + key : key;
+          if (node[key] === null) {
+            lines.push(prefix + branch + key + " [" + (hashMap[currentPath] || "") + "]");
+          } else {
+            lines.push(prefix + branch + key + "/");
+            lines = lines.concat(printNode(node[key], prefix + (isLast ? "    " : "\u2502   "), currentPath));
+          }
+        });
+        return lines;
+      }
+      return printNode(tree, "", "").join("\n");
+    }
+    module.exports.getFileTreeString = getFileTreeString;
+    var delay = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+    module.exports.delay = delay;
+  }
+});
+
+export {
+  require_utils
+};

package/lib/{chunk-4LEXWIIF.mjs → chunk-DPKAJKFO.mjs}

@@ -1,10 +1,8 @@
 import { createRequire } from 'module'; const require = createRequire(import.meta.url);
 import {
+  __commonJS,
   init_esm_shims
-} from "./chunk-VXZQNLPU.mjs";
-import {
-  __commonJS
-} from "./chunk-FB6YIQYR.mjs";
+} from "./chunk-AASHBCRW.mjs";
 
 // src/ps/connected-domain.js
 var require_connected_domain = __commonJS({