@sse-ui/builder 1.0.0 → 1.0.2

package/dist/cli.js

@@ -0,0 +1,2628 @@
+#!/usr/bin/env node
+import {
+  createPackageBin,
+  createPackageExports,
+  getOutExtension,
+  mapConcurrently,
+  validatePkgJson
+} from "./chunk-5S2N5WDQ.js";
+
+// src/cli.ts
+import { Command as Command11 } from "commander";
+
+// src/core/build.ts
+import { findWorkspacesRoot } from "find-workspaces";
+import { $ } from "execa";
+import { globby } from "globby";
+import * as fs from "fs/promises";
+import * as path from "path";
+import { sep as posixSep } from "path/posix";
+import * as semver from "semver";
+import { Command } from "commander";
+
+// src/utils/loadConfig.ts
+import { loadConfig as loadC12Config } from "c12";
+async function loadConfig() {
+  try {
+    const { config, configFile } = await loadC12Config({
+      name: "sse",
+      rcFile: false,
+      globalRc: false
+    });
+    if (configFile) {
+      console.log(`\u{1F4DD} Loaded config from ${configFile}`);
+    }
+    return config || {};
+  } catch (error) {
+    console.error(`\u274C Failed to parse configuration:`);
+    console.error(error);
+    process.exit(1);
+  }
+}
+
+// src/core/build.ts
+async function addLicense({
+  name,
+  version,
+  license,
+  bundle,
+  outputDir,
+  isFlat,
+  packageType
+}) {
+  const outExtension = getOutExtension(bundle, { isFlat, packageType });
+  const file = path.join(outputDir, `index${outExtension}`);
+  if (!await fs.stat(file).then(
+    (stats) => stats.isFile(),
+    () => false
+  )) {
+    return;
+  }
+  const content = await fs.readFile(file, { encoding: "utf8" });
+  await fs.writeFile(
+    file,
+    `/**
+ * ${name} v${version}
+ *
+ * @license ${license}
+ * This source code is licensed under the ${license} license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+${content}`,
+    { encoding: "utf8" }
+  );
+  console.log(`License added to ${file}`);
+}
+async function writePackageJson({
+  packageJson,
+  bundles,
+  outputDir,
+  cwd,
+  addTypes = false,
+  isFlat = false,
+  packageType
+}) {
+  delete packageJson.scripts;
+  delete packageJson.publishConfig?.directory;
+  delete packageJson.devDependencies;
+  delete packageJson.imports;
+  const resolvedPackageType = packageType || packageJson.type || "commonjs";
+  packageJson.type = resolvedPackageType;
+  const originalExports = packageJson.exports;
+  delete packageJson.exports;
+  const originalBin = packageJson.bin;
+  delete packageJson.bin;
+  const {
+    exports: packageExports,
+    main: main2,
+    types
+  } = await createPackageExports({
+    exports: originalExports,
+    bundles,
+    outputDir,
+    cwd,
+    addTypes,
+    isFlat,
+    packageType: resolvedPackageType
+  });
+  packageJson.exports = packageExports;
+  if (main2) {
+    packageJson.main = main2;
+  }
+  if (types) {
+    packageJson.types = types;
+  }
+  const bin = await createPackageBin({
+    bin: originalBin,
+    bundles,
+    cwd,
+    isFlat,
+    packageType: resolvedPackageType
+  });
+  if (bin) {
+    packageJson.bin = bin;
+  }
+  await fs.writeFile(
+    path.join(outputDir, "package.json"),
+    JSON.stringify(packageJson, null, 2),
+    "utf-8"
+  );
+}
+var buildCommand = new Command("build").description("Builds the package for publishing.").option("--bundle <bundles...>", "Bundles to output", ["esm", "cjs"]).option(
+  "--hasLargeFiles",
+  "Set to `true` if you know you are transpiling large files.",
+  false
+).option(
+  "--skipBundlePackageJson",
+  "Set to `true` if you don't want to generate a package.json file in the bundle output.",
+  false
+).option("--buildTypes", "Do not build types for the package.").option(
+  "--skipTsc",
+  "Skip running TypeScript compiler (tsc) for building types.",
+  false
+).option("--ignore <globs...>", "Extra globs to be ignored by Babel.", []).option(
+  "--skipBabelRuntimeCheck",
+  "Skip checking for Babel runtime dependencies in the package.",
+  false
+).option(
+  "--skipPackageJson",
+  "Skip generating the package.json file in the bundle output.",
+  false
+).option(
+  "--skipMainCheck",
+  "Skip checking for main field in package.json.",
+  false
+).option(
+  "--copy <globs...>",
+  "Files/Directories to be copied to the output directory. Can be a glob pattern.",
+  []
+).option("--enableReactCompiler", "Whether to use the React compiler.", false).option(
+  "--tsgo",
+  'Uses tsgo cli instead of tsc for type generation. Can also be set via env var "SSE_USE_TSGO"',
+  process.env.SSE_USE_TSGO === "1" || process.env.SSE_USE_TSGO === "true"
+).option(
+  "--flat",
+  "Builds the package in a flat structure without subdirectories for each module type.",
+  process.env.SSE_BUILD_FLAT === "1"
+).option("--verbose", "Enable verbose logging.", false).action(async (cliOptions) => {
+  const fileConfig = await loadConfig();
+  const options = {
+    bundle: cliOptions.bundle || fileConfig.bundle || ["esm", "cjs"],
+    hasLargeFiles: cliOptions.hasLargeFiles ?? fileConfig.hasLargeFiles ?? false,
+    skipBundlePackageJson: cliOptions.skipBundlePackageJson ?? fileConfig.skipBundlePackageJson ?? false,
+    buildTypes: cliOptions.buildTypes ?? fileConfig.buildTypes ?? true,
+    skipTsc: cliOptions.skipTsc ?? fileConfig.skipTsc ?? false,
+    ignore: [...fileConfig.ignore || [], ...cliOptions.ignore || []],
+    copy: [...fileConfig.copy || [], ...cliOptions.copy || []],
+    enableReactCompiler: cliOptions.enableReactCompiler ?? fileConfig.enableReactCompiler ?? false,
+    tsgo: cliOptions.tsgo ?? fileConfig.tsgo ?? false,
+    flat: cliOptions.flat ?? fileConfig.flat ?? false,
+    verbose: cliOptions.verbose ?? fileConfig.verbose ?? false,
+    skipBabelRuntimeCheck: false,
+    skipPackageJson: false,
+    skipMainCheck: false
+  };
+  const {
+    bundle: bundles,
+    hasLargeFiles,
+    skipBundlePackageJson,
+    verbose = false,
+    ignore: extraIgnores,
+    buildTypes,
+    skipTsc,
+    skipBabelRuntimeCheck = false,
+    skipPackageJson = false,
+    enableReactCompiler = false,
+    tsgo: useTsgo = false
+  } = options;
+  const cwd = process.cwd();
+  const pkgJsonPath = path.join(cwd, "package.json");
+  const packageJson = JSON.parse(
+    await fs.readFile(pkgJsonPath, { encoding: "utf8" })
+  );
+  validatePkgJson(packageJson, {
+    skipMainCheck: options.skipMainCheck,
+    enableReactCompiler
+  });
+  const buildDirBase = packageJson.publishConfig?.directory;
+  const buildDir = path.join(cwd, buildDirBase);
+  const packageType = packageJson.type === "module" ? "module" : "commonjs";
+  console.log(`Selected output directory: "${buildDirBase}"`);
+  if (options.flat) {
+    console.log("Building package in flat structure.");
+  }
+  await fs.rm(buildDir, { recursive: true, force: true });
+  let babelRuntimeVersion = packageJson.dependencies?.["@babel/runtime"];
+  if (babelRuntimeVersion === "catalog:") {
+    const { stdout: configStdout } = await $`pnpm config list --json`;
+    const pnpmWorkspaceConfig = JSON.parse(configStdout);
+    babelRuntimeVersion = pnpmWorkspaceConfig.catalog["@babel/runtime"];
+  }
+  if (!babelRuntimeVersion && !skipBabelRuntimeCheck) {
+    throw new Error(
+      "package.json needs to have a dependency on `@babel/runtime` when building with `@babel/plugin-transform-runtime`."
+    );
+  }
+  if (!bundles || bundles.length === 0) {
+    console.error(
+      "No bundles specified. Use --bundle to specify which bundles to build."
+    );
+    return;
+  }
+  const { build: babelBuild, cjsCopy } = await import("./babel-VTL3CZAT.js");
+  const relativeOutDirs = !options.flat ? {
+    cjs: ".",
+    esm: "esm"
+  } : {
+    cjs: ".",
+    esm: "."
+  };
+  const sourceDir = path.join(cwd, "src");
+  const reactVersion = semver.minVersion(packageJson.peerDependencies?.react || "")?.version ?? "latest";
+  if (enableReactCompiler) {
+    const mode = process.env.SSE_REACT_COMPILER_MODE ?? "opt-in";
+    console.log(
+      `[feature] Building with React compiler enabled. The compiler mode is "${mode}" right now.${mode === "opt-in" ? ' Use explicit "use memo" directives in your components to enable the React compiler for them.' : ""}`
+    );
+  }
+  await Promise.all(
+    bundles.map(async (bundle) => {
+      const outExtension = getOutExtension(bundle, {
+        isFlat: !!options.flat,
+        isType: false,
+        packageType
+      });
+      const relativeOutDir = relativeOutDirs[bundle];
+      const outputDir = path.join(buildDir, relativeOutDir);
+      await fs.mkdir(outputDir, { recursive: true });
+      const promises = [];
+      promises.push(
+        babelBuild({
+          cwd,
+          sourceDir,
+          outDir: outputDir,
+          babelRuntimeVersion,
+          hasLargeFiles,
+          bundle,
+          verbose,
+          optimizeClsx: packageJson.dependencies?.clsx !== void 0 || packageJson.dependencies?.classnames !== void 0,
+          removePropTypes: packageJson.dependencies?.["prop-types"] !== void 0,
+          pkgVersion: packageJson.version,
+          ignores: extraIgnores,
+          outExtension,
+          reactCompiler: enableReactCompiler ? {
+            reactVersion: reactVersion || "latest"
+          } : void 0
+        })
+      );
+      if (buildDir !== outputDir && !skipBundlePackageJson && !options.flat) {
+        promises.push(
+          fs.writeFile(
+            path.join(outputDir, "package.json"),
+            JSON.stringify({
+              type: bundle === "esm" ? "module" : "commonjs",
+              sideEffects: packageJson.sideEffects ?? false
+            })
+          )
+        );
+      }
+      if (!options.flat) {
+        promises.push(cjsCopy({ from: sourceDir, to: outputDir }));
+      }
+      await Promise.all(promises);
+      await addLicense({
+        bundle,
+        license: packageJson.license,
+        name: packageJson.name,
+        version: packageJson.version,
+        outputDir,
+        isFlat: !!options.flat,
+        packageType
+      });
+    })
+  );
+  if (options.flat) {
+    await cjsCopy({ from: sourceDir, to: buildDir });
+  }
+  if (buildTypes) {
+    const tsMod = await import("./typescript-CS6YZCMJ.js");
+    const bundleMap = bundles.map((type) => ({
+      type,
+      dir: relativeOutDirs[type]
+    }));
+    await tsMod.createTypes({
+      bundles: bundleMap,
+      srcDir: sourceDir,
+      cwd,
+      skipTsc,
+      isFlat: !!options.flat,
+      buildDir,
+      useTsgo,
+      packageType,
+      verbose: options.verbose
+    });
+  }
+  if (skipPackageJson) {
+    console.log("Skipping package.json generation in the output directory.");
+    return;
+  }
+  await writePackageJson({
+    cwd,
+    packageJson,
+    bundles: bundles.map((type) => ({
+      type,
+      dir: relativeOutDirs[type]
+    })),
+    outputDir: buildDir,
+    addTypes: buildTypes,
+    isFlat: !!options.flat,
+    packageType
+  });
+  await copyHandler({
+    cwd,
+    globs: options.copy ?? [],
+    buildDir,
+    verbose: options.verbose
+  });
+});
+async function copyHandler({
+  cwd,
+  globs = [],
+  buildDir,
+  verbose = false
+}) {
+  const defaultFiles = [];
+  const workspaceRoot = await findWorkspacesRoot(cwd);
+  const localOrRootFiles = [
+    [path.join(cwd, "README.md")],
+    [path.join(cwd, "LICENSE")],
+    [path.join(cwd, "CHANGELOG.md")]
+  ];
+  if (workspaceRoot) {
+    localOrRootFiles[0].push(path.join(workspaceRoot.location, "README.md"));
+    localOrRootFiles[1].push(path.join(workspaceRoot.location, "LICENSE"));
+    localOrRootFiles[2].push(path.join(workspaceRoot.location, "CHANGELOG.md"));
+  }
+  await Promise.all(
+    localOrRootFiles.map(async (filesToCopy) => {
+      for (const file of filesToCopy) {
+        if (
+          // eslint-disable-next-line no-await-in-loop
+          await fs.stat(file).then(
+            () => true,
+            () => false
+          )
+        ) {
+          defaultFiles.push(file);
+          break;
+        }
+      }
+    })
+  );
+  if (globs.length) {
+    const res = globs.map((globPattern) => {
+      const [pattern, baseDir] = globPattern.split(":");
+      return { pattern, baseDir };
+    });
+    const globToResMap = /* @__PURE__ */ new Map();
+    const result = await Promise.all(
+      res.map(async ({ pattern, baseDir }) => {
+        if (!globToResMap.has(pattern)) {
+          const promise = globby(pattern, { cwd });
+          globToResMap.set(pattern, promise);
+        }
+        const files = await globToResMap.get(pattern);
+        return { files: files ?? [], baseDir };
+      })
+    );
+    globToResMap.clear();
+    result.forEach(({ files, baseDir }) => {
+      files.forEach((file) => {
+        const sourcePath = path.resolve(cwd, file);
+        const pathSegments = file.split(posixSep);
+        const relativePath = (
+          // Use index 2 (when required) since users can also specify paths like `./src/index.js`
+          pathSegments.slice(pathSegments[0] === "." ? 2 : 1).join(posixSep) || file
+        );
+        const targetPath = baseDir ? path.resolve(buildDir, baseDir, relativePath) : path.resolve(buildDir, relativePath);
+        defaultFiles.push({ sourcePath, targetPath });
+      });
+    });
+  }
+  if (!defaultFiles.length) {
+    if (verbose) {
+      console.log("\u24FF No files to copy.");
+    }
+  }
+  await mapConcurrently(
+    defaultFiles,
+    async (file) => {
+      if (typeof file === "string") {
+        const sourcePath = file;
+        const fileName = path.basename(file);
+        const targetPath = path.join(buildDir, fileName);
+        await recursiveCopy({
+          source: sourcePath,
+          target: targetPath,
+          verbose
+        });
+      } else {
+        await fs.mkdir(path.dirname(file.targetPath), { recursive: true });
+        await recursiveCopy({
+          source: file.sourcePath,
+          target: file.targetPath,
+          verbose
+        });
+      }
+    },
+    20
+  );
+  console.log(`\u{1F4CB} Copied ${defaultFiles.length} files.`);
+}
+async function recursiveCopy({
+  source,
+  target,
+  verbose = true
+}) {
+  try {
+    await fs.cp(source, target, { recursive: true });
+    if (verbose) {
+      console.log(`Copied ${source} to ${target}`);
+    }
+    return true;
+  } catch (err) {
+    if (err && typeof err === "object" && "code" in err && err.code !== "ENOENT") {
+      throw err;
+    }
+    if (verbose) {
+      console.warn(`Source does not exist: ${source}`);
+    }
+    throw err;
+  }
+}
+
+// src/core/publish.ts
+import * as fs2 from "fs/promises";
+import * as path2 from "path";
+import { Command as Command2 } from "commander";
+import { $ as $2 } from "execa";
+function getPackageManager() {
+  const userAgent = process.env.npm_config_user_agent || "";
+  if (userAgent.includes("pnpm")) return "pnpm";
+  if (userAgent.includes("yarn")) return "yarn";
+  return "npm";
+}
+var publishCommand = new Command2("publish").description(
+  "Automatically publishes the built package from the publishConfig.directory"
+).option("--tag <tag>", "Registers the published package with the given tag").option(
+  "--access <access>",
+  "Tells the registry whether this package should be published as public or restricted"
+).option(
+  "--dry-run",
+  "Does everything publish would do except actually publishing"
+).option(
+  "--pm <manager>",
+  "Force a specific package manager (npm, yarn, pnpm)"
+).action(async (options) => {
+  const cwd = process.cwd();
+  const pkgJsonPath = path2.join(cwd, "package.json");
+  try {
+    const packageJsonContent = await fs2.readFile(pkgJsonPath, {
+      encoding: "utf8"
+    });
+    const packageJson = JSON.parse(packageJsonContent);
+    const publishDirBase = packageJson.publishConfig?.directory;
+    if (!publishDirBase) {
+      throw new Error(
+        `No publish directory specified in "${packageJson.name}" package.json. Specify it in the "publishConfig.directory" field.`
+      );
+    }
+    const publishDir = path2.join(cwd, publishDirBase);
+    const dirExists = await fs2.stat(publishDir).then(
+      (stats) => stats.isDirectory(),
+      () => false
+    );
+    if (!dirExists) {
+      throw new Error(
+        `Publish directory "${publishDir}" does not exist. Please run the build command first.`
+      );
+    }
+    const pm = options.pm || getPackageManager();
+    console.log(
+      `\u{1F680} Publishing via ${pm.toUpperCase()} from directory: ${publishDirBase}`
+    );
+    const args = ["publish"];
+    if (options.tag) args.push("--tag", options.tag);
+    if (options.access) args.push("--access", options.access);
+    if (options.dryRun) args.push("--dry-run");
+    if (pm === "yarn" && !process.env.npm_config_user_agent?.includes("yarn/3") && !process.env.npm_config_user_agent?.includes("yarn/4")) {
+      args.push("--non-interactive");
+    }
+    await $2({
+      stdio: "inherit",
+      cwd: publishDir
+    })`${pm} ${args}`;
+    console.log("\u2705 Successfully published!");
+  } catch (error) {
+    console.error("\u274C Error executing publish command:");
+    if (error instanceof Error) {
+      console.error(error.message);
+    }
+    process.exit(1);
+  }
+});
+
+// src/core/clean.ts
+import * as fs3 from "fs/promises";
+import * as path3 from "path";
+import { Command as Command3 } from "commander";
+var cleanCommand = new Command3("clean").description(
+  "Removes the build directory specified in package.json to start fresh"
+).action(async () => {
+  const cwd = process.cwd();
+  const pkgJsonPath = path3.join(cwd, "package.json");
+  try {
+    const packageJsonContent = await fs3.readFile(pkgJsonPath, {
+      encoding: "utf8"
+    });
+    const packageJson = JSON.parse(packageJsonContent);
+    const buildDirBase = packageJson.publishConfig?.directory || "build";
+    const buildDir = path3.join(cwd, buildDirBase);
+    console.log(`\u{1F9F9} Cleaning build directory: ${buildDirBase}...`);
+    await fs3.rm(buildDir, { recursive: true, force: true });
+    console.log("\u2728 Cleaned successfully!");
+  } catch (error) {
+    console.error("\u274C Error executing clean command:");
+    if (error instanceof Error) {
+      console.error(error.message);
+    }
+    process.exit(1);
+  }
+});
+
+// src/core/typecheck.ts
+import { Command as Command4 } from "commander";
+import { $ as $3 } from "execa";
+var typecheckCommand = new Command4("typecheck").description(
+  "Runs TypeScript validation across the project without emitting files"
+).option("--watch", "Run typechecking in watch mode").action(async (options) => {
+  console.log("\u{1F50D} Running typecheck...");
+  try {
+    const args = ["tsc", "--noEmit"];
+    if (options.watch) {
+      args.push("--watch");
+    }
+    await $3({ stdio: "inherit" })`${args.join(" ")}`;
+    if (!options.watch) {
+      console.log("\u2705 Typecheck passed! No errors found.");
+    }
+  } catch (error) {
+    console.error(
+      "\u274C Typecheck failed. Please fix the TypeScript errors above."
+    );
+    process.exit(1);
+  }
+});
+
+// src/core/pack.ts
+import * as fs4 from "fs/promises";
+import * as path4 from "path";
+import { Command as Command5 } from "commander";
+import { $ as $4 } from "execa";
+var packCommand = new Command5("pack").description(
+  "Creates a tarball (.tgz) of the built package to inspect before publishing"
+).action(async () => {
+  const cwd = process.cwd();
+  const pkgJsonPath = path4.join(cwd, "package.json");
+  try {
+    const packageJsonContent = await fs4.readFile(pkgJsonPath, {
+      encoding: "utf8"
+    });
+    const packageJson = JSON.parse(packageJsonContent);
+    const publishDirBase = packageJson.publishConfig?.directory;
+    if (!publishDirBase) {
+      throw new Error(`No publish directory specified in package.json.`);
+    }
+    const publishDir = path4.join(cwd, publishDirBase);
+    console.log(`\u{1F4E6} Packing package from directory: ${publishDirBase}...`);
+    await $4({
+      stdio: "inherit",
+      cwd: publishDir
+    })`npm pack`;
+    console.log(
+      "\u2705 Pack successful! You can inspect the generated .tgz file."
+    );
+  } catch (error) {
+    console.error("\u274C Error executing pack command:");
+    if (error instanceof Error) console.error(error.message);
+    process.exit(1);
+  }
+});
+
+// src/core/version.ts
+import { Command as Command6 } from "commander";
+import { $ as $5 } from "execa";
+var versionCommand = new Command6("version").description("Bumps the package version (patch, minor, or major)").argument(
+  "<type>",
+  "Version update type (patch, minor, major, or specific version like 1.2.3)"
+).option("--no-git-tag-version", "Do not create a git tag").action(async (type, options) => {
+  const validTypes = [
+    "patch",
+    "minor",
+    "major",
+    "prepatch",
+    "preminor",
+    "premajor",
+    "prerelease"
+  ];
+  if (!validTypes.includes(type) && !/^\d+\.\d+\.\d+/.test(type)) {
+    console.error(
+      `\u274C Invalid version type: ${type}. Use patch, minor, major, or a valid semver.`
+    );
+    process.exit(1);
+  }
+  console.log(`\u{1F4C8} Bumping version (${type})...`);
+  try {
+    const args = ["version", type];
+    if (!options.gitTagVersion) {
+      args.push("--no-git-tag-version");
+    }
+    await $5({ stdio: "inherit" })`npm ${args}`;
+    console.log("\u2705 Version bumped successfully!");
+  } catch (error) {
+    console.error("\u274C Failed to bump version.");
+    process.exit(1);
+  }
+});
+
+// src/core/info.ts
+import * as fs5 from "fs/promises";
+import * as path5 from "path";
+import { Command as Command7 } from "commander";
+async function getDirSize(dirPath) {
+  let size = 0;
+  const files = await fs5.readdir(dirPath, { withFileTypes: true });
+  for (const file of files) {
+    const fullPath = path5.join(dirPath, file.name);
+    if (file.isDirectory()) {
+      size += await getDirSize(fullPath);
+    } else {
+      const stats = await fs5.stat(fullPath);
+      size += stats.size;
+    }
+  }
+  return size;
+}
+var infoCommand = new Command7("info").description("Displays size and file statistics of the built package").action(async () => {
+  const cwd = process.cwd();
+  const pkgJsonPath = path5.join(cwd, "package.json");
+  try {
+    const packageJsonContent = await fs5.readFile(pkgJsonPath, {
+      encoding: "utf8"
+    });
+    const packageJson = JSON.parse(packageJsonContent);
+    const publishDirBase = packageJson.publishConfig?.directory;
+    if (!publishDirBase) {
+      throw new Error(`No publish directory specified in package.json.`);
+    }
+    const publishDir = path5.join(cwd, publishDirBase);
+    const sizeBytes = await getDirSize(publishDir);
+    const sizeKB = (sizeBytes / 1024).toFixed(2);
+    const sizeMB = (sizeBytes / (1024 * 1024)).toFixed(2);
+    console.log(`
+\u{1F4CA} Package Info: ${packageJson.name}`);
+    console.log(`================================`);
+    console.log(`Version:       ${packageJson.version}`);
+    console.log(`Build Folder:  ./${publishDirBase}`);
+    if (sizeBytes > 1024 * 1024) {
+      console.log(
+        `Total Size:    ${sizeMB} MB \u26A0\uFE0F (Consider keeping packages under 1MB)`
+      );
+    } else {
+      console.log(`Total Size:    ${sizeKB} KB \u2705`);
+    }
+    console.log(`================================
+`);
+  } catch (error) {
+    console.error(
+      "\u274C Error fetching package info. Did you build the project first?"
+    );
+    process.exit(1);
+  }
+});
+
+// src/core/link.ts
+import * as fs6 from "fs/promises";
+import * as path6 from "path";
+import { Command as Command8 } from "commander";
+import { $ as $6 } from "execa";
+var linkCommand = new Command8("link").description(
+  "Symlinks the built package directory so it can be tested in other local projects"
+).action(async () => {
+  const cwd = process.cwd();
+  const pkgJsonPath = path6.join(cwd, "package.json");
+  try {
+    const packageJsonContent = await fs6.readFile(pkgJsonPath, {
+      encoding: "utf8"
+    });
+    const packageJson = JSON.parse(packageJsonContent);
+    const publishDirBase = packageJson.publishConfig?.directory;
+    if (!publishDirBase) {
+      throw new Error(`No publish directory specified in package.json.`);
+    }
+    const publishDir = path6.join(cwd, publishDirBase);
+    console.log(`\u{1F517} Linking package from: ./${publishDirBase}...`);
+    await $6({
+      stdio: "inherit",
+      cwd: publishDir
+    })`npm link`;
+    console.log(`
+\u2705 Successfully linked!`);
+    console.log(
+      `To use this in another project, go to that project and run:`
+    );
+    console.log(`\u{1F449} npm link ${packageJson.name}`);
+  } catch (error) {
+    console.error("\u274C Error executing link command:");
+    if (error instanceof Error) console.error(error.message);
+    process.exit(1);
+  }
+});
+
+// src/core/check-exports.ts
+import * as fs7 from "fs/promises";
+import * as path7 from "path";
+import { Command as Command9 } from "commander";
+async function fileExists(filePath) {
+  return fs7.stat(filePath).then(() => true).catch(() => false);
+}
+function extractPaths(exportsObj) {
+  let paths = [];
+  if (typeof exportsObj === "string") {
+    return [exportsObj];
+  }
+  if (typeof exportsObj === "object" && exportsObj !== null) {
+    for (const key of Object.values(exportsObj)) {
+      paths = paths.concat(extractPaths(key));
+    }
+  }
+  return paths;
+}
+var checkExportsCommand = new Command9("check-exports").description(
+  "Verifies that all files declared in package.json 'exports' actually exist in the build folder"
+).action(async () => {
+  const cwd = process.cwd();
+  const pkgJsonPath = path7.join(cwd, "package.json");
+  try {
+    const rootPkgContent = await fs7.readFile(pkgJsonPath, {
+      encoding: "utf8"
+    });
+    const publishDirBase = JSON.parse(rootPkgContent).publishConfig?.directory || "build";
+    const buildPkgPath = path7.join(cwd, publishDirBase, "package.json");
+    if (!await fileExists(buildPkgPath)) {
+      throw new Error(
+        `Could not find compiled package.json at ./${publishDirBase}/package.json. Did you build first?`
+      );
+    }
+    const buildPkgContent = await fs7.readFile(buildPkgPath, {
+      encoding: "utf8"
+    });
+    const buildPkg = JSON.parse(buildPkgContent);
+    if (!buildPkg.exports) {
+      console.log("\u26A0\uFE0F No 'exports' field found to check.");
+      return;
+    }
+    console.log(`\u{1F575}\uFE0F Checking exports mapping in ./${publishDirBase}...`);
+    const allPaths = extractPaths(buildPkg.exports);
+    let hasErrors = false;
+    for (const relativePath of allPaths) {
+      const absolutePath = path7.join(cwd, publishDirBase, relativePath);
+      const exists = await fileExists(absolutePath);
+      if (exists) {
+        console.log(`  \u2705 Found: ${relativePath}`);
+      } else {
+        console.error(`  \u274C Missing: ${relativePath}`);
+        hasErrors = true;
+      }
+    }
+    if (hasErrors) {
+      console.error(
+        "\n\u274C Export check failed! Some files declared in package.json are missing."
+      );
+      process.exit(1);
+    } else {
+      console.log("\n\u2728 All exported files are present and accounted for!");
+    }
+  } catch (error) {
+    if (error instanceof Error) console.error(error.message);
+    process.exit(1);
+  }
+});
+
+// src/core/watch.ts
+import * as path8 from "path";
+import { Command as Command10 } from "commander";
+
+// node_modules/chokidar/index.js
+import { EventEmitter } from "events";
+import { stat as statcb, Stats } from "fs";
+import { readdir as readdir3, stat as stat7 } from "fs/promises";
+import * as sp2 from "path";
+
+// node_modules/readdirp/index.js
+import { lstat, readdir as readdir2, realpath, stat as stat5 } from "fs/promises";
+import { join as pjoin, relative as prelative, resolve as presolve, sep as psep } from "path";
+import { Readable } from "stream";
+var EntryTypes = {
+  FILE_TYPE: "files",
+  DIR_TYPE: "directories",
+  FILE_DIR_TYPE: "files_directories",
+  EVERYTHING_TYPE: "all"
+};
+var defaultOptions = {
+  root: ".",
+  fileFilter: (_entryInfo) => true,
+  directoryFilter: (_entryInfo) => true,
+  type: EntryTypes.FILE_TYPE,
+  lstat: false,
+  depth: 2147483648,
+  alwaysStat: false,
+  highWaterMark: 4096
+};
+Object.freeze(defaultOptions);
+var RECURSIVE_ERROR_CODE = "READDIRP_RECURSIVE_ERROR";
+var NORMAL_FLOW_ERRORS = /* @__PURE__ */ new Set(["ENOENT", "EPERM", "EACCES", "ELOOP", RECURSIVE_ERROR_CODE]);
+var ALL_TYPES = [
+  EntryTypes.DIR_TYPE,
+  EntryTypes.EVERYTHING_TYPE,
+  EntryTypes.FILE_DIR_TYPE,
+  EntryTypes.FILE_TYPE
+];
+var DIR_TYPES = /* @__PURE__ */ new Set([
+  EntryTypes.DIR_TYPE,
+  EntryTypes.EVERYTHING_TYPE,
+  EntryTypes.FILE_DIR_TYPE
+]);
+var FILE_TYPES = /* @__PURE__ */ new Set([
+  EntryTypes.EVERYTHING_TYPE,
+  EntryTypes.FILE_DIR_TYPE,
+  EntryTypes.FILE_TYPE
+]);
+var isNormalFlowError = (error) => NORMAL_FLOW_ERRORS.has(error.code);
+var wantBigintFsStats = process.platform === "win32";
+var emptyFn = (_entryInfo) => true;
+var normalizeFilter = (filter) => {
+  if (filter === void 0)
+    return emptyFn;
+  if (typeof filter === "function")
+    return filter;
+  if (typeof filter === "string") {
+    const fl = filter.trim();
+    return (entry) => entry.basename === fl;
+  }
+  if (Array.isArray(filter)) {
+    const trItems = filter.map((item) => item.trim());
+    return (entry) => trItems.some((f) => entry.basename === f);
+  }
+  return emptyFn;
+};
+var ReaddirpStream = class extends Readable {
+  parents;
+  reading;
+  parent;
+  _stat;
+  _maxDepth;
+  _wantsDir;
+  _wantsFile;
+  _wantsEverything;
+  _root;
+  _isDirent;
+  _statsProp;
+  _rdOptions;
+  _fileFilter;
+  _directoryFilter;
+  constructor(options = {}) {
+    super({
+      objectMode: true,
+      autoDestroy: true,
+      highWaterMark: options.highWaterMark
+    });
+    const opts = { ...defaultOptions, ...options };
+    const { root, type } = opts;
+    this._fileFilter = normalizeFilter(opts.fileFilter);
+    this._directoryFilter = normalizeFilter(opts.directoryFilter);
+    const statMethod = opts.lstat ? lstat : stat5;
+    if (wantBigintFsStats) {
+      this._stat = (path9) => statMethod(path9, { bigint: true });
+    } else {
+      this._stat = statMethod;
+    }
+    this._maxDepth = opts.depth != null && Number.isSafeInteger(opts.depth) ? opts.depth : defaultOptions.depth;
+    this._wantsDir = type ? DIR_TYPES.has(type) : false;
+    this._wantsFile = type ? FILE_TYPES.has(type) : false;
+    this._wantsEverything = type === EntryTypes.EVERYTHING_TYPE;
+    this._root = presolve(root);
+    this._isDirent = !opts.alwaysStat;
+    this._statsProp = this._isDirent ? "dirent" : "stats";
+    this._rdOptions = { encoding: "utf8", withFileTypes: this._isDirent };
+    this.parents = [this._exploreDir(root, 1)];
+    this.reading = false;
+    this.parent = void 0;
+  }
+  async _read(batch) {
+    if (this.reading)
+      return;
+    this.reading = true;
+    try {
+      while (!this.destroyed && batch > 0) {
+        const par = this.parent;
+        const fil = par && par.files;
+        if (fil && fil.length > 0) {
+          const { path: path9, depth } = par;
+          const slice = fil.splice(0, batch).map((dirent) => this._formatEntry(dirent, path9));
+          const awaited = await Promise.all(slice);
+          for (const entry of awaited) {
+            if (!entry)
+              continue;
+            if (this.destroyed)
+              return;
+            const entryType = await this._getEntryType(entry);
+            if (entryType === "directory" && this._directoryFilter(entry)) {
+              if (depth <= this._maxDepth) {
+                this.parents.push(this._exploreDir(entry.fullPath, depth + 1));
+              }
+              if (this._wantsDir) {
+                this.push(entry);
+                batch--;
+              }
+            } else if ((entryType === "file" || this._includeAsFile(entry)) && this._fileFilter(entry)) {
+              if (this._wantsFile) {
+                this.push(entry);
+                batch--;
+              }
+            }
+          }
+        } else {
+          const parent = this.parents.pop();
+          if (!parent) {
+            this.push(null);
+            break;
+          }
+          this.parent = await parent;
+          if (this.destroyed)
+            return;
+        }
+      }
+    } catch (error) {
+      this.destroy(error);
+    } finally {
+      this.reading = false;
+    }
+  }
+  async _exploreDir(path9, depth) {
+    let files;
+    try {
+      files = await readdir2(path9, this._rdOptions);
+    } catch (error) {
+      this._onError(error);
+    }
+    return { files, depth, path: path9 };
+  }
+  async _formatEntry(dirent, path9) {
+    let entry;
+    const basename4 = this._isDirent ? dirent.name : dirent;
+    try {
+      const fullPath = presolve(pjoin(path9, basename4));
+      entry = { path: prelative(this._root, fullPath), fullPath, basename: basename4 };
+      entry[this._statsProp] = this._isDirent ? dirent : await this._stat(fullPath);
+    } catch (err) {
+      this._onError(err);
+      return;
+    }
+    return entry;
+  }
+  _onError(err) {
+    if (isNormalFlowError(err) && !this.destroyed) {
+      this.emit("warn", err);
+    } else {
+      this.destroy(err);
+    }
+  }
+  async _getEntryType(entry) {
+    if (!entry && this._statsProp in entry) {
+      return "";
+    }
+    const stats = entry[this._statsProp];
+    if (stats.isFile())
+      return "file";
+    if (stats.isDirectory())
+      return "directory";
+    if (stats && stats.isSymbolicLink()) {
+      const full = entry.fullPath;
+      try {
+        const entryRealPath = await realpath(full);
+        const entryRealPathStats = await lstat(entryRealPath);
+        if (entryRealPathStats.isFile()) {
+          return "file";
+        }
+        if (entryRealPathStats.isDirectory()) {
+          const len = entryRealPath.length;
+          if (full.startsWith(entryRealPath) && full.substr(len, 1) === psep) {
+            const recursiveError = new Error(`Circular symlink detected: "${full}" points to "${entryRealPath}"`);
+            recursiveError.code = RECURSIVE_ERROR_CODE;
+            return this._onError(recursiveError);
+          }
+          return "directory";
+        }
+      } catch (error) {
+        this._onError(error);
+        return "";
+      }
+    }
+  }
+  _includeAsFile(entry) {
+    const stats = entry && entry[this._statsProp];
+    return stats && this._wantsEverything && !stats.isDirectory();
+  }
+};
+function readdirp(root, options = {}) {
+  let type = options.entryType || options.type;
+  if (type === "both")
+    type = EntryTypes.FILE_DIR_TYPE;
+  if (type)
+    options.type = type;
+  if (!root) {
+    throw new Error("readdirp: root argument is required. Usage: readdirp(root, options)");
+  } else if (typeof root !== "string") {
+    throw new TypeError("readdirp: root argument must be a string. Usage: readdirp(root, options)");
+  } else if (type && !ALL_TYPES.includes(type)) {
+    throw new Error(`readdirp: Invalid type passed. Use one of ${ALL_TYPES.join(", ")}`);
+  }
+  options.root = root;
+  return new ReaddirpStream(options);
+}
+
+// node_modules/chokidar/handler.js
+import { watch as fs_watch, unwatchFile, watchFile } from "fs";
+import { realpath as fsrealpath, lstat as lstat2, open, stat as stat6 } from "fs/promises";
+import { type as osType } from "os";
+import * as sp from "path";
+var STR_DATA = "data";
+var STR_END = "end";
+var STR_CLOSE = "close";
+var EMPTY_FN = () => {
+};
+var pl = process.platform;
+var isWindows = pl === "win32";
+var isMacos = pl === "darwin";
+var isLinux = pl === "linux";
+var isFreeBSD = pl === "freebsd";
+var isIBMi = osType() === "OS400";
+var EVENTS = {
+  ALL: "all",
+  READY: "ready",
+  ADD: "add",
+  CHANGE: "change",
+  ADD_DIR: "addDir",
+  UNLINK: "unlink",
+  UNLINK_DIR: "unlinkDir",
+  RAW: "raw",
+  ERROR: "error"
+};
+var EV = EVENTS;
+var THROTTLE_MODE_WATCH = "watch";
+var statMethods = { lstat: lstat2, stat: stat6 };
+var KEY_LISTENERS = "listeners";
+var KEY_ERR = "errHandlers";
+var KEY_RAW = "rawEmitters";
+var HANDLER_KEYS = [KEY_LISTENERS, KEY_ERR, KEY_RAW];
+var binaryExtensions = /* @__PURE__ */ new Set([
+  "3dm",
+  "3ds",
+  "3g2",
+  "3gp",
+  "7z",
+  "a",
+  "aac",
+  "adp",
+  "afdesign",
+  "afphoto",
+  "afpub",
+  "ai",
+  "aif",
+  "aiff",
+  "alz",
+  "ape",
+  "apk",
+  "appimage",
+  "ar",
+  "arj",
+  "asf",
+  "au",
+  "avi",
+  "bak",
+  "baml",
+  "bh",
+  "bin",
+  "bk",
+  "bmp",
+  "btif",
+  "bz2",
+  "bzip2",
+  "cab",
+  "caf",
+  "cgm",
+  "class",
+  "cmx",
+  "cpio",
+  "cr2",
+  "cur",
+  "dat",
+  "dcm",
+  "deb",
+  "dex",
+  "djvu",
+  "dll",
+  "dmg",
+  "dng",
+  "doc",
+  "docm",
+  "docx",
+  "dot",
+  "dotm",
+  "dra",
+  "DS_Store",
+  "dsk",
+  "dts",
+  "dtshd",
+  "dvb",
+  "dwg",
+  "dxf",
+  "ecelp4800",
+  "ecelp7470",
+  "ecelp9600",
+  "egg",
+  "eol",
+  "eot",
+  "epub",
+  "exe",
+  "f4v",
+  "fbs",
+  "fh",
+  "fla",
+  "flac",
+  "flatpak",
+  "fli",
+  "flv",
+  "fpx",
+  "fst",
+  "fvt",
+  "g3",
+  "gh",
+  "gif",
+  "graffle",
+  "gz",
+  "gzip",
+  "h261",
+  "h263",
+  "h264",
+  "icns",
+  "ico",
+  "ief",
+  "img",
+  "ipa",
+  "iso",
+  "jar",
+  "jpeg",
+  "jpg",
+  "jpgv",
+  "jpm",
+  "jxr",
+  "key",
+  "ktx",
+  "lha",
+  "lib",
+  "lvp",
+  "lz",
+  "lzh",
+  "lzma",
+  "lzo",
+  "m3u",
+  "m4a",
+  "m4v",
+  "mar",
+  "mdi",
+  "mht",
+  "mid",
+  "midi",
+  "mj2",
+  "mka",
+  "mkv",
+  "mmr",
+  "mng",
+  "mobi",
+  "mov",
+  "movie",
+  "mp3",
+  "mp4",
+  "mp4a",
+  "mpeg",
+  "mpg",
+  "mpga",
+  "mxu",
+  "nef",
+  "npx",
+  "numbers",
+  "nupkg",
+  "o",
+  "odp",
+  "ods",
+  "odt",
+  "oga",
+  "ogg",
+  "ogv",
+  "otf",
+  "ott",
+  "pages",
+  "pbm",
+  "pcx",
+  "pdb",
+  "pdf",
+  "pea",
+  "pgm",
+  "pic",
+  "png",
+  "pnm",
+  "pot",
+  "potm",
+  "potx",
+  "ppa",
+  "ppam",
+  "ppm",
+  "pps",
+  "ppsm",
+  "ppsx",
+  "ppt",
+  "pptm",
+  "pptx",
+  "psd",
+  "pya",
+  "pyc",
+  "pyo",
+  "pyv",
+  "qt",
+  "rar",
+  "ras",
+  "raw",
+  "resources",
+  "rgb",
+  "rip",
+  "rlc",
+  "rmf",
+  "rmvb",
+  "rpm",
+  "rtf",
+  "rz",
+  "s3m",
+  "s7z",
+  "scpt",
+  "sgi",
+  "shar",
+  "snap",
+  "sil",
+  "sketch",
+  "slk",
+  "smv",
+  "snk",
+  "so",
+  "stl",
+  "suo",
+  "sub",
+  "swf",
+  "tar",
+  "tbz",
+  "tbz2",
+  "tga",
+  "tgz",
+  "thmx",
+  "tif",
+  "tiff",
+  "tlz",
+  "ttc",
+  "ttf",
+  "txz",
+  "udf",
+  "uvh",
+  "uvi",
+  "uvm",
+  "uvp",
+  "uvs",
+  "uvu",
+  "viv",
+  "vob",
+  "war",
+  "wav",
+  "wax",
+  "wbmp",
+  "wdp",
+  "weba",
+  "webm",
+  "webp",
+  "whl",
+  "wim",
+  "wm",
+  "wma",
+  "wmv",
+  "wmx",
+  "woff",
+  "woff2",
+  "wrm",
+  "wvx",
+  "xbm",
+  "xif",
+  "xla",
+  "xlam",
+  "xls",
+  "xlsb",
+  "xlsm",
+  "xlsx",
+  "xlt",
+  "xltm",
+  "xltx",
+  "xm",
+  "xmind",
+  "xpi",
+  "xpm",
+  "xwd",
+  "xz",
+  "z",
+  "zip",
+  "zipx"
+]);
+var isBinaryPath = (filePath) => binaryExtensions.has(sp.extname(filePath).slice(1).toLowerCase());
+var foreach = (val, fn) => {
+  if (val instanceof Set) {
+    val.forEach(fn);
+  } else {
+    fn(val);
+  }
+};
+var addAndConvert = (main2, prop, item) => {
+  let container = main2[prop];
+  if (!(container instanceof Set)) {
+    main2[prop] = container = /* @__PURE__ */ new Set([container]);
+  }
+  container.add(item);
+};
+var clearItem = (cont) => (key) => {
+  const set = cont[key];
+  if (set instanceof Set) {
+    set.clear();
+  } else {
+    delete cont[key];
+  }
+};
+var delFromSet = (main2, prop, item) => {
+  const container = main2[prop];
+  if (container instanceof Set) {
+    container.delete(item);
+  } else if (container === item) {
+    delete main2[prop];
+  }
+};
+var isEmptySet = (val) => val instanceof Set ? val.size === 0 : !val;
+var FsWatchInstances = /* @__PURE__ */ new Map();
+function createFsWatchInstance(path9, options, listener, errHandler, emitRaw) {
+  const handleEvent = (rawEvent, evPath) => {
+    listener(path9);
+    emitRaw(rawEvent, evPath, { watchedPath: path9 });
+    if (evPath && path9 !== evPath) {
+      fsWatchBroadcast(sp.resolve(path9, evPath), KEY_LISTENERS, sp.join(path9, evPath));
+    }
+  };
+  try {
+    return fs_watch(path9, {
+      persistent: options.persistent
+    }, handleEvent);
+  } catch (error) {
+    errHandler(error);
+    return void 0;
+  }
+}
+var fsWatchBroadcast = (fullPath, listenerType, val1, val2, val3) => {
+  const cont = FsWatchInstances.get(fullPath);
+  if (!cont)
+    return;
+  foreach(cont[listenerType], (listener) => {
+    listener(val1, val2, val3);
+  });
+};
+var setFsWatchListener = (path9, fullPath, options, handlers) => {
+  const { listener, errHandler, rawEmitter } = handlers;
+  let cont = FsWatchInstances.get(fullPath);
+  let watcher;
+  if (!options.persistent) {
+    watcher = createFsWatchInstance(path9, options, listener, errHandler, rawEmitter);
+    if (!watcher)
+      return;
+    return watcher.close.bind(watcher);
+  }
+  if (cont) {
+    addAndConvert(cont, KEY_LISTENERS, listener);
+    addAndConvert(cont, KEY_ERR, errHandler);
+    addAndConvert(cont, KEY_RAW, rawEmitter);
+  } else {
+    watcher = createFsWatchInstance(
+      path9,
+      options,
+      fsWatchBroadcast.bind(null, fullPath, KEY_LISTENERS),
+      errHandler,
+      // no need to use broadcast here
+      fsWatchBroadcast.bind(null, fullPath, KEY_RAW)
+    );
+    if (!watcher)
+      return;
+    watcher.on(EV.ERROR, async (error) => {
+      const broadcastErr = fsWatchBroadcast.bind(null, fullPath, KEY_ERR);
+      if (cont)
+        cont.watcherUnusable = true;
+      if (isWindows && error.code === "EPERM") {
+        try {
+          const fd = await open(path9, "r");
+          await fd.close();
+          broadcastErr(error);
+        } catch (err) {
+        }
+      } else {
+        broadcastErr(error);
+      }
+    });
+    cont = {
+      listeners: listener,
+      errHandlers: errHandler,
+      rawEmitters: rawEmitter,
+      watcher
+    };
+    FsWatchInstances.set(fullPath, cont);
+  }
+  return () => {
+    delFromSet(cont, KEY_LISTENERS, listener);
+    delFromSet(cont, KEY_ERR, errHandler);
+    delFromSet(cont, KEY_RAW, rawEmitter);
+    if (isEmptySet(cont.listeners)) {
+      cont.watcher.close();
+      FsWatchInstances.delete(fullPath);
+      HANDLER_KEYS.forEach(clearItem(cont));
+      cont.watcher = void 0;
+      Object.freeze(cont);
+    }
+  };
+};
+var FsWatchFileInstances = /* @__PURE__ */ new Map();
+var setFsWatchFileListener = (path9, fullPath, options, handlers) => {
+  const { listener, rawEmitter } = handlers;
+  let cont = FsWatchFileInstances.get(fullPath);
+  const copts = cont && cont.options;
+  if (copts && (copts.persistent < options.persistent || copts.interval > options.interval)) {
+    unwatchFile(fullPath);
+    cont = void 0;
+  }
+  if (cont) {
+    addAndConvert(cont, KEY_LISTENERS, listener);
+    addAndConvert(cont, KEY_RAW, rawEmitter);
+  } else {
+    cont = {
+      listeners: listener,
+      rawEmitters: rawEmitter,
+      options,
+      watcher: watchFile(fullPath, options, (curr, prev) => {
+        foreach(cont.rawEmitters, (rawEmitter2) => {
+          rawEmitter2(EV.CHANGE, fullPath, { curr, prev });
+        });
+        const currmtime = curr.mtimeMs;
+        if (curr.size !== prev.size || currmtime > prev.mtimeMs || currmtime === 0) {
+          foreach(cont.listeners, (listener2) => listener2(path9, curr));
+        }
+      })
+    };
+    FsWatchFileInstances.set(fullPath, cont);
+  }
+  return () => {
+    delFromSet(cont, KEY_LISTENERS, listener);
+    delFromSet(cont, KEY_RAW, rawEmitter);
+    if (isEmptySet(cont.listeners)) {
+      FsWatchFileInstances.delete(fullPath);
+      unwatchFile(fullPath);
+      cont.options = cont.watcher = void 0;
+      Object.freeze(cont);
+    }
+  };
+};
+var NodeFsHandler = class {
+  fsw;
+  _boundHandleError;
+  constructor(fsW) {
+    this.fsw = fsW;
+    this._boundHandleError = (error) => fsW._handleError(error);
+  }
+  /**
+   * Watch file for changes with fs_watchFile or fs_watch.
+   * @param path to file or dir
+   * @param listener on fs change
+   * @returns closer for the watcher instance
+   */
+  _watchWithNodeFs(path9, listener) {
+    const opts = this.fsw.options;
+    const directory = sp.dirname(path9);
+    const basename4 = sp.basename(path9);
+    const parent = this.fsw._getWatchedDir(directory);
+    parent.add(basename4);
+    const absolutePath = sp.resolve(path9);
+    const options = {
+      persistent: opts.persistent
+    };
+    if (!listener)
+      listener = EMPTY_FN;
+    let closer;
+    if (opts.usePolling) {
+      const enableBin = opts.interval !== opts.binaryInterval;
+      options.interval = enableBin && isBinaryPath(basename4) ? opts.binaryInterval : opts.interval;
+      closer = setFsWatchFileListener(path9, absolutePath, options, {
+        listener,
+        rawEmitter: this.fsw._emitRaw
+      });
+    } else {
+      closer = setFsWatchListener(path9, absolutePath, options, {
+        listener,
+        errHandler: this._boundHandleError,
+        rawEmitter: this.fsw._emitRaw
+      });
+    }
+    return closer;
+  }
+  /**
+   * Watch a file and emit add event if warranted.
+   * @returns closer for the watcher instance
+   */
+  _handleFile(file, stats, initialAdd) {
+    if (this.fsw.closed) {
+      return;
+    }
+    const dirname4 = sp.dirname(file);
+    const basename4 = sp.basename(file);
+    const parent = this.fsw._getWatchedDir(dirname4);
+    let prevStats = stats;
+    if (parent.has(basename4))
+      return;
+    const listener = async (path9, newStats) => {
+      if (!this.fsw._throttle(THROTTLE_MODE_WATCH, file, 5))
+        return;
+      if (!newStats || newStats.mtimeMs === 0) {
+        try {
+          const newStats2 = await stat6(file);
+          if (this.fsw.closed)
+            return;
+          const at = newStats2.atimeMs;
+          const mt = newStats2.mtimeMs;
+          if (!at || at <= mt || mt !== prevStats.mtimeMs) {
+            this.fsw._emit(EV.CHANGE, file, newStats2);
+          }
+          if ((isMacos || isLinux || isFreeBSD) && prevStats.ino !== newStats2.ino) {
+            this.fsw._closeFile(path9);
+            prevStats = newStats2;
+            const closer2 = this._watchWithNodeFs(file, listener);
+            if (closer2)
+              this.fsw._addPathCloser(path9, closer2);
+          } else {
+            prevStats = newStats2;
+          }
+        } catch (error) {
+          this.fsw._remove(dirname4, basename4);
+        }
+      } else if (parent.has(basename4)) {
+        const at = newStats.atimeMs;
+        const mt = newStats.mtimeMs;
+        if (!at || at <= mt || mt !== prevStats.mtimeMs) {
+          this.fsw._emit(EV.CHANGE, file, newStats);
+        }
+        prevStats = newStats;
+      }
+    };
+    const closer = this._watchWithNodeFs(file, listener);
+    if (!(initialAdd && this.fsw.options.ignoreInitial) && this.fsw._isntIgnored(file)) {
+      if (!this.fsw._throttle(EV.ADD, file, 0))
+        return;
+      this.fsw._emit(EV.ADD, file, stats);
+    }
+    return closer;
+  }
+  /**
+   * Handle symlinks encountered while reading a dir.
+   * @param entry returned by readdirp
+   * @param directory path of dir being read
+   * @param path of this item
+   * @param item basename of this item
+   * @returns true if no more processing is needed for this entry.
+   */
+  async _handleSymlink(entry, directory, path9, item) {
+    if (this.fsw.closed) {
+      return;
+    }
+    const full = entry.fullPath;
+    const dir = this.fsw._getWatchedDir(directory);
+    if (!this.fsw.options.followSymlinks) {
+      this.fsw._incrReadyCount();
+      let linkPath;
+      try {
+        linkPath = await fsrealpath(path9);
+      } catch (e) {
+        this.fsw._emitReady();
+        return true;
+      }
+      if (this.fsw.closed)
+        return;
+      if (dir.has(item)) {
+        if (this.fsw._symlinkPaths.get(full) !== linkPath) {
+          this.fsw._symlinkPaths.set(full, linkPath);
+          this.fsw._emit(EV.CHANGE, path9, entry.stats);
+        }
+      } else {
+        dir.add(item);
+        this.fsw._symlinkPaths.set(full, linkPath);
+        this.fsw._emit(EV.ADD, path9, entry.stats);
+      }
+      this.fsw._emitReady();
+      return true;
+    }
+    if (this.fsw._symlinkPaths.has(full)) {
+      return true;
+    }
+    this.fsw._symlinkPaths.set(full, true);
+  }
+  _handleRead(directory, initialAdd, wh, target, dir, depth, throttler) {
+    directory = sp.join(directory, "");
+    const throttleKey = target ? `${directory}:${target}` : directory;
+    throttler = this.fsw._throttle("readdir", throttleKey, 1e3);
+    if (!throttler)
+      return;
+    const previous = this.fsw._getWatchedDir(wh.path);
+    const current = /* @__PURE__ */ new Set();
+    let stream = this.fsw._readdirp(directory, {
+      fileFilter: (entry) => wh.filterPath(entry),
+      directoryFilter: (entry) => wh.filterDir(entry)
+    });
+    if (!stream)
+      return;
+    stream.on(STR_DATA, async (entry) => {
+      if (this.fsw.closed) {
+        stream = void 0;
+        return;
+      }
+      const item = entry.path;
+      let path9 = sp.join(directory, item);
+      current.add(item);
+      if (entry.stats.isSymbolicLink() && await this._handleSymlink(entry, directory, path9, item)) {
+        return;
+      }
+      if (this.fsw.closed) {
+        stream = void 0;
+        return;
+      }
+      if (item === target || !target && !previous.has(item)) {
+        this.fsw._incrReadyCount();
+        path9 = sp.join(dir, sp.relative(dir, path9));
+        this._addToNodeFs(path9, initialAdd, wh, depth + 1);
+      }
+    }).on(EV.ERROR, this._boundHandleError);
+    return new Promise((resolve4, reject) => {
+      if (!stream)
+        return reject();
+      stream.once(STR_END, () => {
+        if (this.fsw.closed) {
+          stream = void 0;
+          return;
+        }
+        const wasThrottled = throttler ? throttler.clear() : false;
+        resolve4(void 0);
+        previous.getChildren().filter((item) => {
+          return item !== directory && !current.has(item);
+        }).forEach((item) => {
+          this.fsw._remove(directory, item);
+        });
+        stream = void 0;
+        if (wasThrottled)
+          this._handleRead(directory, false, wh, target, dir, depth, throttler);
+      });
+    });
+  }
+  /**
+   * Read directory to add / remove files from `@watched` list and re-read it on change.
+   * @param dir fs path
+   * @param stats
+   * @param initialAdd
+   * @param depth relative to user-supplied path
+   * @param target child path targeted for watch
+   * @param wh Common watch helpers for this path
+   * @param realpath
+   * @returns closer for the watcher instance.
+   */
+  async _handleDir(dir, stats, initialAdd, depth, target, wh, realpath2) {
+    const parentDir = this.fsw._getWatchedDir(sp.dirname(dir));
+    const tracked = parentDir.has(sp.basename(dir));
+    if (!(initialAdd && this.fsw.options.ignoreInitial) && !target && !tracked) {
+      this.fsw._emit(EV.ADD_DIR, dir, stats);
+    }
+    parentDir.add(sp.basename(dir));
+    this.fsw._getWatchedDir(dir);
+    let throttler;
+    let closer;
+    const oDepth = this.fsw.options.depth;
+    if ((oDepth == null || depth <= oDepth) && !this.fsw._symlinkPaths.has(realpath2)) {
+      if (!target) {
+        await this._handleRead(dir, initialAdd, wh, target, dir, depth, throttler);
+        if (this.fsw.closed)
+          return;
+      }
+      closer = this._watchWithNodeFs(dir, (dirPath, stats2) => {
+        if (stats2 && stats2.mtimeMs === 0)
+          return;
+        this._handleRead(dirPath, false, wh, target, dir, depth, throttler);
+      });
+    }
+    return closer;
+  }
+  /**
+   * Handle added file, directory, or glob pattern.
+   * Delegates call to _handleFile / _handleDir after checks.
+   * @param path to file or ir
+   * @param initialAdd was the file added at watch instantiation?
+   * @param priorWh depth relative to user-supplied path
+   * @param depth Child path actually targeted for watch
+   * @param target Child path actually targeted for watch
+   */
+  async _addToNodeFs(path9, initialAdd, priorWh, depth, target) {
+    const ready = this.fsw._emitReady;
+    if (this.fsw._isIgnored(path9) || this.fsw.closed) {
+      ready();
+      return false;
+    }
+    const wh = this.fsw._getWatchHelpers(path9);
+    if (priorWh) {
+      wh.filterPath = (entry) => priorWh.filterPath(entry);
+      wh.filterDir = (entry) => priorWh.filterDir(entry);
+    }
+    try {
+      const stats = await statMethods[wh.statMethod](wh.watchPath);
+      if (this.fsw.closed)
+        return;
+      if (this.fsw._isIgnored(wh.watchPath, stats)) {
+        ready();
+        return false;
+      }
+      const follow = this.fsw.options.followSymlinks;
+      let closer;
+      if (stats.isDirectory()) {
+        const absPath = sp.resolve(path9);
+        const targetPath = follow ? await fsrealpath(path9) : path9;
+        if (this.fsw.closed)
+          return;
+        closer = await this._handleDir(wh.watchPath, stats, initialAdd, depth, target, wh, targetPath);
+        if (this.fsw.closed)
+          return;
+        if (absPath !== targetPath && targetPath !== void 0) {
+          this.fsw._symlinkPaths.set(absPath, targetPath);
+        }
+      } else if (stats.isSymbolicLink()) {
+        const targetPath = follow ? await fsrealpath(path9) : path9;
+        if (this.fsw.closed)
+          return;
+        const parent = sp.dirname(wh.watchPath);
+        this.fsw._getWatchedDir(parent).add(wh.watchPath);
+        this.fsw._emit(EV.ADD, wh.watchPath, stats);
+        closer = await this._handleDir(parent, stats, initialAdd, depth, path9, wh, targetPath);
+        if (this.fsw.closed)
+          return;
+        if (targetPath !== void 0) {
+          this.fsw._symlinkPaths.set(sp.resolve(path9), targetPath);
+        }
+      } else {
+        closer = this._handleFile(wh.watchPath, stats, initialAdd);
+      }
+      ready();
+      if (closer)
+        this.fsw._addPathCloser(path9, closer);
+      return false;
+    } catch (error) {
+      if (this.fsw._handleError(error)) {
+        ready();
+        return path9;
+      }
+    }
+  }
+};
+
+// node_modules/chokidar/index.js
+var SLASH = "/";
+var SLASH_SLASH = "//";
+var ONE_DOT = ".";
+var TWO_DOTS = "..";
+var STRING_TYPE = "string";
+var BACK_SLASH_RE = /\\/g;
+var DOUBLE_SLASH_RE = /\/\//g;
+var DOT_RE = /\..*\.(sw[px])$|~$|\.subl.*\.tmp/;
+var REPLACER_RE = /^\.[/\\]/;
+function arrify(item) {
+  return Array.isArray(item) ? item : [item];
+}
+var isMatcherObject = (matcher) => typeof matcher === "object" && matcher !== null && !(matcher instanceof RegExp);
+function createPattern(matcher) {
+  if (typeof matcher === "function")
+    return matcher;
+  if (typeof matcher === "string")
+    return (string) => matcher === string;
+  if (matcher instanceof RegExp)
+    return (string) => matcher.test(string);
+  if (typeof matcher === "object" && matcher !== null) {
+    return (string) => {
+      if (matcher.path === string)
+        return true;
+      if (matcher.recursive) {
+        const relative3 = sp2.relative(matcher.path, string);
+        if (!relative3) {
+          return false;
+        }
+        return !relative3.startsWith("..") && !sp2.isAbsolute(relative3);
+      }
+      return false;
+    };
+  }
+  return () => false;
+}
+function normalizePath(path9) {
+  if (typeof path9 !== "string")
+    throw new Error("string expected");
+  path9 = sp2.normalize(path9);
+  path9 = path9.replace(/\\/g, "/");
+  let prepend = false;
+  if (path9.startsWith("//"))
+    prepend = true;
+  path9 = path9.replace(DOUBLE_SLASH_RE, "/");
+  if (prepend)
+    path9 = "/" + path9;
+  return path9;
+}
+function matchPatterns(patterns, testString, stats) {
+  const path9 = normalizePath(testString);
+  for (let index = 0; index < patterns.length; index++) {
+    const pattern = patterns[index];
+    if (pattern(path9, stats)) {
+      return true;
+    }
+  }
+  return false;
+}
+function anymatch(matchers, testString) {
+  if (matchers == null) {
+    throw new TypeError("anymatch: specify first argument");
+  }
+  const matchersArray = arrify(matchers);
+  const patterns = matchersArray.map((matcher) => createPattern(matcher));
+  if (testString == null) {
+    return (testString2, stats) => {
+      return matchPatterns(patterns, testString2, stats);
+    };
+  }
+  return matchPatterns(patterns, testString);
+}
+var unifyPaths = (paths_) => {
+  const paths = arrify(paths_).flat();
+  if (!paths.every((p) => typeof p === STRING_TYPE)) {
+    throw new TypeError(`Non-string provided as watch path: ${paths}`);
+  }
+  return paths.map(normalizePathToUnix);
+};
+var toUnix = (string) => {
+  let str = string.replace(BACK_SLASH_RE, SLASH);
+  let prepend = false;
+  if (str.startsWith(SLASH_SLASH)) {
+    prepend = true;
+  }
+  str = str.replace(DOUBLE_SLASH_RE, SLASH);
+  if (prepend) {
+    str = SLASH + str;
+  }
+  return str;
+};
+var normalizePathToUnix = (path9) => toUnix(sp2.normalize(toUnix(path9)));
+var normalizeIgnored = (cwd = "") => (path9) => {
+  if (typeof path9 === "string") {
+    return normalizePathToUnix(sp2.isAbsolute(path9) ? path9 : sp2.join(cwd, path9));
+  } else {
+    return path9;
+  }
+};
+var getAbsolutePath = (path9, cwd) => {
+  if (sp2.isAbsolute(path9)) {
+    return path9;
+  }
+  return sp2.join(cwd, path9);
+};
+var EMPTY_SET = Object.freeze(/* @__PURE__ */ new Set());
+var DirEntry = class {
+  path;
+  _removeWatcher;
+  items;
+  constructor(dir, removeWatcher) {
+    this.path = dir;
+    this._removeWatcher = removeWatcher;
+    this.items = /* @__PURE__ */ new Set();
+  }
+  add(item) {
+    const { items } = this;
+    if (!items)
+      return;
+    if (item !== ONE_DOT && item !== TWO_DOTS)
+      items.add(item);
+  }
+  async remove(item) {
+    const { items } = this;
+    if (!items)
+      return;
+    items.delete(item);
+    if (items.size > 0)
+      return;
+    const dir = this.path;
+    try {
+      await readdir3(dir);
+    } catch (err) {
+      if (this._removeWatcher) {
+        this._removeWatcher(sp2.dirname(dir), sp2.basename(dir));
+      }
+    }
+  }
+  has(item) {
+    const { items } = this;
+    if (!items)
+      return;
+    return items.has(item);
+  }
+  getChildren() {
+    const { items } = this;
+    if (!items)
+      return [];
+    return [...items.values()];
+  }
+  dispose() {
+    this.items.clear();
+    this.path = "";
+    this._removeWatcher = EMPTY_FN;
+    this.items = EMPTY_SET;
+    Object.freeze(this);
+  }
+};
+var STAT_METHOD_F = "stat";
+var STAT_METHOD_L = "lstat";
+var WatchHelper = class {
+  fsw;
+  path;
+  watchPath;
+  fullWatchPath;
+  dirParts;
+  followSymlinks;
+  statMethod;
+  constructor(path9, follow, fsw) {
+    this.fsw = fsw;
+    const watchPath = path9;
+    this.path = path9 = path9.replace(REPLACER_RE, "");
+    this.watchPath = watchPath;
+    this.fullWatchPath = sp2.resolve(watchPath);
+    this.dirParts = [];
+    this.dirParts.forEach((parts) => {
+      if (parts.length > 1)
+        parts.pop();
+    });
+    this.followSymlinks = follow;
+    this.statMethod = follow ? STAT_METHOD_F : STAT_METHOD_L;
+  }
+  entryPath(entry) {
+    return sp2.join(this.watchPath, sp2.relative(this.watchPath, entry.fullPath));
+  }
+  filterPath(entry) {
+    const { stats } = entry;
+    if (stats && stats.isSymbolicLink())
+      return this.filterDir(entry);
+    const resolvedPath = this.entryPath(entry);
+    return this.fsw._isntIgnored(resolvedPath, stats) && this.fsw._hasReadPermissions(stats);
+  }
+  filterDir(entry) {
+    return this.fsw._isntIgnored(this.entryPath(entry), entry.stats);
+  }
+};
+var FSWatcher = class extends EventEmitter {
+  closed;
+  options;
+  _closers;
+  _ignoredPaths;
+  _throttled;
+  _streams;
+  _symlinkPaths;
+  _watched;
+  _pendingWrites;
+  _pendingUnlinks;
+  _readyCount;
+  _emitReady;
+  _closePromise;
+  _userIgnored;
+  _readyEmitted;
+  _emitRaw;
+  _boundRemove;
+  _nodeFsHandler;
+  // Not indenting methods for history sake; for now.
+  constructor(_opts = {}) {
+    super();
+    this.closed = false;
+    this._closers = /* @__PURE__ */ new Map();
+    this._ignoredPaths = /* @__PURE__ */ new Set();
+    this._throttled = /* @__PURE__ */ new Map();
+    this._streams = /* @__PURE__ */ new Set();
+    this._symlinkPaths = /* @__PURE__ */ new Map();
+    this._watched = /* @__PURE__ */ new Map();
+    this._pendingWrites = /* @__PURE__ */ new Map();
+    this._pendingUnlinks = /* @__PURE__ */ new Map();
+    this._readyCount = 0;
+    this._readyEmitted = false;
+    const awf = _opts.awaitWriteFinish;
+    const DEF_AWF = { stabilityThreshold: 2e3, pollInterval: 100 };
+    const opts = {
+      // Defaults
+      persistent: true,
+      ignoreInitial: false,
+      ignorePermissionErrors: false,
+      interval: 100,
+      binaryInterval: 300,
+      followSymlinks: true,
+      usePolling: false,
+      // useAsync: false,
+      atomic: true,
+      // NOTE: overwritten later (depends on usePolling)
+      ..._opts,
+      // Change format
+      ignored: _opts.ignored ? arrify(_opts.ignored) : arrify([]),
+      awaitWriteFinish: awf === true ? DEF_AWF : typeof awf === "object" ? { ...DEF_AWF, ...awf } : false
+    };
+    if (isIBMi)
+      opts.usePolling = true;
+    if (opts.atomic === void 0)
+      opts.atomic = !opts.usePolling;
+    const envPoll = process.env.CHOKIDAR_USEPOLLING;
+    if (envPoll !== void 0) {
+      const envLower = envPoll.toLowerCase();
+      if (envLower === "false" || envLower === "0")
+        opts.usePolling = false;
+      else if (envLower === "true" || envLower === "1")
+        opts.usePolling = true;
+      else
+        opts.usePolling = !!envLower;
+    }
+    const envInterval = process.env.CHOKIDAR_INTERVAL;
+    if (envInterval)
+      opts.interval = Number.parseInt(envInterval, 10);
+    let readyCalls = 0;
+    this._emitReady = () => {
+      readyCalls++;
+      if (readyCalls >= this._readyCount) {
+        this._emitReady = EMPTY_FN;
+        this._readyEmitted = true;
+        process.nextTick(() => this.emit(EVENTS.READY));
+      }
+    };
+    this._emitRaw = (...args) => this.emit(EVENTS.RAW, ...args);
+    this._boundRemove = this._remove.bind(this);
+    this.options = opts;
+    this._nodeFsHandler = new NodeFsHandler(this);
+    Object.freeze(opts);
+  }
+  _addIgnoredPath(matcher) {
+    if (isMatcherObject(matcher)) {
+      for (const ignored of this._ignoredPaths) {
+        if (isMatcherObject(ignored) && ignored.path === matcher.path && ignored.recursive === matcher.recursive) {
+          return;
+        }
+      }
+    }
+    this._ignoredPaths.add(matcher);
+  }
+  _removeIgnoredPath(matcher) {
+    this._ignoredPaths.delete(matcher);
+    if (typeof matcher === "string") {
+      for (const ignored of this._ignoredPaths) {
+        if (isMatcherObject(ignored) && ignored.path === matcher) {
+          this._ignoredPaths.delete(ignored);
+        }
+      }
+    }
+  }
+  // Public methods
+  /**
+   * Adds paths to be watched on an existing FSWatcher instance.
+   * @param paths_ file or file list. Other arguments are unused
+   */
+  add(paths_, _origAdd, _internal) {
+    const { cwd } = this.options;
+    this.closed = false;
+    this._closePromise = void 0;
+    let paths = unifyPaths(paths_);
+    if (cwd) {
+      paths = paths.map((path9) => {
+        const absPath = getAbsolutePath(path9, cwd);
+        return absPath;
+      });
+    }
+    paths.forEach((path9) => {
+      this._removeIgnoredPath(path9);
+    });
+    this._userIgnored = void 0;
+    if (!this._readyCount)
+      this._readyCount = 0;
+    this._readyCount += paths.length;
+    Promise.all(paths.map(async (path9) => {
+      const res = await this._nodeFsHandler._addToNodeFs(path9, !_internal, void 0, 0, _origAdd);
+      if (res)
+        this._emitReady();
+      return res;
+    })).then((results) => {
+      if (this.closed)
+        return;
+      results.forEach((item) => {
+        if (item)
+          this.add(sp2.dirname(item), sp2.basename(_origAdd || item));
+      });
+    });
+    return this;
+  }
+  /**
+   * Close watchers or start ignoring events from specified paths.
+   */
+  unwatch(paths_) {
+    if (this.closed)
+      return this;
+    const paths = unifyPaths(paths_);
+    const { cwd } = this.options;
+    paths.forEach((path9) => {
+      if (!sp2.isAbsolute(path9) && !this._closers.has(path9)) {
+        if (cwd)
+          path9 = sp2.join(cwd, path9);
+        path9 = sp2.resolve(path9);
+      }
+      this._closePath(path9);
+      this._addIgnoredPath(path9);
+      if (this._watched.has(path9)) {
+        this._addIgnoredPath({
+          path: path9,
+          recursive: true
+        });
+      }
+      this._userIgnored = void 0;
+    });
+    return this;
+  }
+  /**
+   * Close watchers and remove all listeners from watched paths.
+   */
+  close() {
+    if (this._closePromise) {
+      return this._closePromise;
+    }
+    this.closed = true;
+    this.removeAllListeners();
+    const closers = [];
+    this._closers.forEach((closerList) => closerList.forEach((closer) => {
+      const promise = closer();
+      if (promise instanceof Promise)
+        closers.push(promise);
+    }));
+    this._streams.forEach((stream) => stream.destroy());
+    this._userIgnored = void 0;
+    this._readyCount = 0;
+    this._readyEmitted = false;
+    this._watched.forEach((dirent) => dirent.dispose());
+    this._closers.clear();
+    this._watched.clear();
+    this._streams.clear();
+    this._symlinkPaths.clear();
+    this._throttled.clear();
+    this._closePromise = closers.length ? Promise.all(closers).then(() => void 0) : Promise.resolve();
+    return this._closePromise;
+  }
+  /**
+   * Expose list of watched paths
+   * @returns for chaining
+   */
+  getWatched() {
+    const watchList = {};
+    this._watched.forEach((entry, dir) => {
+      const key = this.options.cwd ? sp2.relative(this.options.cwd, dir) : dir;
+      const index = key || ONE_DOT;
+      watchList[index] = entry.getChildren().sort();
+    });
+    return watchList;
+  }
+  emitWithAll(event, args) {
+    this.emit(event, ...args);
+    if (event !== EVENTS.ERROR)
+      this.emit(EVENTS.ALL, event, ...args);
+  }
+  // Common helpers
+  // --------------
+  /**
+   * Normalize and emit events.
+   * Calling _emit DOES NOT MEAN emit() would be called!
+   * @param event Type of event
+   * @param path File or directory path
+   * @param stats arguments to be passed with event
+   * @returns the error if defined, otherwise the value of the FSWatcher instance's `closed` flag
+   */
+  async _emit(event, path9, stats) {
+    if (this.closed)
+      return;
+    const opts = this.options;
+    if (isWindows)
+      path9 = sp2.normalize(path9);
+    if (opts.cwd)
+      path9 = sp2.relative(opts.cwd, path9);
+    const args = [path9];
+    if (stats != null)
+      args.push(stats);
+    const awf = opts.awaitWriteFinish;
+    let pw;
+    if (awf && (pw = this._pendingWrites.get(path9))) {
+      pw.lastChange = /* @__PURE__ */ new Date();
+      return this;
+    }
+    if (opts.atomic) {
+      if (event === EVENTS.UNLINK) {
+        this._pendingUnlinks.set(path9, [event, ...args]);
+        setTimeout(() => {
+          this._pendingUnlinks.forEach((entry, path10) => {
+            this.emit(...entry);
+            this.emit(EVENTS.ALL, ...entry);
+            this._pendingUnlinks.delete(path10);
+          });
+        }, typeof opts.atomic === "number" ? opts.atomic : 100);
+        return this;
+      }
+      if (event === EVENTS.ADD && this._pendingUnlinks.has(path9)) {
+        event = EVENTS.CHANGE;
+        this._pendingUnlinks.delete(path9);
+      }
+    }
+    if (awf && (event === EVENTS.ADD || event === EVENTS.CHANGE) && this._readyEmitted) {
+      const awfEmit = (err, stats2) => {
+        if (err) {
+          event = EVENTS.ERROR;
+          args[0] = err;
+          this.emitWithAll(event, args);
+        } else if (stats2) {
+          if (args.length > 1) {
+            args[1] = stats2;
+          } else {
+            args.push(stats2);
+          }
+          this.emitWithAll(event, args);
+        }
+      };
+      this._awaitWriteFinish(path9, awf.stabilityThreshold, event, awfEmit);
+      return this;
+    }
+    if (event === EVENTS.CHANGE) {
+      const isThrottled = !this._throttle(EVENTS.CHANGE, path9, 50);
+      if (isThrottled)
+        return this;
+    }
+    if (opts.alwaysStat && stats === void 0 && (event === EVENTS.ADD || event === EVENTS.ADD_DIR || event === EVENTS.CHANGE)) {
+      const fullPath = opts.cwd ? sp2.join(opts.cwd, path9) : path9;
+      let stats2;
+      try {
+        stats2 = await stat7(fullPath);
+      } catch (err) {
+      }
+      if (!stats2 || this.closed)
+        return;
+      args.push(stats2);
+    }
+    this.emitWithAll(event, args);
+    return this;
+  }
+  /**
+   * Common handler for errors
+   * @returns The error if defined, otherwise the value of the FSWatcher instance's `closed` flag
+   */
+  _handleError(error) {
+    const code = error && error.code;
+    if (error && code !== "ENOENT" && code !== "ENOTDIR" && (!this.options.ignorePermissionErrors || code !== "EPERM" && code !== "EACCES")) {
+      this.emit(EVENTS.ERROR, error);
+    }
+    return error || this.closed;
+  }
+  /**
+   * Helper utility for throttling
+   * @param actionType type being throttled
+   * @param path being acted upon
+   * @param timeout duration of time to suppress duplicate actions
+   * @returns tracking object or false if action should be suppressed
+   */
+  _throttle(actionType, path9, timeout) {
+    if (!this._throttled.has(actionType)) {
+      this._throttled.set(actionType, /* @__PURE__ */ new Map());
+    }
+    const action = this._throttled.get(actionType);
+    if (!action)
+      throw new Error("invalid throttle");
+    const actionPath = action.get(path9);
+    if (actionPath) {
+      actionPath.count++;
+      return false;
+    }
+    let timeoutObject;
+    const clear = () => {
+      const item = action.get(path9);
+      const count = item ? item.count : 0;
+      action.delete(path9);
+      clearTimeout(timeoutObject);
+      if (item)
+        clearTimeout(item.timeoutObject);
+      return count;
+    };
+    timeoutObject = setTimeout(clear, timeout);
+    const thr = { timeoutObject, clear, count: 0 };
+    action.set(path9, thr);
+    return thr;
+  }
+  _incrReadyCount() {
+    return this._readyCount++;
+  }
+  /**
+   * Awaits write operation to finish.
+   * Polls a newly created file for size variations. When files size does not change for 'threshold' milliseconds calls callback.
+   * @param path being acted upon
+   * @param threshold Time in milliseconds a file size must be fixed before acknowledging write OP is finished
+   * @param event
+   * @param awfEmit Callback to be called when ready for event to be emitted.
+   */
+  _awaitWriteFinish(path9, threshold, event, awfEmit) {
+    const awf = this.options.awaitWriteFinish;
+    if (typeof awf !== "object")
+      return;
+    const pollInterval = awf.pollInterval;
+    let timeoutHandler;
+    let fullPath = path9;
+    if (this.options.cwd && !sp2.isAbsolute(path9)) {
+      fullPath = sp2.join(this.options.cwd, path9);
+    }
+    const now = /* @__PURE__ */ new Date();
+    const writes = this._pendingWrites;
+    function awaitWriteFinishFn(prevStat) {
+      statcb(fullPath, (err, curStat) => {
+        if (err || !writes.has(path9)) {
+          if (err && err.code !== "ENOENT")
+            awfEmit(err);
+          return;
+        }
+        const now2 = Number(/* @__PURE__ */ new Date());
+        if (prevStat && curStat.size !== prevStat.size) {
+          writes.get(path9).lastChange = now2;
+        }
+        const pw = writes.get(path9);
+        const df = now2 - pw.lastChange;
+        if (df >= threshold) {
+          writes.delete(path9);
+          awfEmit(void 0, curStat);
+        } else {
+          timeoutHandler = setTimeout(awaitWriteFinishFn, pollInterval, curStat);
+        }
+      });
+    }
+    if (!writes.has(path9)) {
+      writes.set(path9, {
+        lastChange: now,
+        cancelWait: () => {
+          writes.delete(path9);
+          clearTimeout(timeoutHandler);
+          return event;
+        }
+      });
+      timeoutHandler = setTimeout(awaitWriteFinishFn, pollInterval);
+    }
+  }
+  /**
+   * Determines whether user has asked to ignore this path.
+   */
+  _isIgnored(path9, stats) {
+    if (this.options.atomic && DOT_RE.test(path9))
+      return true;
+    if (!this._userIgnored) {
+      const { cwd } = this.options;
+      const ign = this.options.ignored;
+      const ignored = (ign || []).map(normalizeIgnored(cwd));
+      const ignoredPaths = [...this._ignoredPaths];
+      const list = [...ignoredPaths.map(normalizeIgnored(cwd)), ...ignored];
+      this._userIgnored = anymatch(list, void 0);
+    }
+    return this._userIgnored(path9, stats);
+  }
+  _isntIgnored(path9, stat8) {
+    return !this._isIgnored(path9, stat8);
+  }
+  /**
+   * Provides a set of common helpers and properties relating to symlink handling.
+   * @param path file or directory pattern being watched
+   */
+  _getWatchHelpers(path9) {
+    return new WatchHelper(path9, this.options.followSymlinks, this);
+  }
+  // Directory helpers
+  // -----------------
+  /**
+   * Provides directory tracking objects
+   * @param directory path of the directory
+   */
+  _getWatchedDir(directory) {
+    const dir = sp2.resolve(directory);
+    if (!this._watched.has(dir))
+      this._watched.set(dir, new DirEntry(dir, this._boundRemove));
+    return this._watched.get(dir);
+  }
+  // File helpers
+  // ------------
+  /**
+   * Check for read permissions: https://stackoverflow.com/a/11781404/1358405
+   */
+  _hasReadPermissions(stats) {
+    if (this.options.ignorePermissionErrors)
+      return true;
+    return Boolean(Number(stats.mode) & 256);
+  }
+  /**
+   * Handles emitting unlink events for
+   * files and directories, and via recursion, for
+   * files and directories within directories that are unlinked
+   * @param directory within which the following item is located
+   * @param item      base path of item/directory
+   */
+  _remove(directory, item, isDirectory) {
+    const path9 = sp2.join(directory, item);
+    const fullPath = sp2.resolve(path9);
+    isDirectory = isDirectory != null ? isDirectory : this._watched.has(path9) || this._watched.has(fullPath);
+    if (!this._throttle("remove", path9, 100))
+      return;
+    if (!isDirectory && this._watched.size === 1) {
+      this.add(directory, item, true);
+    }
+    const wp = this._getWatchedDir(path9);
+    const nestedDirectoryChildren = wp.getChildren();
+    nestedDirectoryChildren.forEach((nested) => this._remove(path9, nested));
+    const parent = this._getWatchedDir(directory);
+    const wasTracked = parent.has(item);
+    parent.remove(item);
+    if (this._symlinkPaths.has(fullPath)) {
+      this._symlinkPaths.delete(fullPath);
+    }
+    let relPath = path9;
+    if (this.options.cwd)
+      relPath = sp2.relative(this.options.cwd, path9);
+    if (this.options.awaitWriteFinish && this._pendingWrites.has(relPath)) {
+      const event = this._pendingWrites.get(relPath).cancelWait();
+      if (event === EVENTS.ADD)
+        return;
+    }
+    this._watched.delete(path9);
+    this._watched.delete(fullPath);
+    const eventName = isDirectory ? EVENTS.UNLINK_DIR : EVENTS.UNLINK;
+    if (wasTracked && !this._isIgnored(path9))
+      this._emit(eventName, path9);
+    this._closePath(path9);
+  }
+  /**
+   * Closes all watchers for a path
+   */
+  _closePath(path9) {
+    this._closeFile(path9);
+    const dir = sp2.dirname(path9);
+    this._getWatchedDir(dir).remove(sp2.basename(path9));
+  }
+  /**
+   * Closes only file-specific watchers
+   */
+  _closeFile(path9) {
+    const closers = this._closers.get(path9);
+    if (!closers)
+      return;
+    closers.forEach((closer) => closer());
+    this._closers.delete(path9);
+  }
+  _addPathCloser(path9, closer) {
+    if (!closer)
+      return;
+    let list = this._closers.get(path9);
+    if (!list) {
+      list = [];
+      this._closers.set(path9, list);
+    }
+    list.push(closer);
+  }
+  _readdirp(root, opts) {
+    if (this.closed)
+      return;
+    const options = { type: EVENTS.ALL, alwaysStat: true, lstat: true, ...opts, depth: 0 };
+    let stream = readdirp(root, options);
+    this._streams.add(stream);
+    stream.once(STR_CLOSE, () => {
+      stream = void 0;
+    });
+    stream.once(STR_END, () => {
+      if (stream) {
+        this._streams.delete(stream);
+        stream = void 0;
+      }
+    });
+    return stream;
+  }
+};
+function watch(paths, options = {}) {
+  const watcher = new FSWatcher(options);
+  watcher.add(paths);
+  return watcher;
+}
+var chokidar_default = { watch, FSWatcher };
+
+// src/core/watch.ts
+import { $ as $7 } from "execa";
+var watchCommand = new Command10("watch").description(
+  "Watches the src directory and rebuilds automatically on changes"
+).action(() => {
+  const cwd = process.cwd();
+  const srcDir = path8.join(cwd, "src");
+  console.log(`\u{1F440} Watching for changes in ./src...`);
+  let isBuilding = false;
+  let buildQueued = false;
+  const runBuild = async () => {
+    if (isBuilding) {
+      buildQueued = true;
+      return;
+    }
+    isBuilding = true;
+    console.log(`
+\u23F3 Detected changes. Rebuilding...`);
+    try {
+      await $7({ stdio: "inherit" })`npx sse-tools build`;
+      console.log(`\u2705 Build updated successfully! Waiting for changes...`);
+    } catch (err) {
+      console.error(`\u274C Build failed during watch.`);
+    } finally {
+      isBuilding = false;
+      if (buildQueued) {
+        buildQueued = false;
+        runBuild();
+      }
+    }
+  };
+  const watcher = chokidar_default.watch(srcDir, {
+    ignored: /(^|[\/\\])\../,
+    // ignore dotfiles
+    persistent: true,
+    ignoreInitial: true
+    // Don't trigger on startup
+  });
+  watcher.on("add", runBuild).on("change", runBuild).on("unlink", runBuild);
+});
+
+// src/cli.ts
+async function main() {
+  const program = new Command11();
+  program.name("sse-tools").description("CLI utilities for managing and building MUI packages").version("1.0.0");
+  program.addCommand(buildCommand);
+  program.addCommand(publishCommand);
+  program.addCommand(cleanCommand);
+  program.addCommand(typecheckCommand);
+  program.addCommand(packCommand);
+  program.addCommand(versionCommand);
+  program.addCommand(infoCommand);
+  program.addCommand(linkCommand);
+  program.addCommand(checkExportsCommand);
+  program.addCommand(watchCommand);
+  try {
+    await program.parseAsync(process.argv);
+  } catch (error) {
+    console.error("Error executing command:");
+    if (error instanceof Error) {
+      console.error(error.message);
+    }
+    process.exit(1);
+  }
+}
+main();
+/*! Bundled license information:
+
+chokidar/index.js:
+  (*! chokidar - MIT License (c) 2012 Paul Miller (paulmillr.com) *)
+*/