keycloakify 10.0.0-rc.73 → 10.0.0-rc.75

package/bin/{363.index.js → 440.index.js}

@@ -1,6 +1,6 @@
 "use strict";
-exports.id = 363;
-exports.ids = [363];
+exports.id = 440;
+exports.ids = [440];
 exports.modules = {
 
 /***/ 73817:
@@ -155,7 +155,7 @@ function generateMessageProperties(params) {
 
 /***/ }),
 
-/***/ 52363:
+/***/ 46440:
 /***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
 
 // ESM COMPAT FLAG
@@ -348,63 +348,28 @@ const { readAssetsDirSync } = (() => {
 ;// CONCATENATED MODULE: ./dist/bin/keycloakify/replacers/replaceImportsInJsCode/index.js
 
 //# sourceMappingURL=index.js.map
-// EXTERNAL MODULE: external "crypto"
-var external_crypto_ = __webpack_require__(6113);
 ;// CONCATENATED MODULE: ./dist/bin/keycloakify/replacers/replaceImportsInCssCode.js
 
 
-
 (0,assert.assert)();
 function replaceImportsInCssCode(params) {
-    var _a;
-    const { cssCode } = params;
-    const cssGlobalsToDefine = {};
-    new Set((_a = cssCode.match(/url\(["']?\/[^/][^)"']+["']?\)[^;}]*?/g)) !== null && _a !== void 0 ? _a : []).forEach(match => (cssGlobalsToDefine["url" +
-        external_crypto_.createHash("sha256")
-            .update(match)
-            .digest("hex")
-            .substring(0, 15)] = match));
-    let fixedCssCode = cssCode;
-    Object.keys(cssGlobalsToDefine).forEach(cssVariableName => 
-    //NOTE: split/join pattern ~ replace all
-    (fixedCssCode = fixedCssCode
-        .split(cssGlobalsToDefine[cssVariableName])
-        .join(`var(--${cssVariableName})`)));
-    return { fixedCssCode, cssGlobalsToDefine };
-}
-function generateCssCodeToDefineGlobals(params) {
-    const { cssGlobalsToDefine, buildContext } = params;
-    return {
-        cssCodeToPrependInHead: [
-            ":root {",
-            ...Object.keys(cssGlobalsToDefine)
-                .map(cssVariableName => {
-                var _a;
-                return [
-                    `--${cssVariableName}:`,
-                    cssGlobalsToDefine[cssVariableName].replace(new RegExp(`url\\(${((_a = buildContext.urlPathname) !== null && _a !== void 0 ? _a : "/").replace(/\//g, "\\/")}`, "g"), `url(\${url.resourcesPath}/${constants/* basenameOfTheKeycloakifyResourcesDir */.M}/`)
-                ].join(" ");
-            })
-                .map(line => `    ${line};`),
-            "}"
-        ].join("\n")
-    };
+    const { cssCode, fileRelativeDirPath, buildContext } = params;
+    const fixedCssCode = cssCode.replace(/url\(["']?(\/[^/][^)"']+)["']?\)/g, (match, assetFileAbsoluteUrlPathname) => {
+        if (buildContext.urlPathname !== undefined) {
+            if (!assetFileAbsoluteUrlPathname.startsWith(buildContext.urlPathname)) {
+                // NOTE: Should never happen
+                return match;
+            }
+            assetFileAbsoluteUrlPathname = assetFileAbsoluteUrlPathname.replace(buildContext.urlPathname, "/");
+        }
+        const assetFileRelativeUrlPathname = external_path_.posix.relative(fileRelativeDirPath.replace(/\\/g, "/"), assetFileAbsoluteUrlPathname.replace(/^\//, ""));
+        return `url(${assetFileRelativeUrlPathname})`;
+    });
+    return { fixedCssCode };
 }
 //# sourceMappingURL=replaceImportsInCssCode.js.map
 // EXTERNAL MODULE: ./node_modules/cheerio/lib/esm/index.js + 76 modules
 var esm = __webpack_require__(87182);
-;// CONCATENATED MODULE: ./dist/bin/keycloakify/replacers/replaceImportsInInlineCssCode.js
-
-
-(0,assert.assert)();
-function replaceImportsInInlineCssCode(params) {
-    const { cssCode, buildContext } = params;
-    const fixedCssCode = cssCode.replace(buildContext.urlPathname === undefined
-        ? /url\(["']?\/([^/][^)"']+)["']?\)/g
-        : new RegExp(`url\\(["']?${buildContext.urlPathname}([^)"']+)["']?\\)`, "g"), (...[, group]) => `url(\${url.resourcesPath}/${constants/* basenameOfTheKeycloakifyResourcesDir */.M}/${group})`);
-    return { fixedCssCode };
-}
-//# sourceMappingURL=replaceImportsInInlineCssCode.js.map
 // EXTERNAL MODULE: ./dist/bin/tools/getThisCodebaseRootDirPath.js
 var getThisCodebaseRootDirPath = __webpack_require__(58822);
 ;// CONCATENATED MODULE: ./dist/bin/keycloakify/generateFtl/generateFtl.js
@@ -416,11 +381,10 @@ var getThisCodebaseRootDirPath = __webpack_require__(58822);
 
 
 
-
 (0,assert.assert)();
 function generateFtlFilesCodeFactory(params) {
     var _a;
-    const { themeName, cssGlobalsToDefine, indexHtmlCode, buildContext, keycloakifyVersion, themeType, fieldNames } = params;
+    const { themeName, indexHtmlCode, buildContext, keycloakifyVersion, themeType, fieldNames } = params;
     const $ = esm/* default.load */.ZP.load(indexHtmlCode);
     fix_imports_statements: {
         $("script:not([src])").each((...[, element]) => {
@@ -435,8 +399,9 @@ function generateFtlFilesCodeFactory(params) {
         $("style").each((...[, element]) => {
             const cssCode = $(element).html();
             (0,assert.assert)(cssCode !== null);
-            const { fixedCssCode } = replaceImportsInInlineCssCode({
+            const { fixedCssCode } = replaceImportsInCssCode({
                 cssCode,
+                fileRelativeDirPath: ".",
                 buildContext
             });
             $(element).text(fixedCssCode);
@@ -452,18 +417,6 @@ function generateFtlFilesCodeFactory(params) {
             }
             $(element).attr(attrName, href.replace(new RegExp(`^${((_a = buildContext.urlPathname) !== null && _a !== void 0 ? _a : "/").replace(/\//g, "\\/")}`), `\${url.resourcesPath}/${constants/* basenameOfTheKeycloakifyResourcesDir */.M}/`));
         }));
