@better-t-stack/template-generator 3.37.0 → 3.38.0

package/dist/{is-binary-path-maAgJE_Q.mjs → is-binary-path-C-QlvTjz.mjs}

@@ -1,7 +1,7 @@
 import path from "node:path";
 //#endregion
 //#region ../../node_modules/.bun/is-binary-path@3.0.0/node_modules/is-binary-path/index.js
-const extensions = new Set([
+const extensions = /* @__PURE__ */ new Set([
 	"3dm",
 	"3ds",
 	"3g2",
@@ -271,4 +271,4 @@ function isBinaryPath(filePath) {
 //#endregion
 export { isBinaryPath as t };
 
-//# sourceMappingURL=is-binary-path-maAgJE_Q.mjs.map
+//# sourceMappingURL=is-binary-path-C-QlvTjz.mjs.map

package/dist/{is-binary-path-maAgJE_Q.mjs.map → is-binary-path-C-QlvTjz.mjs.map}

@@ -1 +1 @@
-{"version":3,"file":"is-binary-path-maAgJE_Q.mjs","names":["binaryExtensions","binaryExtensions"],"sources":["../../../node_modules/.bun/binary-extensions@3.1.0/node_modules/binary-extensions/binary-extensions.json","../../../node_modules/.bun/binary-extensions@3.1.0/node_modules/binary-extensions/index.js","../../../node_modules/.bun/is-binary-path@3.0.0/node_modules/is-binary-path/index.js"],"sourcesContent":["","import binaryExtensions from './binary-extensions.json' with {type: 'json'};\n\nexport default binaryExtensions;\n","import path from 'node:path';\nimport binaryExtensions from 'binary-extensions';\n\nconst extensions = new Set(binaryExtensions);\n\nexport default function isBinaryPath(filePath) {\n\treturn extensions.has(path.extname(filePath).slice(1).toLowerCase());\n}\n"],"x_google_ignoreList":[0,1,2],"mappings":";;;AEGA,MAAM,aAAa,IAAI,IAAIC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAAA,CAAgB;AAE3C,SAAwB,aAAa,UAAU;CAC9C,OAAO,WAAW,IAAI,KAAK,QAAQ,QAAQ,EAAE,MAAM,CAAC,EAAE,YAAY,CAAC;AACpE"}
+{"version":3,"file":"is-binary-path-C-QlvTjz.mjs","names":["binaryExtensions","binaryExtensions"],"sources":["../../../node_modules/.bun/binary-extensions@3.1.0/node_modules/binary-extensions/binary-extensions.json","../../../node_modules/.bun/binary-extensions@3.1.0/node_modules/binary-extensions/index.js","../../../node_modules/.bun/is-binary-path@3.0.0/node_modules/is-binary-path/index.js"],"sourcesContent":["","import binaryExtensions from './binary-extensions.json' with {type: 'json'};\n\nexport default binaryExtensions;\n","import path from 'node:path';\nimport binaryExtensions from 'binary-extensions';\n\nconst extensions = new Set(binaryExtensions);\n\nexport default function isBinaryPath(filePath) {\n\treturn extensions.has(path.extname(filePath).slice(1).toLowerCase());\n}\n"],"x_google_ignoreList":[0,1,2],"mappings":";;;AEGA,MAAM,6BAAa,IAAI,IAAIC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAAA,CAAgB;AAE3C,SAAwB,aAAa,UAAU;CAC9C,OAAO,WAAW,IAAI,KAAK,QAAQ,QAAQ,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,YAAY,CAAC;AACpE"}

package/dist/{template-reader-DVuwwW6S.mjs → template-reader-Apnxs6ej.mjs}

@@ -1,4 +1,4 @@
-import { t as isBinaryPath } from "./is-binary-path-maAgJE_Q.mjs";
+import { t as isBinaryPath } from "./is-binary-path-C-QlvTjz.mjs";
 import { dirname, join } from "pathe";
 import fs from "node:fs";
 import { fileURLToPath } from "node:url";
@@ -30,7 +30,7 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 	enumerable: true
 }) : target, mod));
 //#endregion
-//#region ../../node_modules/.bun/fdir@6.5.0+5b2c60377f53a28e/node_modules/fdir/dist/index.mjs
+//#region ../../node_modules/.bun/fdir@6.5.0+0cdedc5136c7dcff/node_modules/fdir/dist/index.mjs
 var __require = /* @__PURE__ */ createRequire(import.meta.url);
 function cleanPath(path) {
 	let normalized = normalize$1(path);
@@ -538,7 +538,7 @@ var Builder = class {
 	}
 };
 //#endregion
-//#region ../../node_modules/.bun/picomatch@4.0.4/node_modules/picomatch/lib/constants.js
+//#region ../../node_modules/.bun/picomatch@4.0.5/node_modules/picomatch/lib/constants.js
 var require_constants = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 	const WIN_SLASH = "\\\\/";
 	const WIN_NO_SLASH = `[^${WIN_SLASH}]`;
@@ -707,7 +707,7 @@ var require_constants = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 	};
 }));
 //#endregion
