@umijs/utils 4.0.0-beta.8 → 4.0.0-canary-20240513.3

package/compiled/zod/package.json

@@ -0,0 +1 @@
+{"name":"zod","version":"3.20.6","author":"Colin McDonnell <colin@colinhacks.com>","license":"MIT","types":"./index.d.ts"}

package/dist/BaseGenerator/BaseGenerator.d.ts

@@ -1,6 +1,6 @@
 import prompts from '../../compiled/prompts';
-import Generator from '../Generator/Generator';
-interface IOpts {
+import Generator, { type IGeneratorOpts } from '../Generator/Generator';
+interface IBaseGeneratorOpts extends Partial<Omit<IGeneratorOpts, 'args'>> {
     path: string;
     target: string;
     data?: any;
@@ -11,7 +11,7 @@ export default class BaseGenerator extends Generator {
     target: string;
     data: any;
     questions: prompts.PromptObject[];
-    constructor({ path, target, data, questions }: IOpts);
+    constructor({ path, target, data, questions, baseDir, slient, }: IBaseGeneratorOpts);
     prompting(): prompts.PromptObject<string>[];
     writing(): Promise<void>;
 }

package/dist/BaseGenerator/BaseGenerator.js

@@ -1,58 +1,82 @@
-"use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
+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 __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
 };
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
+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;
 };
-Object.defineProperty(exports, "__esModule", { value: true });
-const fs_1 = require("fs");
-const path_1 = require("path");
-const fs_extra_1 = __importDefault(require("../../compiled/fs-extra"));
-const Generator_1 = __importDefault(require("../Generator/Generator"));
-class BaseGenerator extends Generator_1.default {
-    constructor({ path, target, data, questions }) {
-        super({ cwd: target, args: data });
-        this.path = path;
-        this.target = target;
-        this.data = data;
-        this.questions = questions || [];
-    }
-    prompting() {
-        return this.questions;
-    }
-    writing() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const context = Object.assign(Object.assign({}, this.data), this.prompts);
-            if ((0, fs_1.statSync)(this.path).isDirectory()) {
-                this.copyDirectory({
-                    context,
-                    path: this.path,
-                    target: this.target,
-                });
-            }
-            else {
-                const file = (0, path_1.basename)(this.path.replace(/\.tpl$/, ''));
-                if (this.path.endsWith('.tpl')) {
-                    this.copyTpl({
-                        templatePath: this.path,
-                        target: (0, path_1.join)(this.target, file),
-                        context,
-                    });
-                }
-                else {
-                    const absTarget = (0, path_1.join)(this.target, file);
-                    fs_extra_1.default.mkdirpSync((0, path_1.dirname)(absTarget));
-                    (0, fs_1.copyFileSync)(this.path, absTarget);
-                }
-            }
+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
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/BaseGenerator/BaseGenerator.ts
+var BaseGenerator_exports = {};
+__export(BaseGenerator_exports, {
+  default: () => BaseGenerator
+});
+module.exports = __toCommonJS(BaseGenerator_exports);
+var import_fs = require("fs");
+var import_path = require("path");
+var import_fs_extra = __toESM(require("../../compiled/fs-extra"));
+var import_Generator = __toESM(require("../Generator/Generator"));
+var BaseGenerator = class extends import_Generator.default {
+  constructor({
+    path,
+    target,
+    data,
+    questions,
+    baseDir,
+    slient
+  }) {
+    super({ baseDir: baseDir || target, args: data, slient });
+    this.path = path;
+    this.target = target;
+    this.data = data;
+    this.questions = questions || [];
+  }
+  prompting() {
+    return this.questions;
+  }
+  async writing() {
+    const context = {
+      ...this.data,
+      ...this.prompts
+    };
+    if ((0, import_fs.statSync)(this.path).isDirectory()) {
+      this.copyDirectory({
+        context,
+        path: this.path,
+        target: this.target
+      });
+    } else {
+      if (this.path.endsWith(".tpl")) {
+        this.copyTpl({
+          templatePath: this.path,
+          target: this.target,
+          context
         });
+      } else {
+        const absTarget = this.target;
+        import_fs_extra.default.mkdirpSync((0, import_path.dirname)(absTarget));
+        (0, import_fs.copyFileSync)(this.path, absTarget);
+      }
     }
-}
-exports.default = BaseGenerator;
+  }
+};

