@doyuli/create-vue 0.0.1

package/dist/index.js

@@ -0,0 +1,1223 @@
+import { createRequire } from "node:module";
+import * as fs from "node:fs";
+import { writeFileSync } from "node:fs";
+import * as path from "node:path";
+import { relative, resolve } from "node:path";
+import process from "node:process";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import { parseArgs } from "node:util";
+import { cancel, confirm, intro, isCancel, multiselect, outro, text } from "@clack/prompts";
+import pico from "picocolors";
+
+//#region rolldown:runtime
+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 __commonJS = (cb, mod) => function() {
+	return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+//#endregion
+//#region ../kits-core/src/utils/command.ts
+function getPackageManager() {
+	const userAgent = process.env.npm_config_user_agent ?? "";
+	return /pnpm/.test(userAgent) ? "pnpm" : /yarn/.test(userAgent) ? "yarn" : /bun/.test(userAgent) ? "bun" : "npm";
+}
+function getPackageCommand(packageManager, scriptName, args) {
+	if (scriptName === "install") return packageManager === "yarn" ? "yarn" : `${packageManager} install`;
+	if (scriptName === "build") return packageManager === "npm" || packageManager === "bun" ? `${packageManager} run build` : `${packageManager} build`;
+	if (args) return packageManager === "npm" ? `npm run ${scriptName} -- ${args}` : `${packageManager} ${scriptName} ${args}`;
+	else return packageManager === "npm" ? `npm run ${scriptName}` : `${packageManager} ${scriptName}`;
+}
+function getOutroMessage(root, cwd) {
+	const packageManager = getPackageManager();
+	let message = `项目初始化完成，可执行以下命令：\n\n`;
+	if (root !== cwd) {
+		const cdProjectName = relative(cwd, root);
+		message += `   ${pico.bold(pico.green(`cd ${cdProjectName.includes(" ") ? `"${cdProjectName}"` : cdProjectName}`))}\n`;
+	}
+	message += `   ${pico.bold(pico.green(getPackageCommand(packageManager, "install")))}\n`;
+	message += `   ${pico.bold(pico.green(getPackageCommand(packageManager, "lint:fix")))}\n`;
+	message += `   ${pico.bold(pico.green(getPackageCommand(packageManager, "dev")))}\n`;
+	return message;
+}
+
+//#endregion
+//#region ../kits-core/src/utils/directoryTraverse.ts
+function preOrderDirectoryTraverse(dir, dirCallback, fileCallback) {
+	for (const filename of fs.readdirSync(dir)) {
+		if (filename === ".git") continue;
+		const fullpath = path.resolve(dir, filename);
+		if (fs.lstatSync(fullpath).isDirectory()) {
+			dirCallback(fullpath);
+			if (fs.existsSync(fullpath)) preOrderDirectoryTraverse(fullpath, dirCallback, fileCallback);
+			continue;
+		}
+		fileCallback(fullpath);
+	}
+}
+const dotGitDirectoryState = { hasDotGitDirectory: false };
+function postOrderDirectoryTraverse(dir, dirCallback, fileCallback) {
+	for (const filename of fs.readdirSync(dir)) {
+		if (filename === ".git") {
+			dotGitDirectoryState.hasDotGitDirectory = true;
+			continue;
+		}
+		const fullpath = path.resolve(dir, filename);
+		if (fs.lstatSync(fullpath).isDirectory()) {
+			postOrderDirectoryTraverse(fullpath, dirCallback, fileCallback);
+			dirCallback(fullpath);
+			continue;
+		}
+		fileCallback(fullpath);
+	}
+}
+function canSkipEmptying(dir) {
+	if (!fs.existsSync(dir)) return true;
+	const files = fs.readdirSync(dir);
+	if (files.length === 0) return true;
+	if (files.length === 1 && files[0] === ".git") {
+		dotGitDirectoryState.hasDotGitDirectory = true;
+		return true;
+	}
+	return false;
+}
+function emptyDir(dir) {
+	if (!fs.existsSync(dir)) return;
+	postOrderDirectoryTraverse(dir, (dir$1) => fs.rmdirSync(dir$1), (file) => fs.unlinkSync(file));
+}
+
+//#endregion
+//#region ../kits-core/src/utils/prompts.ts
+async function unwrapPrompt(maybeCancelPromise) {
+	const result = await maybeCancelPromise;
+	if (isCancel(result)) {
+		cancel(`${pico.red("✖")} 操作取消`);
+		process.exit(0);
+	}
+	return result;
+}
+
+//#endregion
+//#region ../kits-core/src/utils/deepMerge.ts
+const isObject = (val) => val && typeof val === "object";
+const mergeArrayWithDedupe = (a, b) => Array.from(new Set([...a, ...b]));
+/**
+* Recursively merge the content of the new object to the existing one
+* @param {object} target the existing object
+* @param {object} obj the new object
+*/
+function deepMerge(target, obj) {
+	for (const key of Object.keys(obj)) {
+		const oldVal = target[key];
+		const newVal = obj[key];
+		if (Array.isArray(oldVal) && Array.isArray(newVal)) target[key] = mergeArrayWithDedupe(oldVal, newVal);
+		else if (isObject(oldVal) && isObject(newVal)) target[key] = deepMerge(oldVal, newVal);
+		else target[key] = newVal;
+	}
+	return target;
+}
+var deepMerge_default = deepMerge;
+
+//#endregion
+//#region ../kits-core/src/utils/sortDependencies.ts
+function sortDependencies(packageJson) {
+	const sorted = {};
+	const depTypes = [
+		"dependencies",
+		"devDependencies",
+		"peerDependencies",
+		"optionalDependencies"
+	];
+	for (const depType of depTypes) if (packageJson[depType]) {
+		sorted[depType] = {};
+		Object.keys(packageJson[depType]).sort().forEach((name) => {
+			sorted[depType][name] = packageJson[depType][name];
+		});
+	}
+	return {
+		...packageJson,
+		...sorted
+	};
+}
+
+//#endregion
+//#region ../kits-core/src/utils/renderTemplate.ts
+/**
+* Renders a template folder/file to the file system,
+* by recursively copying all files under the `src` directory,
+* with the following exception:
+*   - `_filename` should be renamed to `.filename`
+*   - Fields in `package.json` should be recursively merged
+* @param {string} src source filename to copy
+* @param {string} dest destination filename of the copy operation
+*/
+function renderTemplate(src, dest, callbacks) {
+	if (fs.statSync(src).isDirectory()) {
+		if (path.basename(src) === "node_modules") return;
+		fs.mkdirSync(dest, { recursive: true });
+		for (const file of fs.readdirSync(src)) renderTemplate(path.resolve(src, file), path.resolve(dest, file), callbacks);
+		return;
+	}
+	const filename = path.basename(src);
+	if (filename === "package.json" && fs.existsSync(dest)) {
+		const existing = JSON.parse(fs.readFileSync(dest, "utf8"));
+		const newPackage = JSON.parse(fs.readFileSync(src, "utf8"));
+		const pkg = sortDependencies(deepMerge_default(existing, newPackage));
+		fs.writeFileSync(dest, `${JSON.stringify(pkg, null, 2)}\n`);
+		return;
+	}
+	if (filename === "extensions.json" && fs.existsSync(dest)) {
+		const existing = JSON.parse(fs.readFileSync(dest, "utf8"));
+		const newExtensions = JSON.parse(fs.readFileSync(src, "utf8"));
+		const extensions = deepMerge_default(existing, newExtensions);
+		fs.writeFileSync(dest, `${JSON.stringify(extensions, null, 2)}\n`);
+		return;
+	}
+	if (filename === "settings.json" && fs.existsSync(dest)) {
+		const existing = JSON.parse(fs.readFileSync(dest, "utf8"));
+		const newSettings = JSON.parse(fs.readFileSync(src, "utf8"));
+		const settings = deepMerge_default(existing, newSettings);
+		fs.writeFileSync(dest, `${JSON.stringify(settings, null, 2)}\n`);
+		return;
+	}
+	if (filename.startsWith("_")) dest = path.resolve(path.dirname(dest), filename.replace(/^_/, "."));
+	if (filename === "_gitignore" && fs.existsSync(dest)) {
+		const existing = fs.readFileSync(dest, "utf8");
+		const newGitignore = fs.readFileSync(src, "utf8");
+		fs.writeFileSync(dest, `${existing}\n${newGitignore}`);
+		return;
+	}
+	if (filename.endsWith(".data.mjs")) {
+		dest = dest.replace(/\.data\.mjs$/, "");
+		callbacks.push(async (dataStore) => {
+			const getData = (await import(pathToFileURL(src).toString())).default;
+			dataStore[dest] = await getData({ oldData: dataStore[dest] || {} });
+		});
+		return;
+	}
+	fs.copyFileSync(src, dest);
+}
+
+//#endregion
+//#region ../kits-core/src/utils/render.ts
+function renderFile(root, fileName, content) {
+	writeFileSync(resolve(root, fileName), content, "utf-8");
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/ejs@3.1.10/node_modules/ejs/lib/utils.js
+var require_utils = /* @__PURE__ */ __commonJS({ "../../node_modules/.pnpm/ejs@3.1.10/node_modules/ejs/lib/utils.js": ((exports) => {
+	var regExpChars = /[|\\{}()[\]^$+*?.]/g;
+	var hasOwnProperty = Object.prototype.hasOwnProperty;
+	var hasOwn = function(obj, key) {
+		return hasOwnProperty.apply(obj, [key]);
+	};
+	/**
+	* Escape characters reserved in regular expressions.
+	*
+	* If `string` is `undefined` or `null`, the empty string is returned.
+	*
+	* @param {String} string Input string
+	* @return {String} Escaped string
+	* @static
+	* @private
+	*/
+	exports.escapeRegExpChars = function(string) {
+		// istanbul ignore if
+		if (!string) return "";
+		return String(string).replace(regExpChars, "\\$&");
+	};
+	var _ENCODE_HTML_RULES = {
+		"&": "&amp;",
+		"<": "&lt;",
+		">": "&gt;",
+		"\"": "&#34;",
+		"'": "&#39;"
+	};
+	var _MATCH_HTML = /[&<>'"]/g;
+	function encode_char(c) {
+		return _ENCODE_HTML_RULES[c] || c;
+	}
+	/**
+	* Stringified version of constants used by {@link module:utils.escapeXML}.
+	*
+	* It is used in the process of generating {@link ClientFunction}s.
+	*
+	* @readonly
+	* @type {String}
+	*/
+	var escapeFuncStr = "var _ENCODE_HTML_RULES = {\n      \"&\": \"&amp;\"\n    , \"<\": \"&lt;\"\n    , \">\": \"&gt;\"\n    , '\"': \"&#34;\"\n    , \"'\": \"&#39;\"\n    }\n  , _MATCH_HTML = /[&<>'\"]/g;\nfunction encode_char(c) {\n  return _ENCODE_HTML_RULES[c] || c;\n};\n";
+	/**
+	* Escape characters reserved in XML.
+	*
+	* If `markup` is `undefined` or `null`, the empty string is returned.
+	*
+	* @implements {EscapeCallback}
+	* @param {String} markup Input string
+	* @return {String} Escaped string
+	* @static
+	* @private
+	*/
+	exports.escapeXML = function(markup) {
+		return markup == void 0 ? "" : String(markup).replace(_MATCH_HTML, encode_char);
+	};
+	function escapeXMLToString() {
+		return Function.prototype.toString.call(this) + ";\n" + escapeFuncStr;
+	}
+	try {
+		if (typeof Object.defineProperty === "function") Object.defineProperty(exports.escapeXML, "toString", { value: escapeXMLToString });
+		else exports.escapeXML.toString = escapeXMLToString;
+	} catch (err) {
+		console.warn("Unable to set escapeXML.toString (is the Function prototype frozen?)");
+	}
+	/**
+	* Naive copy of properties from one object to another.
+	* Does not recurse into non-scalar properties
+	* Does not check to see if the property has a value before copying
+	*
+	* @param  {Object} to   Destination object
+	* @param  {Object} from Source object
+	* @return {Object}      Destination object
+	* @static
+	* @private
+	*/
+	exports.shallowCopy = function(to, from) {
+		from = from || {};
+		if (to !== null && to !== void 0) for (var p in from) {
+			if (!hasOwn(from, p)) continue;
+			if (p === "__proto__" || p === "constructor") continue;
+			to[p] = from[p];
+		}
+		return to;
+	};
+	/**
+	* Naive copy of a list of key names, from one object to another.
+	* Only copies property if it is actually defined
+	* Does not recurse into non-scalar properties
+	*
+	* @param  {Object} to   Destination object
+	* @param  {Object} from Source object
+	* @param  {Array} list List of properties to copy
+	* @return {Object}      Destination object
+	* @static
+	* @private
+	*/
+	exports.shallowCopyFromList = function(to, from, list) {
+		list = list || [];
+		from = from || {};
+		if (to !== null && to !== void 0) for (var i = 0; i < list.length; i++) {
+			var p = list[i];
+			if (typeof from[p] != "undefined") {
+				if (!hasOwn(from, p)) continue;
+				if (p === "__proto__" || p === "constructor") continue;
+				to[p] = from[p];
+			}
+		}
+		return to;
+	};
+	/**
+	* Simple in-process cache implementation. Does not implement limits of any
+	* sort.
+	*
+	* @implements {Cache}
+	* @static
+	* @private
+	*/
+	exports.cache = {
+		_data: {},
+		set: function(key, val) {
+			this._data[key] = val;
+		},
+		get: function(key) {
+			return this._data[key];
+		},
+		remove: function(key) {
+			delete this._data[key];
+		},
+		reset: function() {
+			this._data = {};
+		}
+	};
+	/**
+	* Transforms hyphen case variable into camel case.
+	*
+	* @param {String} string Hyphen case string
+	* @return {String} Camel case string
+	* @static
+	* @private
+	*/
+	exports.hyphenToCamel = function(str) {
+		return str.replace(/-[a-z]/g, function(match) {
+			return match[1].toUpperCase();
+		});
+	};
+	/**
+	* Returns a null-prototype object in runtimes that support it
+	*
+	* @return {Object} Object, prototype will be set to null where possible
+	* @static
+	* @private
+	*/
+	exports.createNullProtoObjWherePossible = (function() {
+		if (typeof Object.create == "function") return function() {
+			return Object.create(null);
+		};
+		return function() {
+			return {};
+		};
+	})();
+	exports.hasOwnOnlyObject = function(obj) {
+		var o = exports.createNullProtoObjWherePossible();
+		for (var p in obj) if (hasOwn(obj, p)) o[p] = obj[p];
+		return o;
+	};
+}) });
+
+//#endregion
+//#region ../../node_modules/.pnpm/ejs@3.1.10/node_modules/ejs/package.json
+var require_package = /* @__PURE__ */ __commonJS({ "../../node_modules/.pnpm/ejs@3.1.10/node_modules/ejs/package.json": ((exports, module) => {
+	module.exports = {
+		"name": "ejs",
+		"description": "Embedded JavaScript templates",
+		"keywords": [
+			"template",
+			"engine",
+			"ejs"
+		],
+		"version": "3.1.10",
+		"author": "Matthew Eernisse <mde@fleegix.org> (http://fleegix.org)",
+		"license": "Apache-2.0",
+		"bin": { "ejs": "./bin/cli.js" },
+		"main": "./lib/ejs.js",
+		"jsdelivr": "ejs.min.js",
+		"unpkg": "ejs.min.js",
+		"repository": {
+			"type": "git",
+			"url": "git://github.com/mde/ejs.git"
+		},
+		"bugs": "https://github.com/mde/ejs/issues",
+		"homepage": "https://github.com/mde/ejs",
+		"dependencies": { "jake": "^10.8.5" },
+		"devDependencies": {
+			"browserify": "^16.5.1",
+			"eslint": "^6.8.0",
+			"git-directory-deploy": "^1.5.1",
+			"jsdoc": "^4.0.2",
+			"lru-cache": "^4.0.1",
+			"mocha": "^10.2.0",
+			"uglify-js": "^3.3.16"
+		},
+		"engines": { "node": ">=0.10.0" },
+		"scripts": { "test": "npx jake test" }
+	};
+}) });
+
+//#endregion
+//#region ../../node_modules/.pnpm/ejs@3.1.10/node_modules/ejs/lib/ejs.js
+var require_ejs = /* @__PURE__ */ __commonJS({ "../../node_modules/.pnpm/ejs@3.1.10/node_modules/ejs/lib/ejs.js": ((exports) => {
+	/**
+	* @file Embedded JavaScript templating engine. {@link http://ejs.co}
+	* @author Matthew Eernisse <mde@fleegix.org>
+	* @author Tiancheng "Timothy" Gu <timothygu99@gmail.com>
+	* @project EJS
+	* @license {@link http://www.apache.org/licenses/LICENSE-2.0 Apache License, Version 2.0}
+	*/
+	/**
+	* EJS internal functions.
+	*
+	* Technically this "module" lies in the same file as {@link module:ejs}, for
+	* the sake of organization all the private functions re grouped into this
+	* module.
+	*
+	* @module ejs-internal
+	* @private
+	*/
+	/**
+	* Embedded JavaScript templating engine.
+	*
+	* @module ejs
+	* @public
+	*/
+	var fs$1 = __require("fs");
+	var path$1 = __require("path");
+	var utils = require_utils();
+	var scopeOptionWarned = false;
+	/** @type {string} */
+	var _VERSION_STRING = require_package().version;
+	var _DEFAULT_OPEN_DELIMITER = "<";
+	var _DEFAULT_CLOSE_DELIMITER = ">";
+	var _DEFAULT_DELIMITER = "%";
+	var _DEFAULT_LOCALS_NAME = "locals";
+	var _NAME = "ejs";
+	var _REGEX_STRING = "(<%%|%%>|<%=|<%-|<%_|<%#|<%|%>|-%>|_%>)";
+	var _OPTS_PASSABLE_WITH_DATA = [
+		"delimiter",
+		"scope",
+		"context",
+		"debug",
+		"compileDebug",
+		"client",
+		"_with",
+		"rmWhitespace",
+		"strict",
+		"filename",
+		"async"
+	];
+	var _OPTS_PASSABLE_WITH_DATA_EXPRESS = _OPTS_PASSABLE_WITH_DATA.concat("cache");
+	var _BOM = /^\uFEFF/;
+	var _JS_IDENTIFIER = /^[a-zA-Z_$][0-9a-zA-Z_$]*$/;
+	/**
+	* EJS template function cache. This can be a LRU object from lru-cache NPM
+	* module. By default, it is {@link module:utils.cache}, a simple in-process
+	* cache that grows continuously.
+	*
+	* @type {Cache}
+	*/
+	exports.cache = utils.cache;
+	/**
+	* Custom file loader. Useful for template preprocessing or restricting access
+	* to a certain part of the filesystem.
+	*
+	* @type {fileLoader}
+	*/
+	exports.fileLoader = fs$1.readFileSync;
+	/**
+	* Name of the object containing the locals.
+	*
+	* This variable is overridden by {@link Options}`.localsName` if it is not
+	* `undefined`.
+	*
+	* @type {String}
+	* @public
+	*/
+	exports.localsName = _DEFAULT_LOCALS_NAME;
+	/**
+	* Promise implementation -- defaults to the native implementation if available
+	* This is mostly just for testability
+	*
+	* @type {PromiseConstructorLike}
+	* @public
+	*/
+	exports.promiseImpl = new Function("return this;")().Promise;
+	/**
+	* Get the path to the included file from the parent file path and the
+	* specified path.
+	*
+	* @param {String}  name     specified path
+	* @param {String}  filename parent file path
+	* @param {Boolean} [isDir=false] whether the parent file path is a directory
+	* @return {String}
+	*/
+	exports.resolveInclude = function(name, filename, isDir) {
+		var dirname = path$1.dirname;
+		var extname = path$1.extname;
+		var resolve$1 = path$1.resolve;
+		var includePath = resolve$1(isDir ? filename : dirname(filename), name);
+		if (!extname(name)) includePath += ".ejs";
+		return includePath;
+	};
+	/**
+	* Try to resolve file path on multiple directories
+	*
+	* @param  {String}        name  specified path
+	* @param  {Array<String>} paths list of possible parent directory paths
+	* @return {String}
+	*/
+	function resolvePaths(name, paths) {
+		var filePath;
+		if (paths.some(function(v) {
+			filePath = exports.resolveInclude(name, v, true);
+			return fs$1.existsSync(filePath);
+		})) return filePath;
+	}
+	/**
+	* Get the path to the included file by Options
+	*
+	* @param  {String}  path    specified path
+	* @param  {Options} options compilation options
+	* @return {String}
+	*/
+	function getIncludePath(path$2, options) {
+		var includePath;
+		var filePath;
+		var views = options.views;
+		var match = /^[A-Za-z]+:\\|^\//.exec(path$2);
+		if (match && match.length) {
+			path$2 = path$2.replace(/^\/*/, "");
+			if (Array.isArray(options.root)) includePath = resolvePaths(path$2, options.root);
+			else includePath = exports.resolveInclude(path$2, options.root || "/", true);
+		} else {
+			if (options.filename) {
+				filePath = exports.resolveInclude(path$2, options.filename);
+				if (fs$1.existsSync(filePath)) includePath = filePath;
+			}
+			if (!includePath && Array.isArray(views)) includePath = resolvePaths(path$2, views);
+			if (!includePath && typeof options.includer !== "function") throw new Error("Could not find the include file \"" + options.escapeFunction(path$2) + "\"");
+		}
+		return includePath;
+	}
+	/**
+	* Get the template from a string or a file, either compiled on-the-fly or
+	* read from cache (if enabled), and cache the template if needed.
+	*
+	* If `template` is not set, the file specified in `options.filename` will be
+	* read.
+	*
+	* If `options.cache` is true, this function reads the file from
+	* `options.filename` so it must be set prior to calling this function.
+	*
+	* @memberof module:ejs-internal
+	* @param {Options} options   compilation options
+	* @param {String} [template] template source
+	* @return {(TemplateFunction|ClientFunction)}
+	* Depending on the value of `options.client`, either type might be returned.
+	* @static
+	*/
+	function handleCache(options, template) {
+		var func;
+		var filename = options.filename;
+		var hasTemplate = arguments.length > 1;
+		if (options.cache) {
+			if (!filename) throw new Error("cache option requires a filename");
+			func = exports.cache.get(filename);
+			if (func) return func;
+			if (!hasTemplate) template = fileLoader(filename).toString().replace(_BOM, "");
+		} else if (!hasTemplate) {
+			// istanbul ignore if: should not happen at all
+			if (!filename) throw new Error("Internal EJS error: no file name or template provided");
+			template = fileLoader(filename).toString().replace(_BOM, "");
+		}
+		func = exports.compile(template, options);
+		if (options.cache) exports.cache.set(filename, func);
+		return func;
+	}
+	/**
+	* Try calling handleCache with the given options and data and call the
+	* callback with the result. If an error occurs, call the callback with
+	* the error. Used by renderFile().
+	*
+	* @memberof module:ejs-internal
+	* @param {Options} options    compilation options
+	* @param {Object} data        template data
+	* @param {RenderFileCallback} cb callback
+	* @static
+	*/
+	function tryHandleCache(options, data, cb) {
+		var result;
+		if (!cb) if (typeof exports.promiseImpl == "function") return new exports.promiseImpl(function(resolve$1, reject) {
+			try {
+				result = handleCache(options)(data);
+				resolve$1(result);
+			} catch (err) {
+				reject(err);
+			}
+		});
+		else throw new Error("Please provide a callback function");
+		else {
+			try {
+				result = handleCache(options)(data);
+			} catch (err) {
+				return cb(err);
+			}
+			cb(null, result);
+		}
+	}
+	/**
+	* fileLoader is independent
+	*
+	* @param {String} filePath ejs file path.
+	* @return {String} The contents of the specified file.
+	* @static
+	*/
+	function fileLoader(filePath) {
+		return exports.fileLoader(filePath);
+	}
+	/**
+	* Get the template function.
+	*
+	* If `options.cache` is `true`, then the template is cached.
+	*
+	* @memberof module:ejs-internal
+	* @param {String}  path    path for the specified file
+	* @param {Options} options compilation options
+	* @return {(TemplateFunction|ClientFunction)}
+	* Depending on the value of `options.client`, either type might be returned
+	* @static
+	*/
+	function includeFile(path$2, options) {
+		var opts = utils.shallowCopy(utils.createNullProtoObjWherePossible(), options);
+		opts.filename = getIncludePath(path$2, opts);
+		if (typeof options.includer === "function") {
+			var includerResult = options.includer(path$2, opts.filename);
+			if (includerResult) {
+				if (includerResult.filename) opts.filename = includerResult.filename;
+				if (includerResult.template) return handleCache(opts, includerResult.template);
+			}
+		}
+		return handleCache(opts);
+	}
+	/**
+	* Re-throw the given `err` in context to the `str` of ejs, `filename`, and
+	* `lineno`.
+	*
+	* @implements {RethrowCallback}
+	* @memberof module:ejs-internal
+	* @param {Error}  err      Error object
+	* @param {String} str      EJS source
+	* @param {String} flnm     file name of the EJS file
+	* @param {Number} lineno   line number of the error
+	* @param {EscapeCallback} esc
+	* @static
+	*/
+	function rethrow(err, str, flnm, lineno, esc) {
+		var lines = str.split("\n");
+		var start = Math.max(lineno - 3, 0);
+		var end = Math.min(lines.length, lineno + 3);
+		var filename = esc(flnm);
+		var context = lines.slice(start, end).map(function(line, i) {
+			var curr = i + start + 1;
+			return (curr == lineno ? " >> " : "    ") + curr + "| " + line;
+		}).join("\n");
+		err.path = filename;
+		err.message = (filename || "ejs") + ":" + lineno + "\n" + context + "\n\n" + err.message;
+		throw err;
+	}
+	function stripSemi(str) {
+		return str.replace(/;(\s*$)/, "$1");
+	}
+	/**
+	* Compile the given `str` of ejs into a template function.
+	*
+	* @param {String}  template EJS template
+	*
+	* @param {Options} [opts] compilation options
+	*
+	* @return {(TemplateFunction|ClientFunction)}
+	* Depending on the value of `opts.client`, either type might be returned.
+	* Note that the return type of the function also depends on the value of `opts.async`.
+	* @public
+	*/
+	exports.compile = function compile(template, opts) {
+		var templ;
+		if (opts && opts.scope) {
+			if (!scopeOptionWarned) {
+				console.warn("`scope` option is deprecated and will be removed in EJS 3");
+				scopeOptionWarned = true;
+			}
+			if (!opts.context) opts.context = opts.scope;
+			delete opts.scope;
+		}
+		templ = new Template(template, opts);
+		return templ.compile();
+	};
+	/**
+	* Render the given `template` of ejs.
+	*
+	* If you would like to include options but not data, you need to explicitly
+	* call this function with `data` being an empty object or `null`.
+	*
+	* @param {String}   template EJS template
+	* @param {Object}  [data={}] template data
+	* @param {Options} [opts={}] compilation and rendering options
+	* @return {(String|Promise<String>)}
+	* Return value type depends on `opts.async`.
+	* @public
+	*/
+	exports.render = function(template, d, o) {
+		var data = d || utils.createNullProtoObjWherePossible();
+		var opts = o || utils.createNullProtoObjWherePossible();
+		if (arguments.length == 2) utils.shallowCopyFromList(opts, data, _OPTS_PASSABLE_WITH_DATA);
+		return handleCache(opts, template)(data);
+	};
+	/**
+	* Render an EJS file at the given `path` and callback `cb(err, str)`.
+	*
+	* If you would like to include options but not data, you need to explicitly
+	* call this function with `data` being an empty object or `null`.
+	*
+	* @param {String}             path     path to the EJS file
+	* @param {Object}            [data={}] template data
+	* @param {Options}           [opts={}] compilation and rendering options
+	* @param {RenderFileCallback} cb callback
+	* @public
+	*/
+	exports.renderFile = function() {
+		var args = Array.prototype.slice.call(arguments);
+		var filename = args.shift();
+		var cb;
+		var opts = { filename };
+		var data;
+		var viewOpts;
+		if (typeof arguments[arguments.length - 1] == "function") cb = args.pop();
+		if (args.length) {
+			data = args.shift();
+			if (args.length) utils.shallowCopy(opts, args.pop());
+			else {
+				if (data.settings) {
+					if (data.settings.views) opts.views = data.settings.views;
+					if (data.settings["view cache"]) opts.cache = true;
+					viewOpts = data.settings["view options"];
+					if (viewOpts) utils.shallowCopy(opts, viewOpts);
+				}
+				utils.shallowCopyFromList(opts, data, _OPTS_PASSABLE_WITH_DATA_EXPRESS);
+			}
+			opts.filename = filename;
+		} else data = utils.createNullProtoObjWherePossible();
+		return tryHandleCache(opts, data, cb);
+	};
+	/**
+	* Clear intermediate JavaScript cache. Calls {@link Cache#reset}.
+	* @public
+	*/
+	/**
+	* EJS template class
+	* @public
+	*/
+	exports.Template = Template;
+	exports.clearCache = function() {
+		exports.cache.reset();
+	};
+	function Template(text$1, optsParam) {
+		var opts = utils.hasOwnOnlyObject(optsParam);
+		var options = utils.createNullProtoObjWherePossible();
+		this.templateText = text$1;
+		/** @type {string | null} */
+		this.mode = null;
+		this.truncate = false;
+		this.currentLine = 1;
+		this.source = "";
+		options.client = opts.client || false;
+		options.escapeFunction = opts.escape || opts.escapeFunction || utils.escapeXML;
+		options.compileDebug = opts.compileDebug !== false;
+		options.debug = !!opts.debug;
+		options.filename = opts.filename;
+		options.openDelimiter = opts.openDelimiter || exports.openDelimiter || _DEFAULT_OPEN_DELIMITER;
+		options.closeDelimiter = opts.closeDelimiter || exports.closeDelimiter || _DEFAULT_CLOSE_DELIMITER;
+		options.delimiter = opts.delimiter || exports.delimiter || _DEFAULT_DELIMITER;
+		options.strict = opts.strict || false;
+		options.context = opts.context;
+		options.cache = opts.cache || false;
+		options.rmWhitespace = opts.rmWhitespace;
+		options.root = opts.root;
+		options.includer = opts.includer;
+		options.outputFunctionName = opts.outputFunctionName;
+		options.localsName = opts.localsName || exports.localsName || _DEFAULT_LOCALS_NAME;
+		options.views = opts.views;
+		options.async = opts.async;
+		options.destructuredLocals = opts.destructuredLocals;
+		options.legacyInclude = typeof opts.legacyInclude != "undefined" ? !!opts.legacyInclude : true;
+		if (options.strict) options._with = false;
+		else options._with = typeof opts._with != "undefined" ? opts._with : true;
+		this.opts = options;
+		this.regex = this.createRegex();
+	}
+	Template.modes = {
+		EVAL: "eval",
+		ESCAPED: "escaped",
+		RAW: "raw",
+		COMMENT: "comment",
+		LITERAL: "literal"
+	};
+	Template.prototype = {
+		createRegex: function() {
+			var str = _REGEX_STRING;
+			var delim = utils.escapeRegExpChars(this.opts.delimiter);
+			var open = utils.escapeRegExpChars(this.opts.openDelimiter);
+			var close = utils.escapeRegExpChars(this.opts.closeDelimiter);
+			str = str.replace(/%/g, delim).replace(/</g, open).replace(/>/g, close);
+			return new RegExp(str);
+		},
+		compile: function() {
+			/** @type {string} */
+			var src;
+			/** @type {ClientFunction} */
+			var fn;
+			var opts = this.opts;
+			var prepended = "";
+			var appended = "";
+			/** @type {EscapeCallback} */
+			var escapeFn = opts.escapeFunction;
+			/** @type {FunctionConstructor} */
+			var ctor;
+			/** @type {string} */
+			var sanitizedFilename = opts.filename ? JSON.stringify(opts.filename) : "undefined";
+			if (!this.source) {
+				this.generateSource();
+				prepended += "  var __output = \"\";\n  function __append(s) { if (s !== undefined && s !== null) __output += s }\n";
+				if (opts.outputFunctionName) {
+					if (!_JS_IDENTIFIER.test(opts.outputFunctionName)) throw new Error("outputFunctionName is not a valid JS identifier.");
+					prepended += "  var " + opts.outputFunctionName + " = __append;\n";
+				}
+				if (opts.localsName && !_JS_IDENTIFIER.test(opts.localsName)) throw new Error("localsName is not a valid JS identifier.");
+				if (opts.destructuredLocals && opts.destructuredLocals.length) {
+					var destructuring = "  var __locals = (" + opts.localsName + " || {}),\n";
+					for (var i = 0; i < opts.destructuredLocals.length; i++) {
+						var name = opts.destructuredLocals[i];
+						if (!_JS_IDENTIFIER.test(name)) throw new Error("destructuredLocals[" + i + "] is not a valid JS identifier.");
+						if (i > 0) destructuring += ",\n  ";
+						destructuring += name + " = __locals." + name;
+					}
+					prepended += destructuring + ";\n";
+				}
+				if (opts._with !== false) {
+					prepended += "  with (" + opts.localsName + " || {}) {\n";
+					appended += "  }\n";
+				}
+				appended += "  return __output;\n";
+				this.source = prepended + this.source + appended;
+			}
+			if (opts.compileDebug) src = "var __line = 1\n  , __lines = " + JSON.stringify(this.templateText) + "\n  , __filename = " + sanitizedFilename + ";\ntry {\n" + this.source + "} catch (e) {\n  rethrow(e, __lines, __filename, __line, escapeFn);\n}\n";
+			else src = this.source;
+			if (opts.client) {
+				src = "escapeFn = escapeFn || " + escapeFn.toString() + ";\n" + src;
+				if (opts.compileDebug) src = "rethrow = rethrow || " + rethrow.toString() + ";\n" + src;
+			}
+			if (opts.strict) src = "\"use strict\";\n" + src;
+			if (opts.debug) console.log(src);
+			if (opts.compileDebug && opts.filename) src = src + "\n//# sourceURL=" + sanitizedFilename + "\n";
+			try {
+				if (opts.async) try {
+					ctor = new Function("return (async function(){}).constructor;")();
+				} catch (e) {
+					if (e instanceof SyntaxError) throw new Error("This environment does not support async/await");
+					else throw e;
+				}
+				else ctor = Function;
+				fn = new ctor(opts.localsName + ", escapeFn, include, rethrow", src);
+			} catch (e) {
+				// istanbul ignore else
+				if (e instanceof SyntaxError) {
+					if (opts.filename) e.message += " in " + opts.filename;
+					e.message += " while compiling ejs\n\n";
+					e.message += "If the above error is not helpful, you may want to try EJS-Lint:\n";
+					e.message += "https://github.com/RyanZim/EJS-Lint";
+					if (!opts.async) {
+						e.message += "\n";
+						e.message += "Or, if you meant to create an async function, pass `async: true` as an option.";
+					}
+				}
+				throw e;
+			}
+			var returnedFn = opts.client ? fn : function anonymous(data) {
+				var include = function(path$2, includeData) {
+					var d = utils.shallowCopy(utils.createNullProtoObjWherePossible(), data);
+					if (includeData) d = utils.shallowCopy(d, includeData);
+					return includeFile(path$2, opts)(d);
+				};
+				return fn.apply(opts.context, [
+					data || utils.createNullProtoObjWherePossible(),
+					escapeFn,
+					include,
+					rethrow
+				]);
+			};
+			if (opts.filename && typeof Object.defineProperty === "function") {
+				var filename = opts.filename;
+				var basename = path$1.basename(filename, path$1.extname(filename));
+				try {
+					Object.defineProperty(returnedFn, "name", {
+						value: basename,
+						writable: false,
+						enumerable: false,
+						configurable: true
+					});
+				} catch (e) {}
+			}
+			return returnedFn;
+		},
+		generateSource: function() {
+			if (this.opts.rmWhitespace) this.templateText = this.templateText.replace(/[\r\n]+/g, "\n").replace(/^\s+|\s+$/gm, "");
+			this.templateText = this.templateText.replace(/[ \t]*<%_/gm, "<%_").replace(/_%>[ \t]*/gm, "_%>");
+			var self = this;
+			var matches = this.parseTemplateText();
+			var d = this.opts.delimiter;
+			var o = this.opts.openDelimiter;
+			var c = this.opts.closeDelimiter;
+			if (matches && matches.length) matches.forEach(function(line, index) {
+				var closing;
+				if (line.indexOf(o + d) === 0 && line.indexOf(o + d + d) !== 0) {
+					closing = matches[index + 2];
+					if (!(closing == d + c || closing == "-" + d + c || closing == "_" + d + c)) throw new Error("Could not find matching close tag for \"" + line + "\".");
+				}
+				self.scanLine(line);
+			});
+		},
+		parseTemplateText: function() {
+			var str = this.templateText;
+			var pat = this.regex;
+			var result = pat.exec(str);
+			var arr = [];
+			var firstPos;
+			while (result) {
+				firstPos = result.index;
+				if (firstPos !== 0) {
+					arr.push(str.substring(0, firstPos));
+					str = str.slice(firstPos);
+				}
+				arr.push(result[0]);
+				str = str.slice(result[0].length);
+				result = pat.exec(str);
+			}
+			if (str) arr.push(str);
+			return arr;
+		},
+		_addOutput: function(line) {
+			if (this.truncate) {
+				line = line.replace(/^(?:\r\n|\r|\n)/, "");
+				this.truncate = false;
+			}
+			if (!line) return line;
+			line = line.replace(/\\/g, "\\\\");
+			line = line.replace(/\n/g, "\\n");
+			line = line.replace(/\r/g, "\\r");
+			line = line.replace(/"/g, "\\\"");
+			this.source += "    ; __append(\"" + line + "\")\n";
+		},
+		scanLine: function(line) {
+			var self = this;
+			var d = this.opts.delimiter;
+			var o = this.opts.openDelimiter;
+			var c = this.opts.closeDelimiter;
+			var newLineCount = 0;
+			newLineCount = line.split("\n").length - 1;
+			switch (line) {
+				case o + d:
+				case o + d + "_":
+					this.mode = Template.modes.EVAL;
+					break;
+				case o + d + "=":
+					this.mode = Template.modes.ESCAPED;
+					break;
+				case o + d + "-":
+					this.mode = Template.modes.RAW;
+					break;
+				case o + d + "#":
+					this.mode = Template.modes.COMMENT;
+					break;
+				case o + d + d:
+					this.mode = Template.modes.LITERAL;
+					this.source += "    ; __append(\"" + line.replace(o + d + d, o + d) + "\")\n";
+					break;
+				case d + d + c:
+					this.mode = Template.modes.LITERAL;
+					this.source += "    ; __append(\"" + line.replace(d + d + c, d + c) + "\")\n";
+					break;
+				case d + c:
+				case "-" + d + c:
+				case "_" + d + c:
+					if (this.mode == Template.modes.LITERAL) this._addOutput(line);
+					this.mode = null;
+					this.truncate = line.indexOf("-") === 0 || line.indexOf("_") === 0;
+					break;
+				default: if (this.mode) {
+					switch (this.mode) {
+						case Template.modes.EVAL:
+						case Template.modes.ESCAPED:
+						case Template.modes.RAW: if (line.lastIndexOf("//") > line.lastIndexOf("\n")) line += "\n";
+					}
+					switch (this.mode) {
+						case Template.modes.EVAL:
+							this.source += "    ; " + line + "\n";
+							break;
+						case Template.modes.ESCAPED:
+							this.source += "    ; __append(escapeFn(" + stripSemi(line) + "))\n";
+							break;
+						case Template.modes.RAW:
+							this.source += "    ; __append(" + stripSemi(line) + ")\n";
+							break;
+						case Template.modes.COMMENT: break;
+						case Template.modes.LITERAL:
+							this._addOutput(line);
+							break;
+					}
+				} else this._addOutput(line);
+			}
+			if (self.opts.compileDebug && newLineCount) {
+				this.currentLine += newLineCount;
+				this.source += "    ; __line = " + this.currentLine + "\n";
+			}
+		}
+	};
+	/**
+	* Escape characters reserved in XML.
+	*
+	* This is simply an export of {@link module:utils.escapeXML}.
+	*
+	* If `markup` is `undefined` or `null`, the empty string is returned.
+	*
+	* @param {String} markup Input string
+	* @return {String} Escaped string
+	* @public
+	* @func
+	* */
+	exports.escapeXML = utils.escapeXML;
+	/**
+	* Express.js support.
+	*
+	* This is an alias for {@link module:ejs.renderFile}, in order to support
+	* Express.js out-of-the-box.
+	*
+	* @func
+	*/
+	exports.__express = exports.renderFile;
+	/**
+	* Version of EJS.
+	*
+	* @readonly
+	* @type {String}
+	* @public
+	*/
+	exports.VERSION = _VERSION_STRING;
+	/**
+	* Name for detection of EJS.
+	*
+	* @readonly
+	* @type {String}
+	* @public
+	*/
+	exports.name = _NAME;
+	/* istanbul ignore if */
+	if (typeof window != "undefined") window.ejs = exports;
+}) });
+
+//#endregion
+//#region src/constants.ts
+var import_ejs = /* @__PURE__ */ __toESM(require_ejs(), 1);
+const DEFAULT_BANNER = "Template-Kits - 快速生成你的模板代码";
+const FEATURE_OPTIONS = [
+	{
+		value: "unplugin-vue-router",
+		label: "Unplugin Vue Router（约定式路由）"
+	},
+	{
+		value: "simple-git-hooks",
+		label: "Simple Git Hooks（Git Commit 检查）"
+	},
+	{
+		value: "vitest",
+		label: "Vitest（单元测试）"
+	}
+];
+
+//#endregion
+//#region src/index.ts
+async function promptUser() {
+	const { positionals } = parseArgs({
+		strict: true,
+		allowPositionals: true
+	});
+	let targetDir = positionals[0];
+	const defaultProjectName = targetDir || "Template-Kits";
+	const result = {
+		projectName: defaultProjectName,
+		packageName: defaultProjectName,
+		shouldOverwrite: false,
+		features: []
+	};
+	if (!targetDir) targetDir = result.projectName = result.packageName = (await unwrapPrompt(text({
+		message: "请输入项目名称：",
+		placeholder: defaultProjectName,
+		defaultValue: "",
+		validate: (value) => value.trim().length === 0 ? "不能为空" : ""
+	}))).trim();
+	if (!canSkipEmptying(targetDir)) {
+		result.shouldOverwrite = await unwrapPrompt(confirm({
+			message: `${targetDir === "." ? "当前目录" : `目标文件夹 "${targetDir}"`} 非空，是否覆盖？`,
+			initialValue: false
+		}));
+		if (!result.shouldOverwrite) {
+			cancel(`${pico.red("✖")} 操作取消`);
+			process.exit(0);
+		}
+	}
+	result.features = await unwrapPrompt(multiselect({
+		message: `请选择要包含的功能： ${pico.dim("(↑/↓ 切换，空格选择，a 全选，回车确认)")}`,
+		options: FEATURE_OPTIONS,
+		required: false
+	}));
+	return {
+		result,
+		targetDir
+	};
+}
+function setupProjectDir(cwd, result, targetDir) {
+	const root = path.join(cwd, targetDir);
+	if (fs.existsSync(root) && result.shouldOverwrite) emptyDir(root);
+	else if (!fs.existsSync(root)) fs.mkdirSync(root);
+	console.log(`\n正在初始化项目 ${root}...`);
+	const pkg = {
+		name: result.packageName,
+		version: "0.0.0"
+	};
+	renderFile(root, "tsconfig.json", JSON.stringify(pkg, null, 2));
+	return root;
+}
+function renderTemplates(root, result) {
+	const { features = [] } = result;
+	const needsAutoRouter = features.includes("unplugin-vue-router");
+	const needsGitHooks = features.includes("simple-git-hooks");
+	const needsVitest = features.includes("vitest");
+	const templateRoot = fileURLToPath(new URL("../template", import.meta.url));
+	const callbacks = [];
+	const render = (templateName) => {
+		const templateDir = path.resolve(templateRoot, templateName);
+		renderTemplate(templateDir, root, callbacks);
+	};
+	render("base");
+	render("eslint");
+	render("tsconfig");
+	render(needsAutoRouter ? "router/unplugin" : "router/default");
+	if (needsGitHooks) render("git-hooks");
+	const rootTsConfig = {
+		files: [],
+		references: [{ path: "./tsconfig.node.json" }, { path: "./tsconfig.app.json" }]
+	};
+	if (needsVitest) {
+		render("vitest");
+		rootTsConfig.references.push({ path: "./tsconfig.vitest.json" });
+	}
+	renderFile(root, "tsconfig.json", `${JSON.stringify(rootTsConfig, null, 2)}\n`);
+	renderFile(root, ".env", `VITE_APP_TITLE = ${result.packageName}\n`);
+	preOrderDirectoryTraverse(root, () => {}, (filepath) => {
+		if (filepath.endsWith(".ejs")) {
+			const template = fs.readFileSync(filepath, "utf-8");
+			const dest = filepath.replace(/\.ejs$/, "");
+			const content = import_ejs.render(template, {
+				needsAutoRouter,
+				needsGitHooks
+			});
+			fs.writeFileSync(dest, content);
+			fs.unlinkSync(filepath);
+		}
+	});
+}
+(async function() {
+	const cwd = process.cwd();
+	intro(pico.magenta(DEFAULT_BANNER));
+	const { result, targetDir } = await promptUser();
+	const root = setupProjectDir(cwd, result, targetDir);
+	renderTemplates(root, result);
+	outro(getOutroMessage(root, cwd));
+})();
+
+//#endregion
+export {  };