-//#region ../../node_modules/.bun/picomatch@4.0.4/node_modules/picomatch/lib/utils.js
+//#region ../../node_modules/.bun/picomatch@4.0.5/node_modules/picomatch/lib/utils.js
 var require_utils = /* @__PURE__ */ __commonJSMin(((exports) => {
 	const { REGEX_BACKSLASH, REGEX_REMOVE_BACKSLASH, REGEX_SPECIAL_CHARS, REGEX_SPECIAL_CHARS_GLOBAL } = require_constants();
 	exports.isObject = (val) => val !== null && typeof val === "object" && !Array.isArray(val);
@@ -755,7 +755,7 @@ var require_utils = /* @__PURE__ */ __commonJSMin(((exports) => {
 	};
 }));
 //#endregion
-//#region ../../node_modules/.bun/picomatch@4.0.4/node_modules/picomatch/lib/scan.js
+//#region ../../node_modules/.bun/picomatch@4.0.5/node_modules/picomatch/lib/scan.js
 var require_scan = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 	const utils = require_utils();
 	const { CHAR_ASTERISK, CHAR_AT, CHAR_BACKWARD_SLASH, CHAR_COMMA, CHAR_DOT, CHAR_EXCLAMATION_MARK, CHAR_FORWARD_SLASH, CHAR_LEFT_CURLY_BRACE, CHAR_LEFT_PARENTHESES, CHAR_LEFT_SQUARE_BRACKET, CHAR_PLUS, CHAR_QUESTION_MARK, CHAR_RIGHT_CURLY_BRACE, CHAR_RIGHT_PARENTHESES, CHAR_RIGHT_SQUARE_BRACKET } = require_constants();
@@ -1042,7 +1042,7 @@ var require_scan = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 	module.exports = scan;
 }));
 //#endregion
-//#region ../../node_modules/.bun/picomatch@4.0.4/node_modules/picomatch/lib/parse.js
+//#region ../../node_modules/.bun/picomatch@4.0.5/node_modules/picomatch/lib/parse.js
 var require_parse = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 	const constants = require_constants();
 	const utils = require_utils();
@@ -1197,7 +1197,10 @@ var require_parse = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 			}
 		}
 	};