package/dist/BaseGenerator/generateFile.d.ts

@@ -1,7 +1,8 @@
 import prompts from '../../compiled/prompts';
-declare const generateFile: ({ path, target, data, questions, }: {
+declare const generateFile: ({ path, target, baseDir, data, questions, }: {
     path: string;
     target: string;
+    baseDir?: string | undefined;
     data?: any;
     questions?: prompts.PromptObject<string>[] | undefined;
 }) => Promise<void>;

package/dist/BaseGenerator/generateFile.js

@@ -1,25 +1,52 @@
-"use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
+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 __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
 };
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
+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;
 };
-Object.defineProperty(exports, "__esModule", { value: true });
-const BaseGenerator_1 = __importDefault(require("./BaseGenerator"));
-const generateFile = ({ path, target, data, questions, }) => __awaiter(void 0, void 0, void 0, function* () {
-    const generator = new BaseGenerator_1.default({
-        path,
-        target,
-        data,
-        questions,
-    });
-    yield generator.run();
+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
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/BaseGenerator/generateFile.ts
+var generateFile_exports = {};
+__export(generateFile_exports, {
+  default: () => generateFile_default
 });
-exports.default = generateFile;
+module.exports = __toCommonJS(generateFile_exports);
+var import_BaseGenerator = __toESM(require("./BaseGenerator"));
+var generateFile = async ({
+  path,
+  target,
+  baseDir,
+  data,
+  questions
+}) => {
+  const generator = new import_BaseGenerator.default({
+    path,
+    target,
+    baseDir,
+    data,
+    questions
+  });
+  await generator.run();
+};
+var generateFile_default = generateFile;

package/dist/Generator/Generator.d.ts

@@ -1,25 +1,29 @@
 import yParser from '../../compiled/yargs-parser';
-interface IOpts {
-    cwd: string;
+export interface IGeneratorOpts {
+    baseDir: string;
     args: yParser.Arguments;
+    slient?: boolean;
+}
+interface IGeneratorBaseOpts {
+    context: Record<string, any>;
+    target: string;
+}
+interface IGeneratorCopyTplOpts extends IGeneratorBaseOpts {
+    templatePath: string;
+}
+interface IGeneratorCopyDirectoryOpts extends IGeneratorBaseOpts {
+    path: string;
 }
 declare class Generator {
-    cwd: string;
+    baseDir: string;
     args: yParser.Arguments;
+    slient: boolean;
     prompts: any;
-    constructor({ cwd, args }: IOpts);
+    constructor({ baseDir, args, slient }: IGeneratorOpts);
     run(): Promise<void>;
     prompting(): any;
     writing(): Promise<void>;
-    copyTpl(opts: {
-        templatePath: string;
-        target: string;
-        context: object;
-    }): void;
-    copyDirectory(opts: {
-        path: string;
-        context: object;
-        target: string;
-    }): void;
+    copyTpl(opts: IGeneratorCopyTplOpts): void;
+    copyDirectory(opts: IGeneratorCopyDirectoryOpts): void;
 }
 export default Generator;

package/dist/Generator/Generator.js

@@ -1,74 +1,101 @@
-"use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
+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 __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
 };
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
+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;
 };
-Object.defineProperty(exports, "__esModule", { value: true });
-const fs_1 = require("fs");
-const path_1 = require("path");
-const chalk_1 = __importDefault(require("../../compiled/chalk"));
-const fs_extra_1 = __importDefault(require("../../compiled/fs-extra"));
-const glob_1 = __importDefault(require("../../compiled/glob"));
-const mustache_1 = __importDefault(require("../../compiled/mustache"));
-const prompts_1 = __importDefault(require("../../compiled/prompts"));
-class Generator {
-    constructor({ cwd, args }) {
-        this.cwd = cwd;
-        this.args = args;
-        this.prompts = {};
-    }
-    run() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const questions = this.prompting();
-            this.prompts = yield (0, prompts_1.default)(questions);
-            yield this.writing();
-        });
-    }
-    prompting() {
-        return [];
-    }
-    writing() {
-        return __awaiter(this, void 0, void 0, function* () { });
-    }
-    copyTpl(opts) {
-        const tpl = (0, fs_1.readFileSync)(opts.templatePath, 'utf-8');
-        const content = mustache_1.default.render(tpl, opts.context);
-        fs_extra_1.default.mkdirpSync((0, path_1.dirname)(opts.target));
-        console.log(`${chalk_1.default.green('Write:')} ${(0, path_1.relative)(this.cwd, opts.target)}`);
-        (0, fs_1.writeFileSync)(opts.target, content, 'utf-8');
+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
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/Generator/Generator.ts
+var Generator_exports = {};
+__export(Generator_exports, {
+  default: () => Generator_default
+});
+module.exports = __toCommonJS(Generator_exports);
+var import_fs = require("fs");
+var import_path = require("path");
+var import_chalk = __toESM(require("../../compiled/chalk"));
+var import_fs_extra = __toESM(require("../../compiled/fs-extra"));
+var import_glob = __toESM(require("../../compiled/glob"));
+var import_mustache = __toESM(require("../../compiled/mustache"));
+var import_prompts = __toESM(require("../../compiled/prompts"));
+var Generator = class {
+  constructor({ baseDir, args, slient }) {
+    this.baseDir = baseDir;
+    this.args = args;
+    this.slient = !!slient;
+    this.prompts = {};
+  }
+  async run() {
+    const questions = this.prompting();
+    this.prompts = await (0, import_prompts.default)(questions, {
+      onCancel() {
+        process.exit(1);
+      }
+    });
+    await this.writing();
+  }
+  prompting() {
+    return [];
+  }
+  async writing() {
+  }
+  copyTpl(opts) {
+    const tpl = (0, import_fs.readFileSync)(opts.templatePath, "utf-8");
+    const content = import_mustache.default.render(tpl, opts.context);
+    import_fs_extra.default.mkdirpSync((0, import_path.dirname)(opts.target));
+    if (!this.slient) {
+      console.log(
+        `${import_chalk.default.green("Write:")} ${(0, import_path.relative)(this.baseDir, opts.target)}`
+      );
     }
-    copyDirectory(opts) {
-        const files = glob_1.default.sync('**/*', {
-            cwd: opts.path,
-            dot: true,
-            ignore: ['**/node_modules/**'],
-        });
-        files.forEach((file) => {
-            const absFile = (0, path_1.join)(opts.path, file);
-            if ((0, fs_1.statSync)(absFile).isDirectory())
-                return;
-            if (file.endsWith('.tpl')) {
-                this.copyTpl({
-                    templatePath: absFile,
-                    target: (0, path_1.join)(opts.target, file.replace(/\.tpl$/, '')),
-                    context: opts.context,
-                });
-            }
-            else {
-                console.log(`${chalk_1.default.green('Copy: ')} ${file}`);
-                const absTarget = (0, path_1.join)(opts.target, file);
-                fs_extra_1.default.mkdirpSync((0, path_1.dirname)(absTarget));
-                (0, fs_1.copyFileSync)(absFile, absTarget);
-            }
+    (0, import_fs.writeFileSync)(opts.target, content, "utf-8");
+  }
+  copyDirectory(opts) {
+    const files = import_glob.default.sync("**/*", {
+      cwd: opts.path,
+      dot: true,
+      ignore: ["**/node_modules/**"]
+    });
+    files.forEach((file) => {
+      const absFile = (0, import_path.join)(opts.path, file);
+      if ((0, import_fs.statSync)(absFile).isDirectory())
+        return;
+      if (file.endsWith(".tpl")) {
+        this.copyTpl({
+          templatePath: absFile,
+          target: (0, import_path.join)(opts.target, file.replace(/\.tpl$/, "")),
+          context: opts.context
         });
-    }
-}
-exports.default = Generator;
+      } else {
+        if (!this.slient) {
+          console.log(`${import_chalk.default.green("Copy: ")} ${file}`);
+        }
+        const absTarget = (0, import_path.join)(opts.target, file);
+        import_fs_extra.default.mkdirpSync((0, import_path.dirname)(absTarget));
+        (0, import_fs.copyFileSync)(absFile, absTarget);
+      }
+    });
+  }
+};
+var Generator_default = Generator;

package/dist/aliasUtils/getAliasValue.d.ts

@@ -0,0 +1,4 @@
+export declare function getAliasValue(opts: {
+    imported: string;
+    alias: Record<string, string>;
+}): string | undefined;

package/dist/aliasUtils/getAliasValue.js

@@ -0,0 +1,66 @@
+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 __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+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
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/aliasUtils/getAliasValue.ts
+var getAliasValue_exports = {};
+__export(getAliasValue_exports, {
+  getAliasValue: () => getAliasValue
+});
+module.exports = __toCommonJS(getAliasValue_exports);
+var import_path = __toESM(require("path"));
+function getAliasValue(opts) {
+  const { imported, alias } = opts;
+  if (alias[imported]) {
+    return alias[imported];
+  }
+  for (const key of Object.keys(alias)) {
+    const value = alias[key];
+    if (key.endsWith("$")) {
+      if (imported === key.slice(0, -1)) {
+        return value;
+      } else {
+        continue;
+      }
+    }
+    const keyWithLastSlash = addLastSlash(key);
+    if (imported.startsWith(keyWithLastSlash)) {
+      const isWinPath = process.platform === "win32" && value.includes(import_path.default.sep);
+      if (isWinPath) {
+        return import_path.default.join(value, imported.slice(keyWithLastSlash.length));
+      }
+      return imported.replace(keyWithLastSlash, addLastSlash(value));
+    }
+  }
+}
+function addLastSlash(value) {
+  return value.endsWith("/") ? value : `${value}/`;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getAliasValue
+});

package/dist/aliasUtils/index.d.ts

@@ -0,0 +1,2 @@
+export { getAliasValue } from './getAliasValue';
+export { parseCircleAlias } from './parseCircleAlias';

package/dist/aliasUtils/index.js

@@ -0,0 +1,32 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/aliasUtils/index.ts
+var aliasUtils_exports = {};
+__export(aliasUtils_exports, {
+  getAliasValue: () => import_getAliasValue.getAliasValue,
+  parseCircleAlias: () => import_parseCircleAlias.parseCircleAlias
+});
+module.exports = __toCommonJS(aliasUtils_exports);
+var import_getAliasValue = require("./getAliasValue");
+var import_parseCircleAlias = require("./parseCircleAlias");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getAliasValue,
+  parseCircleAlias
+});

