@cyberskill/shared 1.209.0 → 1.210.0

package/dist/config/config.type.js

@@ -0,0 +1,4 @@
+var T = /* @__PURE__ */ ((t) => (t.ESLINT = "eslint", t.COMMITLINT = "commitlint", t.LINT_STAGED = "lint-staged", t.VITEST_REACT_E2E = "vitest-react-e2e", t.VITEST_REACT_UNIT = "vitest-react-unit", t))(T || {});
+export {
+  T as E_ConfigType
+};

package/dist/config/config.util.js

@@ -0,0 +1,49 @@
+import a from "@antfu/eslint-config";
+import { E_ConfigType as n } from "./config.type.js";
+import g from "./eslint/index.js";
+import { vitestE2E as E } from "./vitest/vitest.e2e.js";
+import { vitestUnit as T } from "./vitest/vitest.unit.js";
+import { deepMerge as i } from "../util/object/object.util.js";
+const c = (...r) => {
+  const e = i(
+    g,
+    ...r.map((o) => o)
+  ), { ignores: t, ...m } = e, s = Array.isArray(t) && t.every((o) => typeof o == "string") ? { ignores: t } : void 0, f = [
+    m,
+    ...s ? [s] : []
+  ];
+  return a(
+    {
+      stylistic: {
+        semi: !0,
+        indent: 4,
+        quotes: "single"
+      },
+      formatters: {
+        css: !0,
+        html: !0,
+        markdown: "prettier"
+      },
+      yaml: !1,
+      react: !0
+    },
+    ...f
+  );
+}, p = {
+  [n.ESLINT]: (r) => c(r),
+  [n.COMMITLINT]: (r) => i(r),
+  [n.LINT_STAGED]: (r) => i(r),
+  [n.VITEST_REACT_UNIT]: (r) => T(r),
+  [n.VITEST_REACT_E2E]: (r) => E(r)
+};
+function A(r, ...e) {
+  const t = p[r];
+  if (!e || e.length === 0)
+    return t({});
+  if (!t)
+    throw new Error(`Unknown config type: ${r}`);
+  return t(...e);
+}
+export {
+  A as mergeConfigs
+};

package/dist/config/env/env.util.js

@@ -0,0 +1,29 @@
+import n from "@dotenvx/dotenvx";
+import { cleanEnv as E, str as r, makeValidator as f } from "envalid";
+import i from "node:os";
+import a from "node:path";
+import o from "node:process";
+import { CYBERSKILL_STORAGE_DIRECTORY as m } from "./env.constant.js";
+import { E_Environment as R } from "../../typescript/common.type.js";
+let t = !1;
+const l = f((e) => typeof e == "boolean" ? e : typeof e == "string");
+function d() {
+  o.env.NODE_ENV !== R.PRODUCTION && !t && (n.config(), t = !0);
+}
+function p() {
+  d();
+  const e = E(o.env, {
+    CWD: r({ default: o.cwd() }),
+    DEBUG: l({ default: !1 }),
+    CYBERSKILL_STORAGE_DIRECTORY: r({ default: a.join(i.homedir(), m) })
+  });
+  return {
+    CWD: e.CWD,
+    DEBUG: e.DEBUG,
+    CYBERSKILL_STORAGE_DIRECTORY: e.CYBERSKILL_STORAGE_DIRECTORY
+  };
+}
+export {
+  p as getEnv,
+  d as loadEnvFile
+};

package/dist/config/index.js

@@ -0,0 +1,6 @@
+import { E_ConfigType as r } from "./config.type.js";
+import { mergeConfigs as g } from "./config.util.js";
+export {
+  r as E_ConfigType,
+  g as mergeConfigs
+};

package/dist/{src/config → config}/vitest/vitest.e2e.js

@@ -1,5 +1,5 @@
 import r from "@vitejs/plugin-react-swc";
