keycloakify 10.0.0-rc.2 → 10.0.0-rc.21

package/bin/420.index.js

@@ -0,0 +1,508 @@
+"use strict";
+exports.id = 420;
+exports.ids = [420];
+exports.modules = {
+
+/***/ 32420:
+/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => {
+
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   "default": () => (/* binding */ cliTruncate)
+/* harmony export */ });
+/* harmony import */ var slice_ansi__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(32470);
+/* harmony import */ var string_width__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(10509);
+
+
+
+function getIndexOfNearestSpace(string, wantedIndex, shouldSearchRight) {
+	if (string.charAt(wantedIndex) === ' ') {
+		return wantedIndex;
+	}
+
+	for (let index = 1; index <= 3; index++) {
+		if (shouldSearchRight) {
+			if (string.charAt(wantedIndex + index) === ' ') {
+				return wantedIndex + index;
+			}
+		} else if (string.charAt(wantedIndex - index) === ' ') {
+			return wantedIndex - index;
+		}
+	}
+
+	return wantedIndex;
+}
+
+function cliTruncate(text, columns, options) {
+	options = {
+		position: 'end',
+		preferTruncationOnSpace: false,
+		truncationCharacter: '…',
+		...options,
+	};
+
+	const {position, space, preferTruncationOnSpace} = 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__WEBPACK_IMPORTED_MODULE_1__/* ["default"] */ .Z)(text);
+
+	if (length <= columns) {
+		return text;
+	}
+
+	if (position === 'start') {
+		if (preferTruncationOnSpace) {
+			const nearestSpace = getIndexOfNearestSpace(text, length - columns + 1, true);
+			return truncationCharacter + (0,slice_ansi__WEBPACK_IMPORTED_MODULE_0__/* ["default"] */ .Z)(text, nearestSpace, length).trim();
+		}
+
+		if (space === true) {
+			truncationCharacter += ' ';
+		}
+
+		return truncationCharacter + (0,slice_ansi__WEBPACK_IMPORTED_MODULE_0__/* ["default"] */ .Z)(text, length - columns + (0,string_width__WEBPACK_IMPORTED_MODULE_1__/* ["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 (0,slice_ansi__WEBPACK_IMPORTED_MODULE_0__/* ["default"] */ .Z)(text, 0, spaceNearFirstBreakPoint) + truncationCharacter + (0,slice_ansi__WEBPACK_IMPORTED_MODULE_0__/* ["default"] */ .Z)(text, spaceNearSecondBreakPoint, length).trim();
+		}
+
+		return (
+			(0,slice_ansi__WEBPACK_IMPORTED_MODULE_0__/* ["default"] */ .Z)(text, 0, half)
+				+ truncationCharacter
+				+ (0,slice_ansi__WEBPACK_IMPORTED_MODULE_0__/* ["default"] */ .Z)(text, length - (columns - half) + (0,string_width__WEBPACK_IMPORTED_MODULE_1__/* ["default"] */ .Z)(truncationCharacter), length)
+		);
+	}
+
+	if (position === 'end') {
+		if (preferTruncationOnSpace) {
+			const nearestSpace = getIndexOfNearestSpace(text, columns - 1);
+			return (0,slice_ansi__WEBPACK_IMPORTED_MODULE_0__/* ["default"] */ .Z)(text, 0, nearestSpace) + truncationCharacter;
+		}
+
+		if (space === true) {
+			truncationCharacter = ` ${truncationCharacter}`;
+		}
+
+		return (0,slice_ansi__WEBPACK_IMPORTED_MODULE_0__/* ["default"] */ .Z)(text, 0, columns - (0,string_width__WEBPACK_IMPORTED_MODULE_1__/* ["default"] */ .Z)(truncationCharacter)) + truncationCharacter;
+	}
+
+	throw new Error(`Expected \`options.position\` to be either \`start\`, \`middle\` or \`end\`, got ${position}`);
+}
+
+
+/***/ }),
+
+/***/ 32470:
+/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => {
+
+
+// EXPORTS
+__webpack_require__.d(__webpack_exports__, {
+  "Z": () => (/* binding */ sliceAnsi)
+});
+
+;// CONCATENATED MODULE: ./node_modules/slice-ansi/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)
+	);
+}
+
+;// CONCATENATED MODULE: ./node_modules/slice-ansi/node_modules/ansi-styles/index.js
+const ANSI_BACKGROUND_OFFSET = 10;
+
+const wrapAnsi16 = (offset = 0) => code => `\u001B[${code + offset}m`;
+
+const wrapAnsi256 = (offset = 0) => code => `\u001B[${38 + offset};5;${code}m`;
+
+const wrapAnsi16m = (offset = 0) => (red, green, blue) => `\u001B[${38 + offset};2;${red};${green};${blue}m`;
+
+const styles = {
+	modifier: {
+		reset: [0, 0],
+		// 21 isn't widely supported and 22 does the same thing
+		bold: [1, 22],
+		dim: [2, 22],
+		italic: [3, 23],
+		underline: [4, 24],
+		overline: [53, 55],
+		inverse: [7, 27],
+		hidden: [8, 28],
+		strikethrough: [9, 29],
+	},
+	color: {
+		black: [30, 39],
+		red: [31, 39],
+		green: [32, 39],
+		yellow: [33, 39],
+		blue: [34, 39],
+		magenta: [35, 39],
+		cyan: [36, 39],
+		white: [37, 39],
+
+		// Bright color
+		blackBright: [90, 39],
+		gray: [90, 39], // Alias of `blackBright`
+		grey: [90, 39], // Alias of `blackBright`
+		redBright: [91, 39],
+		greenBright: [92, 39],
+		yellowBright: [93, 39],
+		blueBright: [94, 39],
+		magentaBright: [95, 39],
+		cyanBright: [96, 39],
+		whiteBright: [97, 39],
+	},
+	bgColor: {
+		bgBlack: [40, 49],
+		bgRed: [41, 49],
+		bgGreen: [42, 49],
+		bgYellow: [43, 49],
+		bgBlue: [44, 49],
+		bgMagenta: [45, 49],
+		bgCyan: [46, 49],
+		bgWhite: [47, 49],
+
+		// Bright color
+		bgBlackBright: [100, 49],
+		bgGray: [100, 49], // Alias of `bgBlackBright`
+		bgGrey: [100, 49], // Alias of `bgBlackBright`
+		bgRedBright: [101, 49],
+		bgGreenBright: [102, 49],
+		bgYellowBright: [103, 49],
+		bgBlueBright: [104, 49],
+		bgMagentaBright: [105, 49],
+		bgCyanBright: [106, 49],
+		bgWhiteBright: [107, 49],
+	},
+};
+
+const modifierNames = Object.keys(styles.modifier);
+const foregroundColorNames = Object.keys(styles.color);
+const backgroundColorNames = Object.keys(styles.bgColor);
+const colorNames = [...foregroundColorNames, ...backgroundColorNames];
+
+function assembleStyles() {
+	const codes = new Map();
+
+	for (const [groupName, group] of Object.entries(styles)) {
+		for (const [styleName, style] of Object.entries(group)) {
+			styles[styleName] = {
+				open: `\u001B[${style[0]}m`,
+				close: `\u001B[${style[1]}m`,
+			};
+
+			group[styleName] = styles[styleName];
+
+			codes.set(style[0], style[1]);
+		}
+
+		Object.defineProperty(styles, groupName, {
+			value: group,
+			enumerable: false,
+		});
+	}
+
+	Object.defineProperty(styles, 'codes', {
+		value: codes,
+		enumerable: false,
+	});
+
+	styles.color.close = '\u001B[39m';
+	styles.bgColor.close = '\u001B[49m';
+
+	styles.color.ansi = wrapAnsi16();
+	styles.color.ansi256 = wrapAnsi256();
+	styles.color.ansi16m = wrapAnsi16m();
+	styles.bgColor.ansi = wrapAnsi16(ANSI_BACKGROUND_OFFSET);
+	styles.bgColor.ansi256 = wrapAnsi256(ANSI_BACKGROUND_OFFSET);
+	styles.bgColor.ansi16m = wrapAnsi16m(ANSI_BACKGROUND_OFFSET);
+
+	// From https://github.com/Qix-/color-convert/blob/3f0e0d4e92e235796ccb17f6e85c72094a651f49/conversions.js
+	Object.defineProperties(styles, {
+		rgbToAnsi256: {
+			value: (red, green, blue) => {
+				// We use the extended greyscale palette here, with the exception of
+				// black and white. normal palette only has 4 greyscale shades.
+				if (red === green && green === blue) {
+					if (red < 8) {
+						return 16;
+					}
+
+					if (red > 248) {
+						return 231;
+					}
+
+					return Math.round(((red - 8) / 247) * 24) + 232;
+				}
+
+				return 16
+					+ (36 * Math.round(red / 255 * 5))
+					+ (6 * Math.round(green / 255 * 5))
+					+ Math.round(blue / 255 * 5);
+			},
+			enumerable: false,
+		},
+		hexToRgb: {
+			value: hex => {
+				const matches = /[a-f\d]{6}|[a-f\d]{3}/i.exec(hex.toString(16));
+				if (!matches) {
+					return [0, 0, 0];
+				}
+
+				let [colorString] = matches;
+
+				if (colorString.length === 3) {
+					colorString = [...colorString].map(character => character + character).join('');
+				}
+
+				const integer = Number.parseInt(colorString, 16);
+
+				return [
+					/* eslint-disable no-bitwise */
+					(integer >> 16) & 0xFF,
+					(integer >> 8) & 0xFF,
+					integer & 0xFF,
+					/* eslint-enable no-bitwise */
+				];
+			},
+			enumerable: false,
+		},
+		hexToAnsi256: {
+			value: hex => styles.rgbToAnsi256(...styles.hexToRgb(hex)),
+			enumerable: false,
+		},
+		ansi256ToAnsi: {
+			value: code => {
+				if (code < 8) {
+					return 30 + code;
+				}
+
+				if (code < 16) {
+					return 90 + (code - 8);
+				}
+
+				let red;
+				let green;
+				let blue;
+
+				if (code >= 232) {
+					red = (((code - 232) * 10) + 8) / 255;
+					green = red;
+					blue = red;
+				} else {
+					code -= 16;
+
+					const remainder = code % 36;
+
+					red = Math.floor(code / 36) / 5;
+					green = Math.floor(remainder / 6) / 5;
+					blue = (remainder % 6) / 5;
+				}
+
+				const value = Math.max(red, green, blue) * 2;
+
+				if (value === 0) {
+					return 30;
+				}
+
+				// eslint-disable-next-line no-bitwise
+				let result = 30 + ((Math.round(blue) << 2) | (Math.round(green) << 1) | Math.round(red));
+
+				if (value === 2) {
+					result += 60;
+				}
+
+				return result;
+			},
+			enumerable: false,
+		},
+		rgbToAnsi: {
+			value: (red, green, blue) => styles.ansi256ToAnsi(styles.rgbToAnsi256(red, green, blue)),
+			enumerable: false,
+		},
+		hexToAnsi: {
+			value: hex => styles.ansi256ToAnsi(styles.hexToAnsi256(hex)),
+			enumerable: false,
+		},
+	});
+
+	return styles;
+}
+
+const ansiStyles = assembleStyles();
+
+/* harmony default export */ const ansi_styles = (ansiStyles);
+
+;// CONCATENATED MODULE: ./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.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.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;
+}
+
+
+/***/ })
+
+};
+;