package/dist/aliasUtils/parseCircleAlias.d.ts

@@ -0,0 +1,4 @@
+export declare const parseCircleAlias: (opts: {
+    alias: Record<string, string>;
+    maxDepth?: number;
+}) => Record<string, any>;

package/dist/aliasUtils/parseCircleAlias.js

@@ -0,0 +1,66 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/aliasUtils/parseCircleAlias.ts
+var parseCircleAlias_exports = {};
+__export(parseCircleAlias_exports, {
+  parseCircleAlias: () => parseCircleAlias
+});
+module.exports = __toCommonJS(parseCircleAlias_exports);
+var import_path = require("path");
+var import_fs_extra = require("../../compiled/fs-extra");
+var import_getAliasValue = require("./getAliasValue");
+var DEFAULT_MAX_DEPTH = 5;
+var parseCircleAlias = (opts) => {
+  const { alias, maxDepth = DEFAULT_MAX_DEPTH } = opts;
+  const isExist = (value) => {
+    return value.startsWith(".") || (0, import_path.isAbsolute)(value) || (0, import_fs_extra.existsSync)(value);
+  };
+  const parsed = {};
+  Object.entries(alias).forEach(([key, value]) => {
+    if (isExist(value)) {
+      parsed[key] = value;
+    } else {
+      let realPath = value;
+      for (let i = 0; i < maxDepth; i++) {
+        const deeperPath = (0, import_getAliasValue.getAliasValue)({ imported: realPath, alias });
+        if (!deeperPath) {
+          parsed[key] = realPath;
+          break;
+        } else {
+          if (isExist(deeperPath)) {
+            parsed[key] = deeperPath;
+            break;
+          } else {
+            realPath = deeperPath;
+          }
+        }
+        if (i === maxDepth - 1) {
+          throw Error(
+            `endless loop detected in resolve alias for '${key}': '${value}', please check your alias config.`
+          );
+        }
+      }
+    }
+  });
+  return parsed;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  parseCircleAlias
+});