-import { d as t } from "../../../config-CwzVfkkX.js";
+import { defineConfig as t } from "../../node_modules/.pnpm/vitest@3.2.4_@types_debug@4.1.12_@types_node@24.0.13_@vitest_browser@3.2.4_jiti@2.4.2_j_cac3da623d5688a51c0b1a2270e144db/node_modules/vitest/dist/config.js";
 function s(e) {
   return t({
     plugins: [r()],

package/dist/config/vitest/vitest.unit.js

@@ -0,0 +1,19 @@
+import e from "@vitejs/plugin-react-swc";
+import { defineConfig as o } from "../../node_modules/.pnpm/vitest@3.2.4_@types_debug@4.1.12_@types_node@24.0.13_@vitest_browser@3.2.4_jiti@2.4.2_j_cac3da623d5688a51c0b1a2270e144db/node_modules/vitest/dist/config.js";
+import { PATH as i } from "../../node/path/path.constant.js";
+function s(t) {
+  return o({
+    plugins: [e()],
+    test: {
+      globals: !0,
+      environment: "jsdom",
+      pool: "vmThreads",
+      include: ["**/*.test.unit.?(c|m)[jt]s?(x)"],
+      setupFiles: [i.VITEST_UNIT_SETUP_CONFIG]
+    },
+    ...t
+  });
+}
+export {
+  s as vitestUnit
+};

package/dist/{src/node → node}/apollo-server/apollo-server.util.js

@@ -1,19 +1,18 @@
 import { ApolloServer as e } from "@apollo/server";
-import { expressMiddleware as d } from "@apollo/server/express4";
 import { ApolloServerPluginDrainHttpServer as l } from "@apollo/server/plugin/drainHttpServer";
-import { ApolloServerPluginLandingPageLocalDefault as o, ApolloServerPluginLandingPageProductionDefault as a } from "@apollo/server/plugin/landingPage/default";
-import { log as n } from "../log/log.util.js";
+import { ApolloServerPluginLandingPageLocalDefault as o, ApolloServerPluginLandingPageProductionDefault as n } from "@apollo/server/plugin/landingPage/default";
+import { log as a } from "../log/log.util.js";
 function c(r) {
   return new e({
     schema: r.schema,
     plugins: [
-      r.isDev ? o() : a(),
+      r.isDev ? o() : n(),
       l({ httpServer: r.server }),
       ...r.drainServer ? [{
         async serverWillStart() {
           return {
             async drainServer() {
-              r.drainServer?.(), n.info("Apollo Server drainServer hook called");
+              r.drainServer?.(), a.info("Apollo Server drainServer hook called");
             }
           };
         }
@@ -26,6 +25,5 @@ function c(r) {
   });
 }
 export {
-  c as createApolloServer,
-  d as expressMiddleware
+  c as createApolloServer
 };

package/dist/{src/node → node}/cli/index.js

@@ -2,79 +2,81 @@
 import g from "node:process";
 import { hideBin as C } from "yargs/helpers";
 import L from "yargs/yargs";
-import { C as M, c as r, r as t, a as i, g as _, b as l, i as f, P as e, d as O, e as R, S as p, f as G } from "../../../index-BG1UznTl.js";
-import { removeSync as y, readFileSync as E, pathExistsSync as h, writeFileSync as u, appendFileSync as N } from "../fs/fs.util.js";
-import { resolve as P } from "../path/path.util.js";
-import { log as s, catchError as T } from "../log/log.util.js";
-import { E_IssueType as d } from "../log/index.js";
+import { clearAllErrorLists as s, runCommand as t, getStoredErrorLists as M, resolveCommands as _ } from "../command/command.util.js";
+import { getPackage as O, installDependencies as w } from "../package/package.util.js";
+import { removeSync as y, readFileSync as E, pathExistsSync as h, writeFileSync as l, appendFileSync as R } from "../fs/fs.util.js";
+import { resolve as G } from "../path/path.util.js";
+import { CYBERSKILL_CLI as N, command as i, CYBERSKILL_PACKAGE_NAME as p, PATH as e, SIMPLE_GIT_HOOK_JSON as u, createGitHooksConfig as T } from "../path/path.constant.js";
+import { log as r, catchError as P } from "../log/log.util.js";
+import { E_IssueType as d } from "../log/log.type.js";
 function D() {
   try {
     return JSON.parse(
-      E(P(__dirname, "../../../package.json"), "utf-8")
+      E(G(__dirname, "../../../package.json"), "utf-8")
     ).version;
   } catch {
     return "1.0.0";
   }
 }
 async function S() {
-  h(e.TS_CONFIG) ? await t("Performing TypeScript validation", await i.typescriptCheck()) : s.warn("No TypeScript configuration found. Skipping type check.");
+  h(e.TS_CONFIG) ? await t("Performing TypeScript validation", await i.typescriptCheck()) : r.warn("No TypeScript configuration found. Skipping type check.");
 }
 async function k(n = !1) {
   n ? await t("Running ESLint with auto-fix", await i.eslintFix()) : await t("Running ESLint check", await i.eslintCheck());
 }
-function w(n, a) {
+function f(n, a) {
   if (!a.length)
     return;
   const o = n === "Errors" ? "red" : "yellow";
-  s.printBoxedLog(n === "Errors" ? "✖ Errors" : "⚠ Warnings", a, o);
+  r.printBoxedLog(n === "Errors" ? "✖ Errors" : "⚠ Warnings", a, o);
 }
 async function c() {
   setTimeout(async () => {
-    const n = await O(), a = n.filter((m) => m.type === d.Error), o = n.filter((m) => m.type === d.Warning);
-    !a.length && !o.length ? s.printBoxedLog("✔ NO ISSUES FOUND", [], "green") : (w("Warnings", o), w("Errors", a), a.length > 0 && g.exit(1));
+    const n = await M(), a = n.filter((m) => m.type === d.Error), o = n.filter((m) => m.type === d.Warning);
+    !a.length && !o.length ? r.printBoxedLog("✔ NO ISSUES FOUND", [], "green") : (f("Warnings", o), f("Errors", a), a.length > 0 && g.exit(1));
   }, 0);
 }
 async function v() {
-  await r();
-  const n = await _({ name: l });
+  await s();
+  const n = await O({ name: p });
   if (!n.success) {
-    s.error("Failed to retrieve package information. Aborting lint-staged.");
+    r.error("Failed to retrieve package information. Aborting lint-staged.");
     return;
   }
-  n.result.isCurrentProject && await t(`Building package: ${l}`, await i.build()), await t("Executing lint-staged", await i.lintStaged()), c();
+  n.result.isCurrentProject && await t(`Building package: ${p}`, await i.build()), await t("Executing lint-staged", await i.lintStaged()), c();
 }
 async function B() {
   await t("Inspecting ESLint configuration", await i.eslintInspect());
 }
 async function x() {
-  await r(), await Promise.all([S(), k()]), c();
+  await s(), await Promise.all([S(), k()]), c();
 }
 async function A() {
-  await r(), await Promise.all([S(), k(!0)]), c();
+  await s(), await Promise.all([S(), k(!0)]), c();
 }
 async function F() {
-  await r(), await t("Validating commit message", await i.commitLint()), c();
+  await s(), await t("Validating commit message", await i.commitLint()), c();
 }
 async function I() {
   await t("Configuring Git hooks", await i.configureGitHook()), y(e.GIT_HOOK);
-  const n = await R(G);
-  u(e.SIMPLE_GIT_HOOKS_JSON, JSON.stringify(n, null, 4));
+  const n = await _(T);
+  l(e.SIMPLE_GIT_HOOKS_JSON, JSON.stringify(n, null, 4));
   const a = `
-${p}
+${u}
 `;
   h(e.GIT_IGNORE) ? E(e.GIT_IGNORE, "utf-8").split(`
-`).includes(p) || N(e.GIT_IGNORE, a) : u(e.GIT_IGNORE, a), await t("Setting up simple-git-hooks", await i.simpleGitHooks());
+`).includes(u) || R(e.GIT_IGNORE, a) : l(e.GIT_IGNORE, a), await t("Setting up simple-git-hooks", await i.simpleGitHooks());
 }
 async function H() {
-  await f(), await I();
+  await w(), await I();
 }
 async function U() {
-  y(e.NODE_MODULES, e.PNPM_LOCK_YAML), await t("Pruning pnpm store", await i.pnpmPruneStore()), await t("Clearing pnpm cache", await i.pnpmCleanCache()), await f(), await I();
+  y(e.NODE_MODULES, e.PNPM_LOCK_YAML), await t("Pruning pnpm store", await i.pnpmPruneStore()), await t("Clearing pnpm cache", await i.pnpmCleanCache()), await w(), await I();
 }
-async function b() {
+async function K() {
   await t("Inspecting project dependencies", await i.nodeModulesInspect());
 }
-async function K() {
+async function b() {
   await t("Running unit tests", await i.testUnit());
 }
 async function j() {
@@ -91,18 +93,18 @@ async function W() {
 }
 (async () => {
   try {
-    await L(C(g.argv)).scriptName(M).usage("$0 <command> [options]").command("lint", "Check code for linting issues", x).command("lint:fix", "Fix linting issues automatically", A).command("lint:inspect", "View active ESLint configuration", B).command("lint-staged", "Run lint checks on staged files", v).command("commitlint", "Validate commit message format", F).command("ready", "Initialize project and dependencies", H).command("reset", "Reset the project and reinstall dependencies", U).command("inspect", "Analyze installed project dependencies", b).command("test:unit", "Run unit test suite", K).command("test:e2e", "Run end-to-end test suite", j).command("mongo:migrate:create <name>", "Create a MongoDB migration", (n) => n.positional("name", {
+    await L(C(g.argv)).scriptName(N).usage("$0 <command> [options]").command("lint", "Check code for linting issues", x).command("lint:fix", "Fix linting issues automatically", A).command("lint:inspect", "View active ESLint configuration", B).command("lint-staged", "Run lint checks on staged files", v).command("commitlint", "Validate commit message format", F).command("ready", "Initialize project and dependencies", H).command("reset", "Reset the project and reinstall dependencies", U).command("inspect", "Analyze installed project dependencies", K).command("test:unit", "Run unit test suite", b).command("test:e2e", "Run end-to-end test suite", j).command("mongo:migrate:create <name>", "Create a MongoDB migration", (n) => n.positional("name", {
       describe: "Migration name",
       type: "string"
     }), async (n) => {
       if (!n.name) {
-        s.error("Migration name is required.");
+        r.error("Migration name is required.");
         return;
       }
       await J(n.name);
     }).command("mongo:migrate:up", "Apply all MongoDB migrations", V).command("mongo:migrate:down", "Rollback last MongoDB migration", W).demandCommand(1, "Please specify a valid command.").strict().help().alias("h", "help").alias("v", "version").version(D()).epilog(`💡 Tip: Use "--help" with any command to see options
 `).parse();
   } catch (n) {
-    T(n), g.exit(1);
+    P(n), g.exit(1);
   }
 })();

package/dist/node/command/command.type.js

@@ -0,0 +1,4 @@
+var N = /* @__PURE__ */ ((I) => (I.CLI = "CLI", I.STRING = "STRING", I.FUNCTION = "FUNCTION", I))(N || {});
+export {
+  N as E_CommandType
+};

package/dist/node/command/command.util.js

@@ -0,0 +1,144 @@
+import { exec as d } from "node:child_process";
+import E from "node:process";
+import * as P from "node:util";
+import { storage as l } from "../storage/storage.util.js";
+import { getPackage as C } from "../package/package.util.js";
+import { E_IssueType as a } from "../log/log.type.js";
+import { CYBERSKILL_PACKAGE_NAME as x, PNPM_EXEC_CLI as y, TSX_CLI as S, CYBERSKILL_CLI_PATH as I, CYBERSKILL_CLI as T } from "../path/path.constant.js";
+import { catchError as g, log as u } from "../log/log.util.js";
+import { getEnv as _ } from "../../config/env/env.util.js";
+const w = _(), k = P.promisify(d);
+async function h() {
+  const r = await C();
+  return r.success ? r.result.name : Date.now().toString();
+}
+async function L(r) {
+  if (r.length === 0)
+    return;
+  const t = await h();
+  try {
+    await l.set(t, r), setTimeout(async () => {
+      const e = await l.getLogLink(t);
+      e && u.info(`📂 Open the error list manually: ${e}`);
+    }, 0);
+  } catch (e) {
+    g(e);
+  }
+}
+async function W() {
+  try {
+    const r = await h();
+    return await l.get(r) ?? [];
+  } catch (r) {
+    return g(r, {
+      returnValue: []
+    });
+  }
+}
+async function U() {
+  try {
+    const r = await h();
+    await l.remove(r);
+  } catch (r) {
+    g(r);
+  }
+}
+function N(r) {
+  const t = [], e = [];
+  let s = "";
+  const i = /^\s*(\d+):(\d+)\s+(error|warning)\s+(.+?)\s+(\S+)$/, n = /^(.+?)\((\d+),(\d+)\):\s+(error|warning)\s+TS\d+:\s+(\S.+)$/, m = /^✖\s+(.*?)\s+\[(.*?)\]$/;
+  r.split(`
+`).forEach((o) => {
+    if (o.startsWith("/"))
+      s = o.trim();
+    else {
+      const c = i.exec(o) || [], f = n.exec(o) || [], p = m.exec(o) || [];
+      c.length && s ? t.push({
+        file: s,
+        position: `${c[1]}:${c[2]}`,
+        type: c[3] === a.Error ? a.Error : a.Warning,
+        message: c?.[4]?.trim() ?? "",
+        rule: c?.[5]?.trim() ?? ""
+      }) : f.length ? t.push({
+        file: f?.[1] ?? "",
+        position: `${f[2]}:${f[3]}`,
+        type: f[4] === a.Error ? a.Error : a.Warning,
+        message: f?.[5]?.trim() ?? ""
+      }) : p.length ? t.push({
+        file: "commitlint",
+        type: a.Error,
+        message: p?.[1]?.trim() ?? "",
+        rule: p?.[2]?.trim() ?? ""
+      }) : e.push(o.trim());
+    }
+  }), t.length && L(t), w.DEBUG && e.length && (u.warn("Unmatched lines:"), e.forEach((o) => u.info(`  ${o}`)));
+}
+function j(r) {
+  try {
+    const t = JSON.parse(r), e = [];
+    t.forEach(({ filePath: s, messages: i }) => {
+      i.forEach(({ severity: n, line: m, column: o, ruleId: c, message: f }) => {
+        e.push({
+          type: n === 2 ? a.Error : a.Warning,
+          file: s,
+          position: `${m}:${o}`,
+          rule: c,
+          message: f
+        });
+      });
+    }), e.length && L(e);
+  } catch {
+    N(r);
+  }
+}
+async function A(r, t = j) {
+  const e = new AbortController();
+  E.on("SIGINT", () => {
+    u.warn("Process interrupted. Terminating..."), e.abort(), E.exit();
+  });
+  try {
+    if (typeof r == "string") {
+      const { stdout: s, stderr: i } = await k(r, {
+        maxBuffer: 104857600,
+        signal: e.signal
+      });
+      [s, i].forEach((n) => n && t(n));
+    }
+  } catch (s) {
+    const { stdout: i, stderr: n, message: m } = s;
+    [i, n].forEach((o) => o && t(o)), !n && !i && u.error(`Command failed: ${m}`);
+  }
+}
+function Y(r) {
+  return { raw: !0, cmd: r };
+}
+function $(r, t) {
+  return t?.isCurrentProject ? `${y} ${S} ${I} ${r}` : `${y} ${T} ${r}`;
+}
+function B(r, t) {
+  return typeof r == "function" ? $(r(t), t) : typeof r == "object" && r?.raw === !0 ? r.cmd : typeof r == "string" ? $(r, t) : r;
+}
+async function X(r) {
+  const t = await C({ name: x });
+  if (t.success) {
+    const e = { isCurrentProject: t.result.isCurrentProject }, s = typeof r == "function" ? r(e) : r;
+    return Object.fromEntries(
+      Object.entries(s).map(([i, n]) => [i, B(n, e)])
+    );
+  }
+}
+async function F(r, t) {
+  try {
+    u.start(`${r}`), w.DEBUG && u.info(`→ ${t}`), await A(t), u.success(`${r} done.`);
+  } catch (e) {
+    g(e);
+  }
+}
+export {
+  U as clearAllErrorLists,
+  B as formatCommand,
+  W as getStoredErrorLists,
+  Y as rawCommand,
+  X as resolveCommands,
+  F as runCommand
+};

package/dist/node/command/index.js

@@ -0,0 +1,11 @@
+import { E_CommandType as m } from "./command.type.js";
+import { clearAllErrorLists as e, formatCommand as t, getStoredErrorLists as d, rawCommand as n, resolveCommands as s, runCommand as C } from "./command.util.js";
+export {
+  m as E_CommandType,
+  e as clearAllErrorLists,
+  t as formatCommand,
+  d as getStoredErrorLists,
+  n as rawCommand,
+  s as resolveCommands,
+  C as runCommand
+};

package/dist/{src/node → node}/express/express.util.js

@@ -1,10 +1,9 @@
 import { NestFactory as a } from "@nestjs/core";
-import { default as O } from "body-parser";
 import c from "compression";
 import f from "cookie-parser";
 import p from "cors";
 import s from "express";
-import { default as M } from "express";
+import { default as P } from "express";
 import m from "express-session";
 import l from "express-useragent";
 import d from "graphql-upload/graphqlUploadExpress.mjs";
@@ -17,10 +16,10 @@ function x({ isDev: e, whiteList: r, ...o }) {
     ...o
   };
 }
-function P(e) {
+function b(e) {
   return p(x(e));
 }
-function S(e) {
+function h(e) {
   return m(e);
 }
 function n(e) {
@@ -31,20 +30,19 @@ function u(e, r) {
     e.use(s.static(t));
   });
 }
-function h(e) {
+function G(e) {
   const r = s();
   return n(r), u(r, e?.static), r.use(d()), r;
 }
-async function G(e) {
+async function H(e) {
   const r = await a.create(e.module);
   return n(r.getHttpAdapter().getInstance()), u(r.getHttpAdapter().getInstance(), e.static), e.filters && r.useGlobalFilters(...e.filters), e.pipes && r.useGlobalPipes(...e.pipes), r;
 }
 export {
-  O as bodyParser,
-  P as createCors,
+  b as createCors,
   x as createCorsOptions,
-  h as createExpress,
-  G as createNest,
-  S as createSession,
-  M as express
+  G as createExpress,
+  H as createNest,
+  h as createSession,
+  P as express
 };

package/dist/node/log/index.js

@@ -0,0 +1,8 @@
+import { E_IssueType as e } from "./log.type.js";
+import { catchError as p, log as E, throwError as c } from "./log.util.js";
+export {
+  e as E_IssueType,
+  p as catchError,
+  E as log,
+  c as throwError
+};

package/dist/node/log/log.type.js

@@ -0,0 +1,4 @@
+var n = /* @__PURE__ */ ((r) => (r.Error = "error", r.Warning = "warning", r))(n || {});
+export {
+  n as E_IssueType
+};

package/dist/node/mongo/index.js

@@ -0,0 +1,17 @@
+import { MONGO_MIGRATE_OPTIONS as r } from "./mongo.constant.js";
+import { C_Collection as a, C_Db as n, C_Document as g, C_Model as l } from "./mongo.type.js";
+import { MongoController as f, MongooseController as C, mongo as _ } from "./mongo.util.js";
+import { default as x } from "mongoose-aggregate-paginate-v2";
+import { default as s } from "mongoose-paginate-v2";
+export {
+  a as C_Collection,
+  n as C_Db,
+  g as C_Document,
+  l as C_Model,
+  r as MONGO_MIGRATE_OPTIONS,
+  f as MongoController,
+  C as MongooseController,
+  x as aggregatePaginate,
+  _ as mongo,
+  s as mongoosePaginate
+};

package/dist/node/mongo/mongo.type.js

@@ -0,0 +1,16 @@
+import { Db as o, Collection as s } from "mongodb";
+import { Document as t, Model as l } from "mongoose";
+class d extends o {
+}
+class m extends t {
+}
+class C extends l {
+}
+class r extends s {
+}
+export {
+  r as C_Collection,
+  d as C_Db,
+  m as C_Document,
+  C as C_Model
+};

package/dist/{src/node → node}/mongo/mongo.util.js

@@ -9,7 +9,7 @@ import { RESPONSE_STATUS as i } from "../../constant/response-status.js";
 import { deepClone as D, getNestedValue as x, setNestedValue as C, isObject as O } from "../../util/object/object.util.js";
 import { regexSearchMapper as _ } from "../../util/common/common.util.js";
 import { writeFileSync as p, pathExistsSync as I, readFileSync as M, appendFileSync as b } from "../fs/fs.util.js";
-import { P as m, M as E } from "../../../index-BG1UznTl.js";
+import { PATH as m, MIGRATE_MONGO_CONFIG as E } from "../path/path.constant.js";
 import { validate as A } from "../../util/validate/validate.util.js";
 import { generateShortId as T, generateSlug as y } from "../../util/string/string.util.js";
 import { catchError as u } from "../log/log.util.js";

package/dist/node/package/index.js

@@ -0,0 +1,10 @@
+import { E_PackageType as t } from "./package.type.js";
+import { getLatestPackageVersion as c, getPackage as p, installDependencies as s, setupPackages as k, updatePackage as o } from "./package.util.js";
+export {
+  t as E_PackageType,
+  c as getLatestPackageVersion,
+  p as getPackage,
+  s as installDependencies,
+  k as setupPackages,
+  o as updatePackage
+};

package/dist/node/package/package.type.js

@@ -0,0 +1,4 @@
+var D = /* @__PURE__ */ ((e) => (e.DEPENDENCY = "dependencies", e.DEV_DEPENDENCY = "devDependencies", e.PEER_DEPENDENCY = "peerDependencies", e.BUNDLE_DEPENDENCY = "bundleDependencies", e.OPTIONAL_DEPENDENCY = "optionalDependencies", e))(D || {});
+export {
+  D as E_PackageType
+};