smartbundle 0.7.3 → 0.8.0-alpha.0

package/__do_not_import_directly__/packageJson.mjs

@@ -0,0 +1,129 @@
+import * as fs from "node:fs/promises";
+import z from "zod";
+import { errors } from "./errors.mjs";
+import { join } from "node:path";
+async function fileExists(filePath) {
+  try {
+    const stats = await fs.stat(filePath);
+    return stats.isFile();
+  } catch (error) {
+    return false;
+  }
+}
+function dependencies(errorText) {
+  return z.record(z.string({ message: errorText }), { message: errorText }).optional();
+}
+function createPathValidator(sourceDir) {
+  return (path) => {
+    const finalPath = join(sourceDir, path);
+    return fileExists(finalPath);
+  };
+}
+const PackageJsonNameField = "___NAME___";
+function fillPackageJson(packageJson) {
+  if (packageJson.bin) {
+    const binName = packageJson.bin.get(PackageJsonNameField);
+    if (binName) {
+      packageJson.bin.set(packageJson.name, binName);
+      packageJson.bin.delete(PackageJsonNameField);
+    }
+  }
+}
+function createPackageJsonSchema(sourceDir) {
+  const pathValidator = createPathValidator(sourceDir);
+  return z.object({
+    exports: z.union(
+      [
+        z.string().transform((path) => /* @__PURE__ */ new Map([[".", path]])),
+        z.record(z.string()).transform((obj) => new Map(Object.entries(obj)))
+      ],
+      {
+        errorMap() {
+          return { message: errors.exportsRequired };
+        }
+      }
+    ).refine(async (obj) => {
+      for (const [key, value] of obj.entries()) {
+        if (!await pathValidator(value)) {
+          return false;
+        }
+      }
+      return true;
+    }, errors.exportsInvalid).optional(),
+    name: z.string({ message: errors.nameRequired }).min(1, errors.nameMinLength).max(214, errors.nameMaxLength).refine(
+      (name) => ["_", "."].every((start) => !name.startsWith(start)),
+      errors.nameStartsIllegalChars
+    ),
+    version: z.string({ message: errors.versionRequired }),
+    private: z.boolean({ message: errors.privateIsTrue }).refine((value) => value, errors.privateIsTrue),
+    description: z.string({ message: errors.descriptionString }).optional(),
+    dependencies: dependencies(errors.dependenciesInvalid),
+    optionalDependencies: dependencies(errors.optionalDependenciesInvalid),
+    bin: z.union(
+      [
+        z.string().transform((value) => /* @__PURE__ */ new Map([[PackageJsonNameField, value]])),
+        z.record(z.string()).transform((record) => new Map(Object.entries(record)))
+      ],
+      {
+        errorMap() {
+          return { message: errors.binFiled };
+        }
+      }
+    ).refine(
+      async (map) => {
+        for (const [key, value] of map.entries()) {
+          if (!await pathValidator(value)) {
+            return false;
+          }
+        }
+        return true;
+      },
+      { message: errors.binFiled }
+    ).optional(),
+    repository: z.any().optional(),
+    keywords: z.array(z.string(), { message: errors.keywordsInvalid }).optional(),
+    author: z.any().optional(),
+    maintainers: z.any().optional(),
+    contributors: z.array(
+      z.union([
+        z.string({ message: errors.contributorsInvalid }),
+        z.object({}, { message: errors.contributorsInvalid })
+      ])
+    ).optional(),
+    license: z.any().optional(),
+    devDependencies: dependencies(errors.devDependenciesInvalid),
+    peerDependencies: dependencies(errors.peerDependenciesInvalid),
+    engines: z.record(z.string(), { message: errors.enginesInvalid }).optional(),
+    browser: z.union([
+      z.string({ message: errors.browserInvalid }),
+      z.record(z.string(), { message: errors.browserInvalid })
+    ]).optional(),
+    bugs: z.any().optional(),
+    funding: z.union([
+      z.string({ message: errors.fundingInvalid }),
+      z.object({}, { message: errors.fundingInvalid })
+    ]).optional(),
+    os: z.array(z.string(), { message: errors.osInvalid }).optional(),
+    cpu: z.array(z.string(), { message: errors.cpuInvalid }).optional(),
+    sideEffects: z.any().optional(),
+    unpkg: z.any().optional(),
+    homepage: z.any().optional()
+  });
+}
+async function parsePackageJson({
+  sourceDir,
+  packagePath
+}) {
+  const packageString = await fs.readFile(packagePath, "utf-8");
+  const rawJson = JSON.parse(packageString);
+  const packageJsonSchema = createPackageJsonSchema(sourceDir);
+  const packageJson = await packageJsonSchema.safeParseAsync(rawJson);
+  if (!packageJson.success) {
+    return packageJson.error.errors.map((error) => error.message);
+  }
+  fillPackageJson(packageJson.data);
+  return packageJson.data;
+}
+export {
+  parsePackageJson
+};

