@rzl-zone/utils-js 3.12.0 → 3.12.1-beta.1

package/dist/assertIsBoolean-DR1SaXPD.js

@@ -0,0 +1,1073 @@
+/*!
+* ========================================================================
+*  @rzl-zone/utils-js
+* ------------------------------------------------------------------------
+*  Version: `3.12.1-beta.1`
+*  Author: `Rizalvin Dwiky <rizalvindwiky@gmail.com>`
+*  Repository: `https://github.com/rzl-zone/rzl-zone/tree/main/packages/utils-js`
+* ========================================================================
+*/
+const isBoolean = (value) => {
+	return typeof value === "boolean";
+};
+const isFunction = (value) => {
+	return typeof value === "function";
+};
+function isNil(value) {
+	return value == null;
+}
+function isArray(value) {
+	return Array.isArray(value);
+}
+function isObject(value) {
+	return typeof value === "object" && !isNil(value) && !isArray(value);
+}
+function isPlainObject(value) {
+	if (!isObject(value)) return false;
+	const proto = Object.getPrototypeOf(value);
+	return proto === Object.prototype || proto === null;
+}
+const isString = (value) => {
+	return typeof value === "string";
+};
+function isNumberObject(value) {
+	return isObject(value) && Object.prototype.toString.call(value) === "[object Number]";
+}
+function isNaN(value) {
+	return typeof value === "number" ? Number.isNaN(value) : isNumberObject(value) && Number.isNaN(value.valueOf());
+}
+const isNull = (val) => val === null;
+function assertIsPlainObject(value, options = {}) {
+	if (isPlainObject(value)) return;
+	resolveErrorMessageAssertions({
+		value,
+		options,
+		requiredValidType: "plain object"
+	});
+}
+const isNumber = (value, options = {}) => {
+	assertIsPlainObject(options, { message: ({ currentType, validType }) => `Second parameter (\`options\`) must be of type \`${validType}\`, but received: \`${currentType}\`.` });
+	const includeNaN = isPlainObject(options) && isBoolean(options.includeNaN) ? options.includeNaN : false;
+	assertIsBoolean(includeNaN, { message: ({ currentType, validType }) => `Parameter \`includeNaN\` property of the \`options\` (second parameter) must be of type \`${validType}\`, but received: \`${currentType}\`.` });
+	const aNumber = typeof value === "number";
+	return includeNaN ? aNumber : aNumber && !Number.isNaN(value);
+};
+const isSymbol = (value) => {
+	return typeof value === "symbol";
+};
+const isUndefined = (value) => {
+	return typeof value === "undefined";
+};
+function isObjectOrArray(value) {
+	return isArray(value) || isObject(value);
+}
+function hasOwnProp(obj, key, options = {}) {
+	if (!isString(obj) && !isObjectOrArray(obj) && !isFunction(obj)) return false;
+	assertIsPlainObject(options, { message: ({ currentType, validType }) => `Third parameter (\`options\`) must be of type \`${validType}\`, but received: \`${currentType}\`.` });
+	const discardUndefined = options.discardUndefined === void 0 ? true : options.discardUndefined;
+	const discardNull = options.discardNull === void 0 ? false : options.discardNull;
+	assertIsBoolean(discardUndefined, { message: ({ currentType, validType }) => `Parameter \`discardUndefined\` property of the \`options\` (third parameter) must be of type \`${validType}\`, but received: \`${currentType}\`.` });
+	assertIsBoolean(discardNull, { message: ({ currentType, validType }) => `Parameter \`discardNull\` property of the \`options\` (third parameter) must be of type \`${validType}\`, but received: \`${currentType}\`.` });
+	const path = [];
+	if (isString(key) && key.trim().length > 0 || isNumber(key, { includeNaN: true })) (isNumber(key, { includeNaN: true }) ? String(key) : key).split(".").forEach((k) => {
+		const bracketMatch = k.match(/^\[(\d+)\]$/);
+		const symbolMatch = k.match(/^Symbol\((.+)\)$/);
+		if (bracketMatch) path.push(Number(bracketMatch[1]));
+		else if (symbolMatch) path.push(Symbol.for(symbolMatch[1]));
+		else if (!isNaN(Number(k))) path.push(Number(k));
+		else path.push(k);
+	});
+	else if (isSymbol(key)) path.push(key);
+	else return false;
+	let current = isString(obj) && obj.trim().length > 0 ? Object(obj) : obj;
+	for (const k of path) if (isString(k) && k.trim().length > 0 || isNumber(k, { includeNaN: true })) {
+		if (isNull(current) || !Object.prototype.hasOwnProperty.call(current, k)) return false;
+		current = current[k];
+	} else if (isSymbol(k)) {
+		if (isNull(current) || typeof current !== "object" && !isFunction(current)) return false;
+		const matched = Object.getOwnPropertySymbols(current).find((s) => s === k || s.description === k.description);
+		if (!matched) return false;
+		current = current[matched];
+	} else return false;
+	if (discardUndefined && isUndefined(current)) return false;
+	if (discardNull && isNull(current)) return false;
+	return true;
+}
+const isNonEmptyString = (value, options = {}) => {
+	if (!isString(value)) return false;
+	assertIsPlainObject(options, { message: ({ currentType, validType }) => `Second parameter (\`options\`) must be of type \`${validType}\`, but received: \`${currentType}\`.` });
+	const trim = hasOwnProp(options, "trim") ? options.trim : true;
+	assertIsBoolean(trim, { message: ({ currentType, validType }) => `Parameter \`trim\` property of the \`options\` (second parameter) must be of type \`${validType}\`, but received: \`${currentType}\`.` });
+	return (trim ? value.trim() : value).length > 0;
+};
+const isError = (error) => {
+	return Object.prototype.toString.call(error) === "[object Error]" || error instanceof Error;
+};
+const isBuffer = (value) => {
+	return typeof Buffer !== "undefined" && typeof Buffer.isBuffer === "function" && Buffer.isBuffer(value);
+};
+function isStringObject(value) {
+	return isObject(value) && Object.prototype.toString.call(value) === "[object String]";
+}
+function isBooleanObject(value) {
+	return isObject(value) && Object.prototype.toString.call(value) === "[object Boolean]";
+}
+function isInfinityNumber(value) {
+	if (typeof value === "number" || isNumberObject(value)) {
+		const num = Number(value);
+		return num === Infinity || num === -Infinity;
+	}
+	return false;
+}
+function isNonEmptyArray(value) {
+	return Array.isArray(value) && value.length > 0;
+}
+function isSet(value) {
+	return Object.prototype.toString.call(value) === "[object Set]" || value instanceof Set;
+}
+const validateCaseInputWordsCase = (input) => {
+	let result = "";
+	if (isArray(input)) result = input.map((x) => isNonEmptyString(x) ? x.trim() : "").filter((x) => x.length).join("-");
+	else if (isNonEmptyString(input)) result = input.trim();
+	return result.split(/[^\p{L}\p{N}]+/u).filter(Boolean);
+};
+const validateCaseIgnoreWordsCase = (ignoreWord) => {
+	const result = /* @__PURE__ */ new Set([]);
+	const normalizeWord = (word) => word.trim().split(/[^\p{L}\p{N}]+/u).filter(Boolean).join("");
+	if (isNonEmptyString(ignoreWord)) {
+		const clean = normalizeWord(ignoreWord);
+		if (clean) result.add(clean);
+	}
+	if (isNonEmptyArray(ignoreWord)) ignoreWord.forEach((w) => {
+		if (isNonEmptyString(w)) {
+			const clean = normalizeWord(w);
+			if (clean) result.add(clean);
+		}
+	});
+	if (isSet(ignoreWord)) ignoreWord.forEach((w) => {
+		if (isNonEmptyString(w)) {
+			const clean = normalizeWord(w);
+			if (clean) result.add(clean);
+		}
+	});
+	return result;
+};
+const slugify = (input, ignoreWord) => {
+	if (!isNonEmptyArray(input) && !isNonEmptyString(input)) return "";
+	const wordsValidated = validateCaseInputWordsCase(input);
+	const ignoreWordsValidated = validateCaseIgnoreWordsCase(ignoreWord);
+	return wordsValidated.map((word) => {
+		if (ignoreWordsValidated.has(word)) return word;
+		return word.toLowerCase();
+	}).join("-").replace(/^-+|-+$/g, "");
+};
+const toDotCase = (input, ignoreWord) => {
+	if (!isNonEmptyArray(input) && !isNonEmptyString(input)) return "";
+	const wordsValidated = validateCaseInputWordsCase(input);
+	const ignoreWordsValidated = validateCaseIgnoreWordsCase(ignoreWord);
+	return wordsValidated.map((word) => {
+		if (ignoreWordsValidated.has(word)) return word;
+		return word.toLowerCase();
+	}).join(".");
+};
+const toCamelCase = (input, ignoreWord) => {
+	if (!isNonEmptyArray(input) && !isNonEmptyString(input)) return "";
+	const wordsValidated = validateCaseInputWordsCase(input);
+	const ignoreWordsValidated = validateCaseIgnoreWordsCase(ignoreWord);
+	return wordsValidated.map((word, index) => {
+		if (ignoreWordsValidated.has(word)) return word;
+		return index === 0 ? word.toLowerCase() : word.charAt(0).toUpperCase() + word.slice(1).toLowerCase();
+	}).join("");
+};
+const toKebabCase = (input, ignoreWord) => {
+	if (!isNonEmptyArray(input) && !isNonEmptyString(input)) return "";
+	const wordsValidated = validateCaseInputWordsCase(input);
+	const ignoreWordsValidated = validateCaseIgnoreWordsCase(ignoreWord);
+	return wordsValidated.map((word) => {
+		if (ignoreWordsValidated.has(word)) return word;
+		return word.toLowerCase();
+	}).join("-");
+};
+const toSnakeCase = (input, ignoreWord) => {
+	if (!isNonEmptyArray(input) && !isNonEmptyString(input)) return "";
+	const wordsValidated = validateCaseInputWordsCase(input);
+	const ignoreWordsValidated = validateCaseIgnoreWordsCase(ignoreWord);
+	return wordsValidated.map((word) => {
+		if (ignoreWordsValidated.has(word)) return word;
+		return word.toLowerCase();
+	}).join("_");
+};
+const toLowerCase = (input, ignoreWord) => {
+	if (!isNonEmptyArray(input) && !isNonEmptyString(input)) return "";
+	const wordsValidated = validateCaseInputWordsCase(input);
+	const ignoreWordsValidated = validateCaseIgnoreWordsCase(ignoreWord);
+	return wordsValidated.map((word) => {
+		if (ignoreWordsValidated.has(word)) return word;
+		return word.toLowerCase();
+	}).join(" ");
+};
+const toPascalCase = (input, ignoreWord) => {
+	if (!isNonEmptyArray(input) && !isNonEmptyString(input)) return "";
+	const wordsValidated = validateCaseInputWordsCase(input);
+	const ignoreWordsValidated = validateCaseIgnoreWordsCase(ignoreWord);
+	return wordsValidated.map((word) => {
+		if (ignoreWordsValidated.has(word)) return word;
+		return word.charAt(0).toUpperCase() + word.slice(1).toLowerCase();
+	}).join("");
+};
+const toPascalCaseSpace = (input, ignoreWord) => {
+	if (!isNonEmptyArray(input) && !isNonEmptyString(input)) return "";
+	const wordsValidated = validateCaseInputWordsCase(input);
+	const ignoreWordsValidated = validateCaseIgnoreWordsCase(ignoreWord);
+	return wordsValidated.map((word) => {
+		if (ignoreWordsValidated.has(word)) return word;
+		return word.charAt(0).toUpperCase() + word.slice(1).toLowerCase();
+	}).join(" ");
+};
+var PreciseType = class PreciseType {
+	static FIXES_RAW = Object.freeze({
+		string: "String",
+		number: "Number",
+		boolean: "Boolean",
+		bigint: "Bigint",
+		symbol: "Symbol",
+		undefined: "Undefined",
+		null: "Null",
+		regexp: "Reg Exp",
+		reflect: "Reflect",
+		proxy: "Proxy",
+		atomics: "Atomics",
+		array: "Array",
+		object: "Object",
+		function: "Function",
+		arguments: "Arguments",
+		asyncfunction: "Async Function",
+		generatorfunction: "Generator Function",
+		asyncgeneratorfunction: "Async Generator Function",
+		generator: "Generator",
+		promise: "Promise",
+		evalerror: "Eval Error",
+		rangeerror: "Range Error",
+		referenceerror: "Reference Error",
+		syntaxerror: "Syntax Error",
+		typeerror: "Type Error",
+		urierror: "URI Error",
+		aggregateerror: "Aggregate Error",
+		error: "Error",
+		int8array: "Int 8 Array",
+		uint8array: "Uint 8 Array",
+		uint8clampedarray: "Uint 8 Clamped Array",
+		int16array: "Int 16 Array",
+		uint16array: "Uint 16 Array",
+		int32array: "Int 32 Array",
+		uint32array: "Uint 32 Array",
+		float32array: "Float 32 Array",
+		float64array: "Float 64 Array",
+		bigint64array: "Big Int 64 Array",
+		biguint64array: "Big Uint 64 Array",
+		arraybuffer: "Array Buffer",
+		sharedarraybuffer: "Shared Array Buffer",
+		dataview: "Data View",
+		arraybufferview: "Array Buffer View",
+		map: "Map",
+		set: "Set",
+		weakmap: "Weak Map",
+		weakset: "Weak Set",
+		mapiterator: "Map Iterator",
+		weakmapiterator: "Weak Map Iterator",
+		setiterator: "Set Iterator",
+		weaksetiterator: "Weak Set Iterator",
+		arrayiterator: "Array Iterator",
+		stringiterator: "String Iterator",
+		asynciterator: "Async Iterator",
+		iteratorresult: "Iterator Result",
+		arrayiteratorresult: "Array Iterator Result",
+		readablestream: "Readable Stream",
+		writablestream: "Writable Stream",
+		transformstream: "Transform Stream",
+		readablestreamdefaultreader: "Readable Stream Default Reader",
+		writablestreamdefaultwriter: "Writable Stream Default Writer",
+		readablestreamdefaultcontroller: "Readable Stream Default Controller",
+		transformstreamdefaultcontroller: "Transform Stream Default Controller",
+		abortcontroller: "Abort Controller",
+		abortsignal: "Abort Signal",
+		fetch: "fetch",
+		request: "Request",
+		response: "Response",
+		headers: "Headers",
+		formdata: "FormData",
+		blob: "Blob",
+		file: "File",
+		filelist: "FileList",
+		filereader: "FileReader",
+		intl: "Intl",
+		collator: "Intl. Collator",
+		datetimeformat: "Intl. Date Time Format",
+		displaynames: "Intl. Display Names",
+		listformat: "Intl. List Format",
+		locale: "Intl. Locale",
+		numberformat: "Intl. Number Format",
+		pluralrules: "Intl. Plural Rules",
+		relativetimeformat: "Intl. Relative Time Format",
+		segmenter: "Intl. Segmenter",
+		weakref: "Weak Ref",
+		urlpattern: "URLPattern",
+		structuredclone: "structured Clone",
+		finalizationregistry: "Finalization Registry",
+		performance: "Performance",
+		performanceobserver: "Performance Observer",
+		performanceentry: "Performance Entry",
+		performancemark: "Performance Mark",
+		performancemeasure: "Performance Measure",
+		webassembly: "Web Assembly",
+		wasmmodule: "WebAssembly. Module",
+		wasminstance: "WebAssembly. Instance",
+		wasmmemory: "WebAssembly. Memory",
+		wasmtable: "WebAssembly. Table",
+		buffer: "Buffer",
+		process: "Process",
+		eventemitter: "Event Emitter",
+		stream: "Stream",
+		fs: "fs",
+		path: "path",
+		url: "URL",
+		urlsearchparams: "URL Search Params",
+		node: "Node",
+		element: "Element",
+		htmlelement: "HTML Element",
+		svgelement: "SVG Element",
+		document: "Document",
+		documentfragment: "Document Fragment",
+		shadowroot: "Shadow Root",
+		nodelist: "Node List",
+		htmlcollection: "HTML Collection",
+		resizeobserver: "Resize Observer",
+		mutationobserver: "Mutation Observer",
+		intersectionobserver: "Intersection Observer",
+		symboliterator: "Symbol. Iterator",
+		symbolasynciterator: "Symbol. Async Iterator",
+		symboltostringtag: "Symbol. To String Tag",
+		symbolspecies: "Symbol. Species",
+		symbolhasinstance: "Symbol. Has Instance",
+		symbolisconcatspreadable: "Symbol. Is Concat Spreadable",
+		symbolunscopables: "Symbol. Unscopables",
+		symbolmatch: "Symbol. Match",
+		symbolreplace: "Symbol. Replace",
+		symbolsearch: "Symbol. Search",
+		symbolsplit: "Symbol. Split",
+		symboltoprimitive: "Symbol. To Primitive",
+		symbolmatchall: "Symbol. Match All",
+		symbolarguments: "Symbol. Arguments",
+		math: "Math",
+		bigintconstructor: "Bigint Constructor",
+		numberconstructor: "Number Constructor",
+		stringconstructor: "String Constructor",
+		booleanconstructor: "Boolean Constructor",
+		formdataevent: "Form Data Event",
+		customevent: "Custom Event",
+		messagechannel: "Message Channel",
+		messageport: "Message Port",
+		messageevent: "Message Event",
+		websocket: "Web Socket",
+		eventsource: "Event Source",
+		indexeddb: "IndexedDB",
+		idbrequest: "IDB Request",
+		idbtransaction: "IDB Transaction",
+		idbobjectstore: "IDB Object Store",
+		idbcursor: "IDB Cursor",
+		localstorage: "Local Storage",
+		sessionstorage: "Session Storage",
+		navigator: "Navigator",
+		geolocation: "Geolocation",
+		clipboard: "Clipboard",
+		notification: "Notification",
+		canvas: "Canvas",
+		canvasrenderingcontext2d: "Canvas Rendering Context 2D",
+		offscreencanvas: "Offscreen Canvas",
+		webglrenderingcontext: "WebGL Rendering Context",
+		imagedata: "Image Data",
+		imagebitmap: "Image Bitmap",
+		mediastream: "Media Stream",
+		mediarecorder: "Media Recorder",
+		mediastreamtrack: "Media Stream Track",
+		audiocontext: "Audio Context",
+		audiobuffer: "Audio Buffer",
+		audioworklet: "Audio Worklet",
+		worker: "Worker",
+		sharedworker: "Shared Worker",
+		serviceworker: "Service Worker",
+		workerglobalscope: "Worker Global Scope",
+		structuredcloneerror: "Structured Clone Error",
+		transferable: "Transferable",
+		report: "Report",
+		console: "Console",
+		diagnosticreport: "Diagnostic Report",
+		domrect: "DOM Rect",
+		dompoint: "DOM Point",
+		dommatrix: "DOM Matrix",
+		domparser: "DOM Parser",
+		xmlhttprequest: "XML HTTP Request",
+		customelementregistry: "Custom Element Registry",
+		text: "Text",
+		comment: "Comment",
+		animation: "Animation",
+		documenttype: "Document Type",
+		characterdata: "Character Data",
+		animationevent: "Animation Event",
+		customemmetregistry: "Custom Emmet Registry",
+		websocketmessageevent: "WebSocket Message Event"
+	});
+	static SPECIAL_TYPE = Object.freeze([
+		"-Infinity",
+		"Infinity",
+		"NaN"
+	]);
+	static ACRONYMS = Object.freeze([
+		"URI",
+		"URL",
+		"URN",
+		"HTTP",
+		"HTTPS",
+		"FTP",
+		"FTPS",
+		"SFTP",
+		"SSH",
+		"SMTP",
+		"POP3",
+		"IMAP",
+		"WS",
+		"WSS",
+		"TCP",
+		"UDP",
+		"IP",
+		"ICMP",
+		"ARP",
+		"RTP",
+		"RTSP",
+		"SIP",
+		"HTML",
+		"XHTML",
+		"XML",
+		"WBR",
+		"CSS",
+		"SVG",
+		"JSON",
+		"JSONP",
+		"DOM",
+		"IDB",
+		"DB",
+		"RTC",
+		"ICE",
+		"TLS",
+		"SSL",
+		"CORS",
+		"WASM",
+		"CSR",
+		"SSR",
+		"PWA",
+		"DPI",
+		"CDN",
+		"JS",
+		"TS",
+		"JSX",
+		"TSX",
+		"CLI",
+		"API",
+		"SDK",
+		"UI",
+		"UX",
+		"OS",
+		"ID",
+		"UUID",
+		"PID",
+		"NPM",
+		"YARN",
+		"ESM",
+		"CJS",
+		"BOM",
+		"MVC",
+		"MVVM",
+		"ORM",
+		"DAO",
+		"CRUD",
+		"FIFO",
+		"LIFO",
+		"OOP",
+		"FP",
+		"REPL",
+		"CSV",
+		"TSV",
+		"SQL",
+		"YAML",
+		"JSON",
+		"MD",
+		"INI",
+		"PDF",
+		"XLS",
+		"XLSX",
+		"RTF",
+		"XML",
+		"BMP",
+		"GIF",
+		"PNG",
+		"JPEG",
+		"WEBP",
+		"MP3",
+		"MP4",
+		"AVI",
+		"MOV",
+		"FLAC",
+		"MKV",
+		"WAV",
+		"URLSearchParams",
+		"XHR",
+		"2D",
+		"3D",
+		"GL",
+		"WebGL",
+		"TTL",
+		"UID",
+		"GID",
+		"MAC",
+		"IP",
+		"DNS",
+		"DHCP",
+		"VPN",
+		"LAN",
+		"WAN",
+		"SSID",
+		"IoT",
+		"API",
+		"SDK",
+		"CLI",
+		"LTS",
+		"EOL",
+		"CPU",
+		"GPU",
+		"RAM",
+		"ROM",
+		"SSD",
+		"HDD",
+		"BIOS",
+		"USB",
+		"PCI",
+		"SATA",
+		"DIMM",
+		"DDR",
+		"VGA",
+		"HDMI",
+		"KVM",
+		"ASIC",
+		"FPGA",
+		"SoC",
+		"NAS",
+		"SAN",
+		"TCP",
+		"UDP",
+		"IP",
+		"MAC",
+		"DNS",
+		"DHCP",
+		"VPN",
+		"LAN",
+		"WAN",
+		"SSID",
+		"NAT",
+		"QoS",
+		"MPLS",
+		"BGP",
+		"OSPF",
+		"ICMP",
+		"IGMP",
+		"LLDP",
+		"ARP",
+		"RARP",
+		"AES",
+		"RSA",
+		"OTP",
+		"MFA",
+		"PKI",
+		"VPN",
+		"IAM",
+		"ACL",
+		"CSP",
+		"XSS",
+		"CSRF",
+		"HSTS",
+		"WAF",
+		"DDoS",
+		"IDS",
+		"IPS",
+		"SOC",
+		"SIEM",
+		"AWS",
+		"GCP",
+		"AZURE",
+		"CI",
+		"CD",
+		"K8S",
+		"IaC",
+		"PaaS",
+		"SaaS",
+		"IaaS",
+		"API",
+		"CLI",
+		"SDK",
+		"REST",
+		"SOAP",
+		"JSON-RPC",
+		"gRPC",
+		"ELB",
+		"EKS",
+		"AKS",
+		"FaaS",
+		"CaaS",
+		"GUI",
+		"IDE",
+		"FAQ",
+		"UX",
+		"UI",
+		"CLI",
+		"API",
+		"SDK",
+		"LTS",
+		"EOL",
+		"WYSIWYG",
+		"CMS",
+		"CRM",
+		"GPS",
+		"LED",
+		"OLED",
+		"LCD",
+		"RFID",
+		"NFC",
+		"CPU",
+		"GPU",
+		"AI",
+		"ML",
+		"DL",
+		"DB",
+		"SQL",
+		"NoSQL",
+		"ORM",
+		"JSON",
+		"XML",
+		"CSV",
+		"HTTP",
+		"HTTPS",
+		"TDD",
+		"BDD",
+		"CI",
+		"CD",
+		"QA",
+		"SLA",
+		"SLO",
+		"MTTR",
+		"MTBF",
+		"UAT",
+		"RPA",
+		"KPI",
+		"OKR",
+		"ROI",
+		"RFP",
+		"SLA",
+		"CRM",
+		"ERP",
+		"PMO",
+		"SCRUM",
+		"KANBAN",
+		"FPS",
+		"HDR",
+		"VR",
+		"AR",
+		"3D",
+		"2D",
+		"MP3",
+		"MP4",
+		"GIF",
+		"PNG",
+		"JPEG",
+		"SVG",
+		"BMP",
+		"TIFF",
+		"POSIX",
+		"NTFS",
+		"FAT",
+		"EXT",
+		"EXT4",
+		"APFS",
+		"HFS",
+		"ISO",
+		"HTML",
+		"CSS",
+		"JS",
+		"TS",
+		"PHP",
+		"SQL",
+		"JSON",
+		"XML",
+		"YAML",
+		"BASH",
+		"ZSH",
+		"JSON",
+		"YAML",
+		"INI",
+		"DOTENV",
+		"VM",
+		"VMM",
+		"VPC",
+		"OCI",
+		"LXC",
+		"Docker",
+		"K8S",
+		"CRI",
+		"CNI"
+	]);
+	static FIXES_CASTABLE_TABLE = Object.freeze(Object.entries(PreciseType.FIXES_RAW).reduce((acc, [k, v]) => {
+		acc[PreciseType.normalizeKeyForCase(k)] = v;
+		return acc;
+	}, {}));
+	formatCase = "toKebabCase";
+	useAcronyms = false;
+	constructor(params) {
+		this.formatCase = params?.formatCase;
+		this.useAcronyms = params?.useAcronyms;
+	}
+	determineOptions(options) {
+		return {
+			formatCase: options?.formatCase || this.formatCase,
+			useAcronyms: options?.useAcronyms ?? this.useAcronyms
+		};
+	}
+	getHtmlElementType(value, options) {
+		const { formatCase, useAcronyms } = this.determineOptions(options);
+		if (typeof HTMLElement === "undefined" || !(value instanceof HTMLElement)) return null;
+		const tagName = value.tagName;
+		const DEFAULTS = {
+			a: "Anchor",
+			abbr: "Abbreviation",
+			address: "Address",
+			area: "Area",
+			article: "Article",
+			aside: "Aside",
+			audio: "Audio",
+			b: "Bold",
+			base: "Base",
+			bdi: "BDI",
+			bdo: "BDO",
+			blockquote: "Blockquote",
+			body: "Body",
+			br: "Break",
+			button: "Button",
+			canvas: "Canvas",
+			caption: "Caption",
+			cite: "Cite",
+			code: "Code",
+			col: "Column",
+			colgroup: "Column Group",
+			data: "Data",
+			datalist: "Datalist",
+			dd: "Definition Description",
+			del: "Deleted Text",
+			details: "Details",
+			dfn: "Definition",
+			dialog: "Dialog",
+			div: "Div",
+			dl: "Definition List",
+			dt: "Definition Term",
+			em: "Emphasis",
+			embed: "Embed",
+			fieldset: "Fieldset",
+			figcaption: "Figcaption",
+			figure: "Figure",
+			footer: "Footer",
+			form: "Form",
+			h1: "Heading 1",
+			h2: "Heading 2",
+			h3: "Heading 3",
+			h4: "Heading 4",
+			h5: "Heading 5",
+			h6: "Heading 6",
+			head: "Head",
+			header: "Header",
+			hr: "Horizontal Rule",
+			html: "HTML",
+			i: "Italic",
+			iframe: "IFrame",
+			img: "Image",
+			input: "Input",
+			ins: "Inserted Text",
+			kbd: "Keyboard",
+			label: "Label",
+			legend: "Legend",
+			li: "List Item",
+			link: "Link",
+			main: "Main",
+			map: "Map",
+			mark: "Mark",
+			meta: "Meta",
+			meter: "Meter",
+			nav: "Nav",
+			noscript: "NoScript",
+			object: "Object",
+			ol: "Ordered List",
+			optgroup: "Option Group",
+			option: "Option",
+			output: "Output",
+			p: "Paragraph",
+			param: "Param",
+			picture: "Picture",
+			pre: "Preformatted",
+			progress: "Progress",
+			q: "Quote",
+			rp: "RP",
+			rt: "RT",
+			ruby: "Ruby",
+			s: "Strikethrough",
+			samp: "Sample",
+			script: "Script",
+			section: "Section",
+			select: "Select",
+			small: "Small",
+			source: "Source",
+			span: "Span",
+			strong: "Strong",
+			style: "Style",
+			sub: "Subscript",
+			summary: "Summary",
+			sup: "Superscript",
+			table: "Table",
+			tbody: "Table Body",
+			td: "Table Data",
+			template: "Template",
+			textarea: "Textarea",
+			tfoot: "Table Footer",
+			th: "Table Header",
+			thead: "Table Head",
+			time: "Time",
+			title: "Title",
+			tr: "Table Row",
+			track: "Track",
+			u: "Underline",
+			ul: "Unordered List",
+			var: "Variable",
+			video: "Video",
+			wbr: "WBR"
+		};
+		const displayName = PreciseType.FIXES_CASTABLE_TABLE[PreciseType.normalizeKeyForCase(tagName)] ?? (DEFAULTS[tagName] ? `HTML ${DEFAULTS[tagName]} Element` : "HTML Element");
+		return this.converter(displayName, {
+			formatCase,
+			useAcronyms
+		});
+	}
+	getCommentNodeType(value, options) {
+		const { formatCase, useAcronyms } = this.determineOptions(options);
+		if (value instanceof Comment) return this.converter(PreciseType.FIXES_CASTABLE_TABLE[PreciseType.normalizeKeyForCase("comment")] ?? "Comment", {
+			formatCase,
+			useAcronyms
+		});
+		return null;
+	}
+	getTextNodeType(value, options) {
+		const { formatCase, useAcronyms } = this.determineOptions(options);
+		if (value instanceof Text) return this.converter(PreciseType.FIXES_CASTABLE_TABLE[PreciseType.normalizeKeyForCase("text")] ?? "Text", {
+			formatCase,
+			useAcronyms
+		});
+		return null;
+	}
+	getOtherNodeType(value, options) {
+		const { formatCase, useAcronyms } = this.determineOptions(options);
+		if (typeof Node !== "undefined" && value instanceof Node) return this.converter(PreciseType.FIXES_CASTABLE_TABLE[PreciseType.normalizeKeyForCase("node")] ?? "Node", {
+			formatCase,
+			useAcronyms
+		});
+		return null;
+	}
+	getSymbolName(value, options) {
+		const { formatCase, useAcronyms } = this.determineOptions(options);
+		const key = new Map([
+			[Symbol.iterator, "symboliterator"],
+			[Symbol.asyncIterator, "symbolasynciterator"],
+			[Symbol.toStringTag, "symboltostringtag"],
+			[Symbol.species, "symbolspecies"],
+			[Symbol.hasInstance, "symbolhasinstance"],
+			[Symbol.isConcatSpreadable, "symbolisconcatspreadable"],
+			[Symbol.unscopables, "symbolunscopables"],
+			[Symbol.match, "symbolmatch"],
+			[Symbol.replace, "symbolreplace"],
+			[Symbol.search, "symbolsearch"],
+			[Symbol.split, "symbolsplit"],
+			[Symbol.toPrimitive, "symboltoprimitive"],
+			[Symbol.matchAll, "symbolmatchall"]
+		]).get(value);
+		if (key) return this.converter(PreciseType.FIXES_CASTABLE_TABLE[PreciseType.normalizeKeyForCase(key)] ?? key, {
+			formatCase,
+			useAcronyms
+		});
+		return this.converter(PreciseType.FIXES_CASTABLE_TABLE[PreciseType.normalizeKeyForCase("symbol")] ?? "Symbol", {
+			formatCase,
+			useAcronyms
+		});
+	}
+	detectDomNodeType(value, options) {
+		const { formatCase, useAcronyms } = this.determineOptions(options);
+		try {
+			return this.getHtmlElementType(value, {
+				formatCase,
+				useAcronyms
+			}) || this.getCommentNodeType(value, {
+				formatCase,
+				useAcronyms
+			}) || this.getTextNodeType(value, {
+				formatCase,
+				useAcronyms
+			}) || this.getOtherNodeType(value, {
+				formatCase,
+				useAcronyms
+			});
+		} catch {
+			return null;
+		}
+	}
+	isProxy(value) {
+		if (isNull(value) || !isObjectOrArray(value)) return false;
+		const tag = Object.prototype.toString.call(value);
+		if ([
+			"[object Array]",
+			"[object Date]",
+			"[object RegExp]",
+			"[object Map]",
+			"[object Set]",
+			"[object WeakMap]",
+			"[object WeakSet]",
+			"[object Function]",
+			"[object Error]",
+			"[object Promise]",
+			"[object Generator]",
+			"[object GeneratorFunction]",
+			"[object AsyncFunction]"
+		].includes(tag)) return false;
+		try {
+			Reflect.defineProperty(value, "__proxy_detect__", {
+				configurable: true,
+				value: 1
+			});
+			Reflect.deleteProperty(value, "__proxy_detect__");
+			return false;
+		} catch {
+			return true;
+		}
+	}
+	converter(input, options) {
+		const { formatCase, useAcronyms } = this.determineOptions(options);
+		const ignoreWord = useAcronyms ? PreciseType.ACRONYMS : [];
+		switch (formatCase) {
+			case "slugify": return slugify(input, ignoreWord);
+			case "toDotCase": return toDotCase(input, ignoreWord);
+			case "toCamelCase": return toCamelCase(input, ignoreWord);
+			case "toSnakeCase": return toSnakeCase(input, ignoreWord);
+			case "toLowerCase": return toLowerCase(input, ignoreWord);
+			case "toPascalCase": return toPascalCase(input, ignoreWord);
+			case "toPascalCaseSpace": return toPascalCaseSpace(input, ignoreWord);
+			default: return toKebabCase(input, ignoreWord);
+		}
+	}
+	static normalizeKeyForCase(k) {
+		return k.replace(/[\s_\-.]+/g, "").toLowerCase();
+	}
+	static get castableTable() {
+		return PreciseType.FIXES_CASTABLE_TABLE;
+	}
+	static get specialType() {
+		return this.SPECIAL_TYPE;
+	}
+	static get fixesRaw() {
+		return this.FIXES_RAW;
+	}
+	static get acronymsList() {
+		return this.ACRONYMS;
+	}
+};
+const getPreciseType = (() => {
+	const cache = /* @__PURE__ */ new Map();
+	const MAX_CACHE_SIZE = 25;
+	return (value, options = {}) => {
+		if (!isPlainObject(options)) options = {};
+		const key = JSON.stringify({
+			formatCase: options.formatCase || "toKebabCase",
+			useAcronyms: options.useAcronyms ?? false
+		});
+		let ClassPrecise = cache.get(key);
+		if (!ClassPrecise) {
+			if (cache.size >= MAX_CACHE_SIZE) cache.clear();
+			ClassPrecise = new PreciseType(options);
+			cache.set(key, ClassPrecise);
+		}
+		if (isNull(value)) return ClassPrecise.converter(PreciseType.castableTable[PreciseType.normalizeKeyForCase("null")] ?? "Null");
+		if (isNaN(value)) return "NaN";
+		if (isInfinityNumber(value)) return String(value);
+		if (typeof BigInt !== "undefined" && value === BigInt) return ClassPrecise.converter(PreciseType.castableTable[PreciseType.normalizeKeyForCase("bigint constructor")] ?? "bigint constructor");
+		if (isNumberObject(value) || value === Number) return ClassPrecise.converter(PreciseType.castableTable[PreciseType.normalizeKeyForCase("number constructor")] ?? "number constructor");
+		if (isStringObject(value) || value === String) return ClassPrecise.converter(PreciseType.castableTable[PreciseType.normalizeKeyForCase("string constructor")] ?? "string constructor");
+		if (isBooleanObject(value) || value === Boolean) return ClassPrecise.converter(PreciseType.castableTable[PreciseType.normalizeKeyForCase("boolean constructor")] ?? "boolean constructor");
+		const prim = typeof value;
+		if (!isObjectOrArray(value) && !isFunction(value) && prim !== "symbol") return ClassPrecise.converter(PreciseType.castableTable[PreciseType.normalizeKeyForCase(prim)] ?? prim);
+		if (prim === "symbol") return ClassPrecise.getSymbolName(value);
+		if (isObjectOrArray(value) && value.constructor?.name === "EventEmitter") return ClassPrecise.converter(PreciseType.castableTable[PreciseType.normalizeKeyForCase("event emitter")] ?? "Event Emitter");
+		const domType = ClassPrecise.detectDomNodeType(value);
+		if (domType) return domType;
+		if (isBuffer(value)) return ClassPrecise.converter(PreciseType.castableTable[PreciseType.normalizeKeyForCase("buffer")] ?? "Buffer");
+		if (ClassPrecise.isProxy(value)) return ClassPrecise.converter(PreciseType.castableTable[PreciseType.normalizeKeyForCase("proxy")] ?? "Proxy");
+		if (isObject(value) && isFunction(value?.next) && isFunction(value?.throw)) return ClassPrecise.converter(PreciseType.castableTable[PreciseType.normalizeKeyForCase("generator")] ?? "Generator");
+		if (isError(value)) {
+			const ctorName = value.constructor?.name ?? "Error";
+			return ClassPrecise.converter(PreciseType.castableTable[PreciseType.normalizeKeyForCase(ctorName)] ?? PreciseType.castableTable[PreciseType.normalizeKeyForCase(ctorName.replace(/\s+/g, ""))] ?? ctorName);
+		}
+		if (isObjectOrArray(value) && "done" in value && "value" in value && Object.keys(value).length === 2) return ClassPrecise.converter(PreciseType.castableTable[PreciseType.normalizeKeyForCase("iterator result")] ?? "iterator result");
+		if (isNull(Object.getPrototypeOf(value))) return ClassPrecise.converter(PreciseType.castableTable[PreciseType.normalizeKeyForCase("object")] ?? "Object");
+		const tag = Object.prototype.toString.call(value).slice(8, -1) || "Object";
+		const mapped = PreciseType.castableTable[PreciseType.normalizeKeyForCase(tag)];
+		if (mapped) return ClassPrecise.converter(mapped);
+		const ctorName = value?.constructor?.name;
+		if (ctorName && ctorName !== "Object") return ClassPrecise.converter(PreciseType.castableTable[PreciseType.normalizeKeyForCase(ctorName)] ?? ctorName);
+		return ClassPrecise.converter(tag);
+	};
+})();
+const determineErrorTypeAssertion = (type, message) => {
+	switch (type) {
+		case "Error": throw new Error(message);
+		case "EvalError": throw new EvalError(message);
+		case "RangeError": throw new RangeError(message);
+		case "ReferenceError": throw new ReferenceError(message);
+		case "SyntaxError": throw new SyntaxError(message);
+		case "URIError": throw new URIError(message);
+		case "TypeError": throw new TypeError(message);
+		default: throw new TypeError(message);
+	}
+};
+function resolveErrorMessageAssertions(params) {
+	const { requiredValidType, value, options } = params || {};
+	const { message, formatCase, useAcronyms, errorType = "TypeError" } = isPlainObject(options) ? options : {};
+	const validType = toKebabCase(requiredValidType);
+	const currentType = getPreciseType(value, {
+		formatCase,
+		useAcronyms
+	});
+	const messageFnOptions = {
+		currentType,
+		validType
+	};
+	const defaultMessage = `Parameter input (\`value\`) must be of type \`${validType}\`, but received: \`${currentType}\`.`;
+	return determineErrorTypeAssertion(errorType, isFunction(message) ? isNonEmptyString(message(messageFnOptions)) ? message(messageFnOptions).trim() : defaultMessage : isNonEmptyString(message) ? message.trim() : defaultMessage);
+}
+const assertIsBoolean = (value, options = {}) => {
+	if (isBoolean(value)) return;
+	resolveErrorMessageAssertions({
+		value,
+		options,
+		requiredValidType: "boolean"
+	});
+};
+export { isPlainObject as A, isSymbol as C, isNaN as D, isNull as E, isBoolean as F, isArray as M, isNil as N, isNumberObject as O, isFunction as P, isUndefined as S, assertIsPlainObject as T, isBuffer as _, toPascalCase as a, hasOwnProp as b, toKebabCase as c, slugify as d, isSet as f, isStringObject as g, isBooleanObject as h, toPascalCaseSpace as i, isObject as j, isString as k, toCamelCase as l, isInfinityNumber as m, resolveErrorMessageAssertions as n, toLowerCase as o, isNonEmptyArray as p, getPreciseType as r, toSnakeCase as s, assertIsBoolean as t, toDotCase as u, isError as v, isNumber as w, isObjectOrArray as x, isNonEmptyString as y };
+//# sourceMappingURL=assertIsBoolean-DR1SaXPD.js.map