-	const getStarExtglobSequenceOutput = (pattern) => {
+	const buildCharClassStar = (chars) => {
+		return `${chars.length === 1 ? utils.escapeRegex(chars[0]) : `[${chars.map((ch) => utils.escapeRegex(ch)).join("")}]`}*`;
+	};
+	const getStarExtglobSequenceChars = (pattern) => {
 		let index = 0;
 		const chars = [];
 		while (index < pattern.length) {
@@ -1211,7 +1214,7 @@ var require_parse = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 			index += match.end + 1;
 		}
 		if (chars.length < 1) return;
-		return `${chars.length === 1 ? utils.escapeRegex(chars[0]) : `[${chars.map((ch) => utils.escapeRegex(ch)).join("")}]`}*`;
+		return chars;
 	};
 	const repeatedExtglobRecursion = (pattern) => {
 		let depth = 0;
@@ -1231,14 +1234,28 @@ var require_parse = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 		if (branches.length > 1) {
 			if (branches.some((branch) => branch === "") || branches.some((branch) => /^[*?]+$/.test(branch)) || hasRepeatedCharPrefixOverlap(branches)) return { risky: true };
 		}
+		const safeChars = [];
+		let sawStarSequence = false;
+		let combinable = true;
 		for (const branch of branches) {
-			const safeOutput = getStarExtglobSequenceOutput(branch);
-			if (safeOutput) return {
-				risky: true,
-				safeOutput
-			};
+			const chars = getStarExtglobSequenceChars(branch);
+			if (chars) {
+				sawStarSequence = true;
+				safeChars.push(...chars);
+				continue;
+			}
+			const literal = normalizeSimpleBranch(branch);
+			if (literal && literal.length === 1) {
+				safeChars.push(literal);
+				continue;
+			}
+			combinable = false;
 			if (repeatedExtglobRecursion(branch) > max) return { risky: true };
 		}
+		if (sawStarSequence) return combinable ? {
+			risky: true,
+			safeOutput: buildCharClassStar([...new Set(safeChars)])
+		} : { risky: true };
 		return { risky: false };
 	};
 	/**
@@ -1389,7 +1406,8 @@ var require_parse = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 		};
 		const extglobClose = (token) => {
 			const literal = input.slice(token.startIndex, state.index + 1);
-			const analysis = analyzeRepeatedExtglob(input.slice(token.startIndex + 2, state.index), opts);
+			const body = input.slice(token.startIndex + 2, state.index);
+			const analysis = analyzeRepeatedExtglob(body, opts);
 			if ((token.type === "plus" || token.type === "star") && analysis.risky) {
 				const safeOutput = analysis.safeOutput ? (token.output ? "" : ONE_CHAR) + (opts.capture ? `(${analysis.safeOutput})` : analysis.safeOutput) : void 0;
 				const open = tokens[token.tokensIndex];
@@ -1515,7 +1533,8 @@ var require_parse = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 						if (inner.includes(":")) {
 							const idx = prev.value.lastIndexOf("[");
 							const pre = prev.value.slice(0, idx);
-							const posix = POSIX_REGEX_SOURCE[prev.value.slice(idx + 2)];
+							const rest = prev.value.slice(idx + 2);
+							const posix = POSIX_REGEX_SOURCE[rest];
 							if (posix) {
 								prev.value = pre + posix;
 								state.backtrack = true;
@@ -2097,7 +2116,7 @@ var require_parse = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 	module.exports = parse;
 }));
 //#endregion
-//#region ../../node_modules/.bun/picomatch@4.0.4/node_modules/picomatch/lib/picomatch.js
+//#region ../../node_modules/.bun/picomatch@4.0.5/node_modules/picomatch/lib/picomatch.js
 var require_picomatch$1 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 	const scan = require_scan();
 	const parse = require_parse();
@@ -2118,6 +2137,18 @@ var require_picomatch$1 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 	* const isMatch = picomatch('*.!(*a)');
 	* console.log(isMatch('a.a')); //=> false
 	* console.log(isMatch('a.b')); //=> true
+	*
+	* // For environments without `node.js`, `picomatch/posix` provides you a dependency-free matcher, without automatic OS detection.
+	* const picomatch = require('picomatch/posix');
+	* // the same API, defaulting to posix paths
+	* const isMatch = picomatch('a/*');
+	* console.log(isMatch('a\\b')); //=> false
+	* console.log(isMatch('a/b')); //=> true
+	*
+	* // you can still configure the matcher function to accept windows paths
+	* const isMatch = picomatch('a/*', { options: windows });
+	* console.log(isMatch('a\\b')); //=> true
+	* console.log(isMatch('a/b')); //=> true
 	* ```
 	* @name picomatch
 	* @param {String|Array} `globs` One or more glob patterns.
@@ -2236,8 +2267,8 @@ var require_picomatch$1 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 	* @return {Boolean}
 	* @api public
 	*/
-	picomatch.matchBase = (input, glob, options) => {
-		return (glob instanceof RegExp ? glob : picomatch.makeRe(glob, options)).test(utils.basename(input));
+	picomatch.matchBase = (input, glob, options, posix = options && options.windows) => {
+		return (glob instanceof RegExp ? glob : picomatch.makeRe(glob, options)).test(utils.basename(input, { windows: posix }));
 	};
 	/**
 	* Returns true if **any** of the given glob `patterns` match the specified `string`.
@@ -2397,7 +2428,7 @@ var require_picomatch$1 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 	module.exports = picomatch;
 }));
 //#endregion
-//#region ../../node_modules/.bun/tinyglobby@0.2.16/node_modules/tinyglobby/dist/index.mjs
+//#region ../../node_modules/.bun/tinyglobby@0.2.17/node_modules/tinyglobby/dist/index.mjs
 var import_picomatch = /* @__PURE__ */ __toESM((/* @__PURE__ */ __commonJSMin(((exports, module) => {
 	const pico = require_picomatch$1();
 	const utils = require_utils();
@@ -2413,6 +2444,7 @@ var import_picomatch = /* @__PURE__ */ __toESM((/* @__PURE__ */ __commonJSMin(((
 })))(), 1);
 const isReadonlyArray = Array.isArray;
 const BACKSLASHES = /\\/g;
+const DRIVE_RELATIVE_PATH = /^[A-Za-z]:$/;
 const isWin = process.platform === "win32";
 const ONLY_PARENT_DIRECTORIES = /^(\/?\.\.)+$/;
 function getPartialMatcher(patterns, options = {}) {
@@ -2479,6 +2511,9 @@ function buildRelative(cwd, root) {
 		return p[p.length - 1] === "/" && result !== "" ? `${result}/` : result || ".";
 	};
 }
+function ensureNonDriveRelativePath(path) {
+	return path.replace(DRIVE_RELATIVE_PATH, (match) => `${match}/`);
+}
 const splitPatternOptions = { parts: true };
 function splitPattern(path) {
 	var _result$parts;
@@ -2540,7 +2575,7 @@ function normalizePattern(pattern, opts, props, isIgnore) {
 		}
 		const potentialRoot = posix.join(cwd, parentDir.slice(i * 3));
 		if (potentialRoot[0] !== "." && props.root.length > potentialRoot.length) {
-			props.root = potentialRoot;
+			props.root = ensureNonDriveRelativePath(potentialRoot);
 			props.depthOffset = -n + i;
 		}
 	}
@@ -2560,7 +2595,7 @@ function normalizePattern(pattern, opts, props, isIgnore) {
 		}
 		props.depthOffset = newCommonPath.length;
 		props.commonPath = newCommonPath;
-		props.root = newCommonPath.length > 0 ? posix.join(cwd, ...newCommonPath) : cwd;
+		props.root = ensureNonDriveRelativePath(newCommonPath.length > 0 ? posix.join(cwd, ...newCommonPath) : cwd);
 	}
 	return result;
 }
@@ -2649,18 +2684,15 @@ function formatPaths(paths, mapper) {
 }
 const defaultOptions = {
 	caseSensitiveMatch: true,
-	cwd: process.cwd(),
 	debug: !!process.env.TINYGLOBBY_DEBUG,
 	expandDirectories: true,
 	followSymbolicLinks: true,
 	onlyFiles: true
 };
 function getOptions(options) {
-	const opts = {
-		...defaultOptions,
-		...options
-	};
-	opts.cwd = (opts.cwd instanceof URL ? fileURLToPath$1(opts.cwd) : resolve(opts.cwd)).replace(BACKSLASHES, "/");
+	const opts = Object.assign({}, options);
+	for (const key in defaultOptions) if (opts[key] === void 0) Object.assign(opts, { [key]: defaultOptions[key] });
+	opts.cwd = (opts.cwd instanceof URL ? fileURLToPath$1(opts.cwd) : resolve(opts.cwd || process.cwd())).replace(BACKSLASHES, "/");
 	opts.ignore = ensureStringArray(opts.ignore);
 	opts.fs && (opts.fs = {
 		readdir: opts.fs.readdir || readdir,
@@ -2748,4 +2780,4 @@ async function listTemplates(prefix) {
 //#endregion
 export { loadTemplates as a, loadTemplate as i, getTemplatesRoot as n, listTemplates as r, getBinaryTemplatesRoot as t };
 
-//# sourceMappingURL=template-reader-DVuwwW6S.mjs.map
+//# sourceMappingURL=template-reader-Apnxs6ej.mjs.map