package/__do_not_import_directly__/resolveDirs.js

@@ -1,9 +1,11 @@
-import { isAbsolute, join } from "node:path";
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const path = require("node:path");
 function myResolve(path1, path2) {
-  if (isAbsolute(path2)) {
+  if (path.isAbsolute(path2)) {
     return path2;
   }
-  return join(path1, path2);
+  return path.join(path1, path2);
 }
 function resolveDirs(args) {
   const sourceDir = myResolve(process.cwd(), args.sourceDir ?? ".");
@@ -15,6 +17,4 @@ function resolveDirs(args) {
   const outBinsDir = myResolve(outDir, "__bin__");
   return { sourceDir, packagePath, outDir, outBinsDir };
 }
-export {
-  resolveDirs
-};
+exports.resolveDirs = resolveDirs;

package/__do_not_import_directly__/{resolveDirs.cjs → resolveDirs.mjs}

@@ -1,11 +1,9 @@
-"use strict";
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const path = require("node:path");
+import { isAbsolute, join } from "node:path";
 function myResolve(path1, path2) {
-  if (path.isAbsolute(path2)) {
+  if (isAbsolute(path2)) {
     return path2;
   }
-  return path.join(path1, path2);
+  return join(path1, path2);
 }
 function resolveDirs(args) {
   const sourceDir = myResolve(process.cwd(), args.sourceDir ?? ".");
@@ -17,4 +15,6 @@ function resolveDirs(args) {
   const outBinsDir = myResolve(outDir, "__bin__");
   return { sourceDir, packagePath, outDir, outBinsDir };
 }
-exports.resolveDirs = resolveDirs;
+export {
+  resolveDirs
+};

package/__do_not_import_directly__/smartbundle.js

@@ -1,3 +1,4 @@
-import { args } from "./args.js";
-import { run } from "../src/index.js";
-run(args);
+"use strict";
+const args = require("./args.js");
+const _ = require("../src/index.js");
+_.run(args.args);

package/__do_not_import_directly__/smartbundle.mjs

@@ -0,0 +1,3 @@
+import { args } from "./args.mjs";
+import { run } from "../src/index.mjs";
+run(args);

package/__do_not_import_directly__/tasks/binsTask.js

@@ -1,7 +1,9 @@
-import { mkdir, writeFile } from "node:fs/promises";
-import { relative, join } from "node:path";
-import "vite";
-import { reverseMap } from "./utils.js";
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const fs = require("node:fs/promises");
+const path = require("node:path");
+require("vite");
+const utils = require("./utils.js");
 async function binsTask({
   buildOutput,
   bins,
@@ -11,8 +13,8 @@ async function binsTask({
   if (bins.size === 0) {
     return /* @__PURE__ */ new Map();
   }
-  await mkdir(outBinsDir, { recursive: true });
-  const reversedEntrypoints = reverseMap(bins);
+  await fs.mkdir(outBinsDir, { recursive: true });
+  const reversedEntrypoints = utils.reverseMap(bins);
   const res = /* @__PURE__ */ new Map();
   for (const el of buildOutput) {
     if (el.facadeModuleId == null) {
@@ -26,19 +28,20 @@ async function binsTask({
       continue;
     }
     for (const binName of binsNames) {
-      const totalPath = relative(outBinsDir, join(outDir, el.fileName));
-      const execPath = join(outBinsDir, `${binName}.js`);
-      await writeFile(
+      const totalPath = path.relative(
+        outBinsDir,
+        path.join(outDir, el.fileName.replace(/js$/, "mjs"))
+      );
+      const execPath = path.join(outBinsDir, `${binName}.js`);
+      await fs.writeFile(
         execPath,
         `#!/usr/bin/env node
 import("${totalPath}");
 `
       );
-      res.set(relative(outDir, execPath), binName);
+      res.set(path.relative(outDir, execPath), binName);
     }
   }
   return res;
 }
-export {
-  binsTask
-};
+exports.binsTask = binsTask;

package/__do_not_import_directly__/tasks/{binsTask.cjs → binsTask.mjs}

@@ -1,9 +1,7 @@
-"use strict";
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const fs = require("node:fs/promises");
-const path = require("node:path");
-require("vite");
-const utils = require("./utils.cjs");
+import { mkdir, writeFile } from "node:fs/promises";
+import { relative, join } from "node:path";
+import "vite";
+import { reverseMap } from "./utils.mjs";
 async function binsTask({
   buildOutput,
   bins,
@@ -13,8 +11,8 @@ async function binsTask({
   if (bins.size === 0) {
     return /* @__PURE__ */ new Map();
   }
-  await fs.mkdir(outBinsDir, { recursive: true });
-  const reversedEntrypoints = utils.reverseMap(bins);
+  await mkdir(outBinsDir, { recursive: true });
+  const reversedEntrypoints = reverseMap(bins);
   const res = /* @__PURE__ */ new Map();
   for (const el of buildOutput) {
     if (el.facadeModuleId == null) {
@@ -28,17 +26,22 @@ async function binsTask({
       continue;
     }
     for (const binName of binsNames) {
-      const totalPath = path.relative(outBinsDir, path.join(outDir, el.fileName));
-      const execPath = path.join(outBinsDir, `${binName}.js`);
-      await fs.writeFile(
+      const totalPath = relative(
+        outBinsDir,
+        join(outDir, el.fileName.replace(/js$/, "mjs"))
+      );
+      const execPath = join(outBinsDir, `${binName}.js`);
+      await writeFile(
         execPath,
         `#!/usr/bin/env node
 import("${totalPath}");
 `
       );
-      res.set(path.relative(outDir, execPath), binName);
+      res.set(relative(outDir, execPath), binName);
     }
   }
   return res;
 }
-exports.binsTask = binsTask;
+export {
+  binsTask
+};

package/__do_not_import_directly__/tasks/buildTypesTask/buildTypesTask.js

@@ -1,14 +1,38 @@
-import "vite";
-import { errors } from "../../errors.js";
-import { callTypescript } from "./callTypescript.js";
-import { reverseMap } from "../utils.js";
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+require("vite");
+const errors = require("../../errors.js");
+const callTypescript = require("./callTypescript.js");
+const utils = require("../utils.js");
 async function buildTypesTask({
   buildOutput,
   entrypoints,
   sourceDir,
   outDir
 }) {
-  const reversedEntrypoints = reverseMap(entrypoints);
+  const reversedEntrypoints = utils.reverseMap(entrypoints);
   const tsEntrypoints = [...entrypoints.values()].filter(
     (entry) => entry.endsWith(".ts")
   );
@@ -19,22 +43,20 @@ async function buildTypesTask({
   try {
     ts = await import("typescript");
   } catch {
-    throw errors.typescriptNotFound;
+    throw errors.errors.typescriptNotFound;
   }
   const files = buildOutput.map((el) => el.facadeModuleId ?? "");
-  const dtsMap = await callTypescript({ ts, sourceDir, files, outDir });
+  const dtsMap = await callTypescript.callTypescript({ ts, sourceDir, files, outDir });
   const result = /* @__PURE__ */ new Map();
-  for (const [source, dts] of dtsMap) {
+  for (const [types, source] of dtsMap) {
     const exportPath = reversedEntrypoints.get(source);
     if (!exportPath) {
       continue;
     }
     for (const path of exportPath) {
-      result.set(dts, path);
+      result.set(types, path);
     }
   }
   return result;
 }
-export {
-  buildTypesTask
-};
+exports.buildTypesTask = buildTypesTask;

package/__do_not_import_directly__/tasks/buildTypesTask/buildTypesTask.mjs

@@ -0,0 +1,40 @@
+import "vite";
+import { errors } from "../../errors.mjs";
+import { callTypescript } from "./callTypescript.mjs";
+import { reverseMap } from "../utils.mjs";
+async function buildTypesTask({
+  buildOutput,
+  entrypoints,
+  sourceDir,
+  outDir
+}) {
+  const reversedEntrypoints = reverseMap(entrypoints);
+  const tsEntrypoints = [...entrypoints.values()].filter(
+    (entry) => entry.endsWith(".ts")
+  );
+  if (tsEntrypoints.length === 0) {
+    return /* @__PURE__ */ new Map();
+  }
+  let ts;
+  try {
+    ts = await import("typescript");
+  } catch {
+    throw errors.typescriptNotFound;
+  }
+  const files = buildOutput.map((el) => el.facadeModuleId ?? "");
+  const dtsMap = await callTypescript({ ts, sourceDir, files, outDir });
+  const result = /* @__PURE__ */ new Map();
+  for (const [types, source] of dtsMap) {
+    const exportPath = reversedEntrypoints.get(source);
+    if (!exportPath) {
+      continue;
+    }
+    for (const path of exportPath) {
+      result.set(types, path);
+    }
+  }
+  return result;
+}
+export {
+  buildTypesTask
+};

package/__do_not_import_directly__/tasks/buildTypesTask/callTypescript.js

@@ -1,17 +1,37 @@
-import * as path from "node:path";
-import * as fs from "node:fs";
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const path = require("node:path");
+const fs = require("node:fs");
+function _interopNamespaceDefault(e) {
+  const n = Object.create(null, { [Symbol.toStringTag]: { value: "Module" } });
+  if (e) {
+    for (const k in e) {
+      if (k !== "default") {
+        const d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: () => e[k]
+        });
+      }
+    }
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+const path__namespace = /* @__PURE__ */ _interopNamespaceDefault(path);
+const fs__namespace = /* @__PURE__ */ _interopNamespaceDefault(fs);
 async function callTypescript({
   ts,
   sourceDir,
   files,
   outDir
 }) {
-  const configPath = path.join(sourceDir, "tsconfig.json");
+  const configPath = path__namespace.join(sourceDir, "tsconfig.json");
   const configFile = ts.readConfigFile(
     configPath,
     (path2) => (
       // https://github.com/XaveScor/bobrik/issues/22
-      fs.readFileSync(path2, "utf-8")
+      fs__namespace.readFileSync(path2, "utf-8")
     )
   );
   const parsedCommandLine = ts.parseJsonConfigFileContent(
@@ -36,15 +56,16 @@ async function callTypescript({
   const sourceToDtsMap = /* @__PURE__ */ new Map();
   const program = ts.createProgram(files, parsedCommandLine.options, host);
   program.emit(void 0, (fileName, data) => {
-    const relativePath = path.relative(sourceDir, fileName);
-    const finalPath = path.join(outDir, relativePath);
+    const relativePath = path__namespace.relative(sourceDir, fileName);
+    const esmFinalPath = path__namespace.join(outDir, relativePath);
     const sourceFileName = fileName.replace(/\.d\.ts$/, ".ts");
-    sourceToDtsMap.set(sourceFileName, finalPath);
-    fs.mkdirSync(path.dirname(finalPath), { recursive: true });
-    fs.writeFileSync(finalPath, data);
+    sourceToDtsMap.set(esmFinalPath, sourceFileName);
+    fs__namespace.mkdirSync(path__namespace.dirname(esmFinalPath), { recursive: true });
+    fs__namespace.writeFileSync(esmFinalPath, data);
+    const cjsFinalPath = esmFinalPath.replace(/\.d\.ts$/, ".d.cts");
+    fs__namespace.writeFileSync(cjsFinalPath, data);
+    sourceToDtsMap.set(cjsFinalPath, sourceFileName);
   });
   return sourceToDtsMap;
 }
-export {
-  callTypescript
-};
+exports.callTypescript = callTypescript;

package/__do_not_import_directly__/tasks/buildTypesTask/callTypescript.mjs

@@ -0,0 +1,53 @@
+import * as path from "node:path";
+import * as fs from "node:fs";
+async function callTypescript({
+  ts,
+  sourceDir,
+  files,
+  outDir
+}) {
+  const configPath = path.join(sourceDir, "tsconfig.json");
+  const configFile = ts.readConfigFile(
+    configPath,
+    (path2) => (
+      // https://github.com/XaveScor/bobrik/issues/22
+      fs.readFileSync(path2, "utf-8")
+    )
+  );
+  const parsedCommandLine = ts.parseJsonConfigFileContent(
+    configFile.config,
+    ts.sys,
+    sourceDir,
+    {
+      declaration: true,
+      emitDeclarationOnly: true,
+      strict: false,
+      strictNullChecks: false,
+      strictFunctionTypes: false,
+      strictPropertyInitialization: false,
+      skipLibCheck: true,
+      skipDefaultLibCheck: true,
+      // https://github.com/XaveScor/bobrik/issues/22#issuecomment-2308552352
+      noEmit: false
+    },
+    configPath
+  );
+  const host = ts.createCompilerHost(parsedCommandLine.options);
+  const sourceToDtsMap = /* @__PURE__ */ new Map();
+  const program = ts.createProgram(files, parsedCommandLine.options, host);
+  program.emit(void 0, (fileName, data) => {
+    const relativePath = path.relative(sourceDir, fileName);
+    const esmFinalPath = path.join(outDir, relativePath);
+    const sourceFileName = fileName.replace(/\.d\.ts$/, ".ts");
+    sourceToDtsMap.set(esmFinalPath, sourceFileName);
+    fs.mkdirSync(path.dirname(esmFinalPath), { recursive: true });
+    fs.writeFileSync(esmFinalPath, data);
+    const cjsFinalPath = esmFinalPath.replace(/\.d\.ts$/, ".d.cts");
+    fs.writeFileSync(cjsFinalPath, data);
+    sourceToDtsMap.set(cjsFinalPath, sourceFileName);
+  });
+  return sourceToDtsMap;
+}
+export {
+  callTypescript
+};

package/__do_not_import_directly__/tasks/copyStaticFilesTask.js

@@ -1,5 +1,7 @@
-import { join } from "node:path";
-import { readdir, copyFile } from "node:fs/promises";
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const path = require("node:path");
+const fs = require("node:fs/promises");
 async function copyStaticFilesTask(sourceDir, outDir) {
   return copyStaticFiles({
     relativeFiles: /* @__PURE__ */ new Set(["readme.md"]),
@@ -13,7 +15,7 @@ async function copyStaticFiles({
   relativeFiles
 }) {
   const dirFiles = new Map(
-    (await readdir(sourceDir, { recursive: true })).map(
+    (await fs.readdir(sourceDir, { recursive: true })).map(
       (f) => [f.toLowerCase(), f]
     )
   );
@@ -21,14 +23,12 @@ async function copyStaticFiles({
     try {
       const matchingFile = dirFiles.get(file.toLowerCase());
       if (matchingFile) {
-        const outFilePath = join(outDir, matchingFile);
-        const filePath = join(sourceDir, matchingFile);
-        await copyFile(filePath, outFilePath);
+        const outFilePath = path.join(outDir, matchingFile);
+        const filePath = path.join(sourceDir, matchingFile);
+        await fs.copyFile(filePath, outFilePath);
       }
     } catch {
     }
   }
 }
-export {
-  copyStaticFilesTask
-};
+exports.copyStaticFilesTask = copyStaticFilesTask;

package/__do_not_import_directly__/tasks/{copyStaticFilesTask.cjs → copyStaticFilesTask.mjs}

@@ -1,7 +1,5 @@
-"use strict";
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const path = require("node:path");
-const fs = require("node:fs/promises");
+import { join } from "node:path";
+import { readdir, copyFile } from "node:fs/promises";
 async function copyStaticFilesTask(sourceDir, outDir) {
   return copyStaticFiles({
     relativeFiles: /* @__PURE__ */ new Set(["readme.md"]),
@@ -15,7 +13,7 @@ async function copyStaticFiles({
   relativeFiles
 }) {
   const dirFiles = new Map(
-    (await fs.readdir(sourceDir, { recursive: true })).map(
+    (await readdir(sourceDir, { recursive: true })).map(
       (f) => [f.toLowerCase(), f]
     )
   );
@@ -23,12 +21,14 @@ async function copyStaticFiles({
     try {
       const matchingFile = dirFiles.get(file.toLowerCase());
       if (matchingFile) {
-        const outFilePath = path.join(outDir, matchingFile);
-        const filePath = path.join(sourceDir, matchingFile);
-        await fs.copyFile(filePath, outFilePath);
+        const outFilePath = join(outDir, matchingFile);
+        const filePath = join(sourceDir, matchingFile);
+        await copyFile(filePath, outFilePath);
       }
     } catch {
     }
   }
 }
-exports.copyStaticFilesTask = copyStaticFilesTask;
+export {
+  copyStaticFilesTask
+};

package/__do_not_import_directly__/tasks/jsFilesTask.js

@@ -1,10 +1,12 @@
-import "vite";
-import { reverseMap } from "./utils.js";
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+require("vite");
+const utils = require("./utils.js");
 async function jsFilesTask({
   buildOutput,
   entrypoints
 }) {
-  const reversedEntrypoints = reverseMap(entrypoints);
+  const reversedEntrypoints = utils.reverseMap(entrypoints);
   const res = /* @__PURE__ */ new Map();
   for (const el of buildOutput) {
     if (el.facadeModuleId == null) {
@@ -20,6 +22,4 @@ async function jsFilesTask({
   }
   return res;
 }
-export {
-  jsFilesTask
-};
+exports.jsFilesTask = jsFilesTask;

package/__do_not_import_directly__/tasks/{jsFilesTask.cjs → jsFilesTask.mjs}

@@ -1,12 +1,10 @@
-"use strict";
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-require("vite");
-const utils = require("./utils.cjs");
+import "vite";
+import { reverseMap } from "./utils.mjs";
 async function jsFilesTask({
   buildOutput,
   entrypoints
 }) {
-  const reversedEntrypoints = utils.reverseMap(entrypoints);
+  const reversedEntrypoints = reverseMap(entrypoints);
   const res = /* @__PURE__ */ new Map();
   for (const el of buildOutput) {
     if (el.facadeModuleId == null) {
@@ -22,4 +20,6 @@ async function jsFilesTask({
   }
   return res;
 }
-exports.jsFilesTask = jsFilesTask;
+export {
+  jsFilesTask
+};

package/__do_not_import_directly__/tasks/utils.js

@@ -1,3 +1,5 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 function reverseMap(map) {
   const reversed = /* @__PURE__ */ new Map();
   for (const [key, value] of map) {
@@ -7,6 +9,4 @@ function reverseMap(map) {
   }
   return reversed;
 }
-export {
-  reverseMap
-};
+exports.reverseMap = reverseMap;