-        if (Object.keys(cssGlobalsToDefine).length !== 0) {
-            $("head").prepend([
-                "",
-                "<style>",
-                generateCssCodeToDefineGlobals({
-                    cssGlobalsToDefine,
-                    buildContext
-                }).cssCodeToPrependInHead,
-                "</style>",
-                ""
-            ].join("\n"));
-        }
     }
     //FTL is no valid html, we can't insert with cheerio, we put placeholder for injecting later.
     const kcContextDeclarationTemplateFtl = external_fs_.readFileSync((0,external_path_.join)((0,getThisCodebaseRootDirPath/* getThisCodebaseRootDirPath */.e)(), "src", "bin", "keycloakify", "generateFtl", "kcContextDeclarationTemplate.ftl"))
@@ -734,7 +687,6 @@ async function generateResourcesForMainTheme(params) {
         const { themeType } = params;
         return (0,external_path_.join)(resourcesDirPath, "theme", themeName, themeType);
     };
-    const cssGlobalsToDefine = {};
     for (const themeType of ["login", "account"]) {
         if (!buildContext.recordIsImplementedByThemeType[themeType]) {
             continue;
@@ -771,13 +723,12 @@ async function generateResourcesForMainTheme(params) {
             (0,transformCodebase/* transformCodebase */.N)({
                 srcDirPath: buildContext.projectBuildDirPath,
                 destDirPath,
-                transformSourceCode: ({ filePath, sourceCode }) => {
+                transformSourceCode: ({ filePath, fileRelativePath, sourceCode }) => {
                     if (filePath.endsWith(".css")) {
-                        const { cssGlobalsToDefine: cssGlobalsToDefineForThisFile, fixedCssCode } = replaceImportsInCssCode({
-                            cssCode: sourceCode.toString("utf8")
-                        });
-                        Object.entries(cssGlobalsToDefineForThisFile).forEach(([key, value]) => {
-                            cssGlobalsToDefine[key] = value;
+                        const { fixedCssCode } = replaceImportsInCssCode({
+                            cssCode: sourceCode.toString("utf8"),
+                            fileRelativeDirPath: (0,external_path_.dirname)(fileRelativePath),
+                            buildContext
                         });
                         return {
                             modifiedSourceCode: Buffer.from(fixedCssCode, "utf8")
@@ -800,7 +751,6 @@ async function generateResourcesForMainTheme(params) {
             themeName,
             indexHtmlCode: external_fs_.readFileSync((0,external_path_.join)(buildContext.projectBuildDirPath, "index.html"))
                 .toString("utf8"),
-            cssGlobalsToDefine,
             buildContext,
             keycloakifyVersion: (0,readThisNpmPackageVersion/* readThisNpmPackageVersion */.K)(),
             themeType,

package/bin/720.index.js

@@ -0,0 +1,243 @@
+"use strict";
+exports.id = 720;
+exports.ids = [720];
+exports.modules = {
+
+/***/ 68720:
+/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => {
+
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   "default": () => (/* binding */ wrapAnsi)
+/* harmony export */ });
+/* harmony import */ var string_width__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(10509);
+/* harmony import */ var strip_ansi__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(5505);
+/* harmony import */ var ansi_styles__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(51284);
+
+
+
+
+const ESCAPES = new Set([
+	'\u001B',
+	'\u009B',
+]);
+
+const END_CODE = 39;
+const ANSI_ESCAPE_BELL = '\u0007';
+const ANSI_CSI = '[';
+const ANSI_OSC = ']';
+const ANSI_SGR_TERMINATOR = 'm';
+const ANSI_ESCAPE_LINK = `${ANSI_OSC}8;;`;
+
+const wrapAnsiCode = code => `${ESCAPES.values().next().value}${ANSI_CSI}${code}${ANSI_SGR_TERMINATOR}`;
+const wrapAnsiHyperlink = url => `${ESCAPES.values().next().value}${ANSI_ESCAPE_LINK}${url}${ANSI_ESCAPE_BELL}`;
+
+// Calculate the length of words split on ' ', ignoring
+// the extra characters added by ansi escape codes
+const wordLengths = string => string.split(' ').map(character => (0,string_width__WEBPACK_IMPORTED_MODULE_2__/* ["default"] */ .Z)(character));
+
+// Wrap a long word across multiple rows
+// Ansi escape codes do not count towards length
+const wrapWord = (rows, word, columns) => {
+	const characters = [...word];
+
+	let isInsideEscape = false;
+	let isInsideLinkEscape = false;
+	let visible = (0,string_width__WEBPACK_IMPORTED_MODULE_2__/* ["default"] */ .Z)((0,strip_ansi__WEBPACK_IMPORTED_MODULE_0__/* ["default"] */ .Z)(rows.at(-1)));
+
+	for (const [index, character] of characters.entries()) {
+		const characterLength = (0,string_width__WEBPACK_IMPORTED_MODULE_2__/* ["default"] */ .Z)(character);
+
+		if (visible + characterLength <= columns) {
+			rows[rows.length - 1] += character;
+		} else {
+			rows.push(character);
+			visible = 0;
+		}
+
+		if (ESCAPES.has(character)) {
+			isInsideEscape = true;
+
+			const ansiEscapeLinkCandidate = characters.slice(index + 1, index + 1 + ANSI_ESCAPE_LINK.length).join('');
+			isInsideLinkEscape = ansiEscapeLinkCandidate === ANSI_ESCAPE_LINK;
+		}
+
+		if (isInsideEscape) {
+			if (isInsideLinkEscape) {
+				if (character === ANSI_ESCAPE_BELL) {
+					isInsideEscape = false;
+					isInsideLinkEscape = false;
+				}
+			} else if (character === ANSI_SGR_TERMINATOR) {
+				isInsideEscape = false;
+			}
+
+			continue;
+		}
+
+		visible += characterLength;
+
+		if (visible === columns && index < characters.length - 1) {
+			rows.push('');
+			visible = 0;
+		}
+	}
+
+	// It's possible that the last row we copy over is only
+	// ansi escape characters, handle this edge-case
+	if (!visible && rows.at(-1).length > 0 && rows.length > 1) {
+		rows[rows.length - 2] += rows.pop();
+	}
+};
+
+// Trims spaces from a string ignoring invisible sequences
+const stringVisibleTrimSpacesRight = string => {
+	const words = string.split(' ');
+	let last = words.length;
+
+	while (last > 0) {
+		if ((0,string_width__WEBPACK_IMPORTED_MODULE_2__/* ["default"] */ .Z)(words[last - 1]) > 0) {
+			break;
+		}
+
+		last--;
+	}
+
+	if (last === words.length) {
+		return string;
+	}
+
+	return words.slice(0, last).join(' ') + words.slice(last).join('');
+};
+
+// The wrap-ansi module can be invoked in either 'hard' or 'soft' wrap mode.
+//
+// 'hard' will never allow a string to take up more than columns characters.
+//
+// 'soft' allows long words to expand past the column length.
+const exec = (string, columns, options = {}) => {
+	if (options.trim !== false && string.trim() === '') {
+		return '';
+	}
+
+	let returnValue = '';
+	let escapeCode;
+	let escapeUrl;
+
+	const lengths = wordLengths(string);
+	let rows = [''];
+
+	for (const [index, word] of string.split(' ').entries()) {
+		if (options.trim !== false) {
+			rows[rows.length - 1] = rows.at(-1).trimStart();
+		}
+
+		let rowLength = (0,string_width__WEBPACK_IMPORTED_MODULE_2__/* ["default"] */ .Z)(rows.at(-1));
+
+		if (index !== 0) {
+			if (rowLength >= columns && (options.wordWrap === false || options.trim === false)) {
+				// If we start with a new word but the current row length equals the length of the columns, add a new row
+				rows.push('');
+				rowLength = 0;
+			}
+
+			if (rowLength > 0 || options.trim === false) {
+				rows[rows.length - 1] += ' ';
+				rowLength++;
+			}
+		}
+
+		// In 'hard' wrap mode, the length of a line is never allowed to extend past 'columns'
+		if (options.hard && lengths[index] > columns) {
+			const remainingColumns = (columns - rowLength);
+			const breaksStartingThisLine = 1 + Math.floor((lengths[index] - remainingColumns - 1) / columns);
+			const breaksStartingNextLine = Math.floor((lengths[index] - 1) / columns);
+			if (breaksStartingNextLine < breaksStartingThisLine) {
+				rows.push('');
+			}
+
+			wrapWord(rows, word, columns);
+			continue;
+		}
+
+		if (rowLength + lengths[index] > columns && rowLength > 0 && lengths[index] > 0) {
+			if (options.wordWrap === false && rowLength < columns) {
+				wrapWord(rows, word, columns);
+				continue;
+			}
+
+			rows.push('');
+		}
+
+		if (rowLength + lengths[index] > columns && options.wordWrap === false) {
+			wrapWord(rows, word, columns);
+			continue;
+		}
+
+		rows[rows.length - 1] += word;
+	}
+
+	if (options.trim !== false) {
+		rows = rows.map(row => stringVisibleTrimSpacesRight(row));
+	}
+
+	const preString = rows.join('\n');
+	const pre = [...preString];
+
+	// We need to keep a separate index as `String#slice()` works on Unicode code units, while `pre` is an array of codepoints.
+	let preStringIndex = 0;
+
+	for (const [index, character] of pre.entries()) {
+		returnValue += character;
+
+		if (ESCAPES.has(character)) {
+			const {groups} = new RegExp(`(?:\\${ANSI_CSI}(?<code>\\d+)m|\\${ANSI_ESCAPE_LINK}(?<uri>.*)${ANSI_ESCAPE_BELL})`).exec(preString.slice(preStringIndex)) || {groups: {}};
+			if (groups.code !== undefined) {
+				const code = Number.parseFloat(groups.code);
+				escapeCode = code === END_CODE ? undefined : code;
+			} else if (groups.uri !== undefined) {
+				escapeUrl = groups.uri.length === 0 ? undefined : groups.uri;
+			}
+		}
+
+		const code = ansi_styles__WEBPACK_IMPORTED_MODULE_1__/* ["default"].codes.get */ .ZP.codes.get(Number(escapeCode));
+
+		if (pre[index + 1] === '\n') {
+			if (escapeUrl) {
+				returnValue += wrapAnsiHyperlink('');
+			}
+
+			if (escapeCode && code) {
+				returnValue += wrapAnsiCode(code);
+			}
+		} else if (character === '\n') {
+			if (escapeCode && code) {
+				returnValue += wrapAnsiCode(escapeCode);
+			}
+
+			if (escapeUrl) {
+				returnValue += wrapAnsiHyperlink(escapeUrl);
+			}
+		}
+
+		preStringIndex += character.length;
+	}
+
+	return returnValue;
+};
+
+// For each newline, invoke the method separately
+function wrapAnsi(string, columns, options) {
+	return String(string)
+		.normalize()
+		.replaceAll('\r\n', '\n')
+		.split('\n')
+		.map(line => exec(line, columns, options))
+		.join('\n');
+}
+
+
+/***/ })
+
+};
+;

package/bin/877.index.js

@@ -0,0 +1,275 @@
+"use strict";
+exports.id = 877;
+exports.ids = [877];
+exports.modules = {
+
+/***/ 85877:
+/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => {
+
+// ESM COMPAT FLAG
+__webpack_require__.r(__webpack_exports__);
+
+// EXPORTS
+__webpack_require__.d(__webpack_exports__, {
+  "default": () => (/* binding */ cliTruncate)
+});
+
+;// CONCATENATED MODULE: ./node_modules/listr2/node_modules/is-fullwidth-code-point/index.js
+/* eslint-disable yoda */
+
+function isFullwidthCodePoint(codePoint) {
+	if (!Number.isInteger(codePoint)) {
+		return false;
+	}
+
+	// Code points are derived from:
+	// https://unicode.org/Public/UNIDATA/EastAsianWidth.txt
+	return codePoint >= 0x1100 && (
+		codePoint <= 0x115F || // Hangul Jamo
+		codePoint === 0x2329 || // LEFT-POINTING ANGLE BRACKET
+		codePoint === 0x232A || // RIGHT-POINTING ANGLE BRACKET
+		// CJK Radicals Supplement .. Enclosed CJK Letters and Months
+		(0x2E80 <= codePoint && codePoint <= 0x3247 && codePoint !== 0x303F) ||
+		// Enclosed CJK Letters and Months .. CJK Unified Ideographs Extension A
+		(0x3250 <= codePoint && codePoint <= 0x4DBF) ||
+		// CJK Unified Ideographs .. Yi Radicals
+		(0x4E00 <= codePoint && codePoint <= 0xA4C6) ||
+		// Hangul Jamo Extended-A
+		(0xA960 <= codePoint && codePoint <= 0xA97C) ||
+		// Hangul Syllables
+		(0xAC00 <= codePoint && codePoint <= 0xD7A3) ||
+		// CJK Compatibility Ideographs
+		(0xF900 <= codePoint && codePoint <= 0xFAFF) ||
+		// Vertical Forms
+		(0xFE10 <= codePoint && codePoint <= 0xFE19) ||
+		// CJK Compatibility Forms .. Small Form Variants
+		(0xFE30 <= codePoint && codePoint <= 0xFE6B) ||
+		// Halfwidth and Fullwidth Forms
+		(0xFF01 <= codePoint && codePoint <= 0xFF60) ||
+		(0xFFE0 <= codePoint && codePoint <= 0xFFE6) ||
+		// Kana Supplement
+		(0x1B000 <= codePoint && codePoint <= 0x1B001) ||
+		// Enclosed Ideographic Supplement
+		(0x1F200 <= codePoint && codePoint <= 0x1F251) ||
+		// CJK Unified Ideographs Extension B .. Tertiary Ideographic Plane
+		(0x20000 <= codePoint && codePoint <= 0x3FFFD)
+	);
+}
+
+// EXTERNAL MODULE: ./node_modules/listr2/node_modules/ansi-styles/index.js
+var ansi_styles = __webpack_require__(51284);
+;// CONCATENATED MODULE: ./node_modules/listr2/node_modules/slice-ansi/index.js
+
+
+
+const astralRegex = /^[\uD800-\uDBFF][\uDC00-\uDFFF]$/;
+
+const ESCAPES = [
+	'\u001B',
+	'\u009B'
+];
+
+const wrapAnsi = code => `${ESCAPES[0]}[${code}m`;
+
+const checkAnsi = (ansiCodes, isEscapes, endAnsiCode) => {
+	let output = [];
+	ansiCodes = [...ansiCodes];
+
+	for (let ansiCode of ansiCodes) {
+		const ansiCodeOrigin = ansiCode;
+		if (ansiCode.includes(';')) {
+			ansiCode = ansiCode.split(';')[0][0] + '0';
+		}
+
+		const item = ansi_styles/* default.codes.get */.ZP.codes.get(Number.parseInt(ansiCode, 10));
+		if (item) {
+			const indexEscape = ansiCodes.indexOf(item.toString());
+			if (indexEscape === -1) {
+				output.push(wrapAnsi(isEscapes ? item : ansiCodeOrigin));
+			} else {
+				ansiCodes.splice(indexEscape, 1);
+			}
+		} else if (isEscapes) {
+			output.push(wrapAnsi(0));
+			break;
+		} else {
+			output.push(wrapAnsi(ansiCodeOrigin));
+		}
+	}
+
+	if (isEscapes) {
+		output = output.filter((element, index) => output.indexOf(element) === index);
+
+		if (endAnsiCode !== undefined) {
+			const fistEscapeCode = wrapAnsi(ansi_styles/* default.codes.get */.ZP.codes.get(Number.parseInt(endAnsiCode, 10)));
+			// TODO: Remove the use of `.reduce` here.
+			// eslint-disable-next-line unicorn/no-array-reduce
+			output = output.reduce((current, next) => next === fistEscapeCode ? [next, ...current] : [...current, next], []);
+		}
+	}
+
+	return output.join('');
+};
+
+function sliceAnsi(string, begin, end) {
+	const characters = [...string];
+	const ansiCodes = [];
+
+	let stringEnd = typeof end === 'number' ? end : characters.length;
+	let isInsideEscape = false;
+	let ansiCode;
+	let visible = 0;
+	let output = '';
+
+	for (const [index, character] of characters.entries()) {
+		let leftEscape = false;
+
+		if (ESCAPES.includes(character)) {
+			const code = /\d[^m]*/.exec(string.slice(index, index + 18));
+			ansiCode = code && code.length > 0 ? code[0] : undefined;
+
+			if (visible < stringEnd) {
+				isInsideEscape = true;
+
+				if (ansiCode !== undefined) {
+					ansiCodes.push(ansiCode);
+				}
+			}
+		} else if (isInsideEscape && character === 'm') {
+			isInsideEscape = false;
+			leftEscape = true;
+		}
+
+		if (!isInsideEscape && !leftEscape) {
+			visible++;
+		}
+
+		if (!astralRegex.test(character) && isFullwidthCodePoint(character.codePointAt())) {
+			visible++;
+
+			if (typeof end !== 'number') {
+				stringEnd++;
+			}
+		}
+
+		if (visible > begin && visible <= stringEnd) {
+			output += character;
+		} else if (visible === begin && !isInsideEscape && ansiCode !== undefined) {
+			output = checkAnsi(ansiCodes);
+		} else if (visible >= stringEnd) {
+			output += checkAnsi(ansiCodes, true, ansiCode);
+			break;
+		}
+	}
+
+	return output;
+}
+
+// EXTERNAL MODULE: ./node_modules/listr2/node_modules/string-width/index.js
+var string_width = __webpack_require__(10509);
+;// CONCATENATED MODULE: ./node_modules/listr2/node_modules/cli-truncate/index.js
+
+
+
+function getIndexOfNearestSpace(string, wantedIndex, shouldSearchRight) {
+	if (string.charAt(wantedIndex) === ' ') {
+		return wantedIndex;
+	}
+
+	const direction = shouldSearchRight ? 1 : -1;
+
+	for (let index = 0; index <= 3; index++) {
+		const finalIndex = wantedIndex + (index * direction);
+		if (string.charAt(finalIndex) === ' ') {
+			return finalIndex;
+		}
+	}
+
+	return wantedIndex;
+}
+
+function cliTruncate(text, columns, options = {}) {
+	const {
+		position = 'end',
+		space = false,
+		preferTruncationOnSpace = false,
+	} = options;
+
+	let {truncationCharacter = '…'} = options;
+
+	if (typeof text !== 'string') {
+		throw new TypeError(`Expected \`input\` to be a string, got ${typeof text}`);
+	}
+
+	if (typeof columns !== 'number') {
+		throw new TypeError(`Expected \`columns\` to be a number, got ${typeof columns}`);
+	}
+
+	if (columns < 1) {
+		return '';
+	}
+
+	if (columns === 1) {
+		return truncationCharacter;
+	}
+
+	const length = (0,string_width/* default */.Z)(text);
+
+	if (length <= columns) {
+		return text;
+	}
+
+	if (position === 'start') {
+		if (preferTruncationOnSpace) {
+			const nearestSpace = getIndexOfNearestSpace(text, length - columns + 1, true);
+			return truncationCharacter + sliceAnsi(text, nearestSpace, length).trim();
+		}
+
+		if (space === true) {
+			truncationCharacter += ' ';
+		}
+
+		return truncationCharacter + sliceAnsi(text, length - columns + (0,string_width/* default */.Z)(truncationCharacter), length);
+	}
+
+	if (position === 'middle') {
+		if (space === true) {
+			truncationCharacter = ` ${truncationCharacter} `;
+		}
+
+		const half = Math.floor(columns / 2);
+
+		if (preferTruncationOnSpace) {
+			const spaceNearFirstBreakPoint = getIndexOfNearestSpace(text, half);
+			const spaceNearSecondBreakPoint = getIndexOfNearestSpace(text, length - (columns - half) + 1, true);
+			return sliceAnsi(text, 0, spaceNearFirstBreakPoint) + truncationCharacter + sliceAnsi(text, spaceNearSecondBreakPoint, length).trim();
+		}
+
+		return (
+			sliceAnsi(text, 0, half)
+				+ truncationCharacter
+				+ sliceAnsi(text, length - (columns - half) + (0,string_width/* default */.Z)(truncationCharacter), length)
+		);
+	}
+
+	if (position === 'end') {
+		if (preferTruncationOnSpace) {
+			const nearestSpace = getIndexOfNearestSpace(text, columns - 1);
+			return sliceAnsi(text, 0, nearestSpace) + truncationCharacter;
+		}
+
+		if (space === true) {
+			truncationCharacter = ` ${truncationCharacter}`;
+		}
+
+		return sliceAnsi(text, 0, columns - (0,string_width/* default */.Z)(truncationCharacter)) + truncationCharacter;
+	}
+
+	throw new Error(`Expected \`options.position\` to be either \`start\`, \`middle\` or \`end\`, got ${position}`);
+}
+
+
+/***/ })
+
+};
+;