@rzl-zone/build-tools 0.0.5

package/dist/fast-globe-options-6r2aj6UC.d.ts

@@ -0,0 +1,126 @@
+/*!
+* ========================================================================
+*  @rzl-zone/build-tools
+* ------------------------------------------------------------------------
+*  Version: `0.0.5`
+*  Author: `Rizalvin Dwiky <rizalvindwiky1998@gmail.com>`
+*  Repository: `https://github.com/rzl-zone/rzl-zone/tree/main/packages/build-tools`
+* ========================================================================
+*/
+
+import { a as OmitStrict, s as Prettify } from "./extra-CVuXMpEw.js";
+import * as fg from "fast-glob";
+
+type IfTrueGeneric<T extends boolean, K> = T extends true ? K : never;
+/** ----------------------------------------------------------------
+* * ***Supported pattern matching options.***
+* ----------------------------------------------------------------
+* Defines the subset of {@link fg | `fast-glob`} options exposed by
+* this module for pattern-based file resolution.
+*
+* This type intentionally omits several low-level or environment-
+* controlled fields to ensure predictable and safe behavior.
+*
+* ----------------------------------------------------------------
+*
+* *Excluded options (managed internally):*
+*
+* - `fs`
+* - `cwd`
+* - `stats`
+* - `deep`
+* - `extglob`
+* - `suppressErrors`
+* - `braceExpansion`
+*
+* These fields are controlled by the runtime environment and should
+* not be overridden by consumers.
+*
+* ----------------------------------------------------------------
+* @template FilesOnly
+* When `true`, directory filtering options (`onlyFiles`, `onlyDirectories`)
+* are removed from the public API surface, preventing consumers from
+* modifying directory matching behavior.
+*
+* @template ForceUnique
+* When `true`, the `unique` option is removed from the public API to enforce internal uniqueness handling.
+*
+* This allows higher-level utilities to guarantee that matched results
+* are always deduplicated.
+*
+* ----------------------------------------------------------------
+*
+* This type serves as the public configuration contract used when
+* resolving glob patterns.
+*/
+type PatternOptions<FilesOnly extends boolean = false, ForceUnique extends boolean = false> = OmitStrict<fg.Options, "fs" | "cwd" | "stats" | "deep" | "extglob" | "suppressErrors" | "braceExpansion" | "dot" | IfTrueGeneric<FilesOnly, "onlyFiles" | "onlyDirectories"> | IfTrueGeneric<ForceUnique, "unique">, {
+  skipPrettify: true;
+}> & {
+  /** Allow patterns to match entries that begin with a period (`.`).
+  *
+  * @default true
+  */
+  dot?: boolean;
+};
+/** ----------------------------------------------------------------
+* * ***Pattern configuration wrapper.***
+* ----------------------------------------------------------------
+*
+* Provides an optional container for {@link PatternOptions | `PatternOptions`}.
+*
+* This wrapper allows pattern matching configuration to be composed
+* within higher-level configuration objects without flattening
+* the option namespace.
+*
+* ----------------------------------------------------------------
+*
+* @template FilesOnly
+* When `true`, directory-related options (`onlyFiles`, `onlyDirectories`)
+* are removed from the public configuration to enforce file-only matching.
+*
+* @template ForceUnique
+* When `true`, the `unique` option is removed from the underlying
+* {@link PatternOptions | `PatternOptions`} to guarantee deduplicated results.
+*
+* ----------------------------------------------------------------
+*
+* @example
+* ```ts
+* const config: PatternConfig = {
+*   patternOptions: {
+*     dot: true
+*   }
+* };
+* ```
+*/
+type PatternConfig<FilesOnly extends boolean = false, ForceUnique extends boolean = false> = Prettify<{
+  /** ----------------------------------------------------------------
+  * * ***Pattern matching options.***
+  * ----------------------------------------------------------------
+  *
+  * Optional configuration for controlling file pattern resolution.
+  *
+  * When provided, these options are sanitized and merged with
+  * the internal default configuration before being passed to
+  * {@link fg | `fast-glob`}.
+  *
+  * @see {@link PatternOptions | `PatternOptions`} for supported fields.
+  */
+  patternOptions?: PatternOptions<FilesOnly, ForceUnique>;
+}>;
+/** ----------------------------------------------------------------
+* * ***Default pattern matching configuration.***
+* ----------------------------------------------------------------
+*
+* Represents the canonical baseline configuration used when
+* resolving pattern options.
+*
+* These values are applied whenever a user does not explicitly
+* provide overrides.
+*
+* This object also acts as the runtime source of truth for
+* allowed pattern option keys.
+*/
+declare const defaultPatternOptions: PatternOptions;
+export { PatternOptions as n, defaultPatternOptions as r, PatternConfig as t };
+//# sourceMappingURL=fast-globe-options-6r2aj6UC.d.ts.map

package/dist/fast-globe-options-BFt__e__.d.cts

@@ -0,0 +1,126 @@
+/*!
+* ========================================================================
+*  @rzl-zone/build-tools
+* ------------------------------------------------------------------------
+*  Version: `0.0.5`
+*  Author: `Rizalvin Dwiky <rizalvindwiky1998@gmail.com>`
+*  Repository: `https://github.com/rzl-zone/rzl-zone/tree/main/packages/build-tools`
+* ========================================================================
+*/
+
+import { a as OmitStrict, s as Prettify } from "./extra-CxDwtQEy.cjs";
+import * as fg from "fast-glob";
+
+type IfTrueGeneric<T extends boolean, K> = T extends true ? K : never;
+/** ----------------------------------------------------------------
+* * ***Supported pattern matching options.***
+* ----------------------------------------------------------------
+* Defines the subset of {@link fg | `fast-glob`} options exposed by
+* this module for pattern-based file resolution.
+*
+* This type intentionally omits several low-level or environment-
+* controlled fields to ensure predictable and safe behavior.
+*
+* ----------------------------------------------------------------
+*
+* *Excluded options (managed internally):*
+*
+* - `fs`
+* - `cwd`
+* - `stats`
+* - `deep`
+* - `extglob`
+* - `suppressErrors`
+* - `braceExpansion`
+*
+* These fields are controlled by the runtime environment and should
+* not be overridden by consumers.
+*
+* ----------------------------------------------------------------
+* @template FilesOnly
+* When `true`, directory filtering options (`onlyFiles`, `onlyDirectories`)
+* are removed from the public API surface, preventing consumers from
+* modifying directory matching behavior.
+*
+* @template ForceUnique
+* When `true`, the `unique` option is removed from the public API to enforce internal uniqueness handling.
+*
+* This allows higher-level utilities to guarantee that matched results
+* are always deduplicated.
+*
+* ----------------------------------------------------------------
+*
+* This type serves as the public configuration contract used when
+* resolving glob patterns.
+*/
+type PatternOptions<FilesOnly extends boolean = false, ForceUnique extends boolean = false> = OmitStrict<fg.Options, "fs" | "cwd" | "stats" | "deep" | "extglob" | "suppressErrors" | "braceExpansion" | "dot" | IfTrueGeneric<FilesOnly, "onlyFiles" | "onlyDirectories"> | IfTrueGeneric<ForceUnique, "unique">, {
+  skipPrettify: true;
+}> & {
+  /** Allow patterns to match entries that begin with a period (`.`).
+  *
+  * @default true
+  */
+  dot?: boolean;
+};
+/** ----------------------------------------------------------------
+* * ***Pattern configuration wrapper.***
+* ----------------------------------------------------------------
+*
+* Provides an optional container for {@link PatternOptions | `PatternOptions`}.
+*
+* This wrapper allows pattern matching configuration to be composed
+* within higher-level configuration objects without flattening
+* the option namespace.
+*
+* ----------------------------------------------------------------
+*
+* @template FilesOnly
+* When `true`, directory-related options (`onlyFiles`, `onlyDirectories`)
+* are removed from the public configuration to enforce file-only matching.
+*
+* @template ForceUnique
+* When `true`, the `unique` option is removed from the underlying
+* {@link PatternOptions | `PatternOptions`} to guarantee deduplicated results.
+*
+* ----------------------------------------------------------------
+*
+* @example
+* ```ts
+* const config: PatternConfig = {
+*   patternOptions: {
+*     dot: true
+*   }
+* };
+* ```
+*/
+type PatternConfig<FilesOnly extends boolean = false, ForceUnique extends boolean = false> = Prettify<{
+  /** ----------------------------------------------------------------
+  * * ***Pattern matching options.***
+  * ----------------------------------------------------------------
+  *
+  * Optional configuration for controlling file pattern resolution.
+  *
+  * When provided, these options are sanitized and merged with
+  * the internal default configuration before being passed to
+  * {@link fg | `fast-glob`}.
+  *
+  * @see {@link PatternOptions | `PatternOptions`} for supported fields.
+  */
+  patternOptions?: PatternOptions<FilesOnly, ForceUnique>;
+}>;
+/** ----------------------------------------------------------------
+* * ***Default pattern matching configuration.***
+* ----------------------------------------------------------------
+*
+* Represents the canonical baseline configuration used when
+* resolving pattern options.
+*
+* These values are applied whenever a user does not explicitly
+* provide overrides.
+*
+* This object also acts as the runtime source of truth for
+* allowed pattern option keys.
+*/
+declare const defaultPatternOptions: PatternOptions;
+export { PatternOptions as n, defaultPatternOptions as r, PatternConfig as t };
+//# sourceMappingURL=fast-globe-options-BFt__e__.d.cts.map

package/dist/helper-BdjaR8Yv.js

@@ -0,0 +1,215 @@
+/*!
+* ========================================================================
+*  @rzl-zone/build-tools
+* ------------------------------------------------------------------------
+*  Version: `0.0.5`
+*  Author: `Rizalvin Dwiky <rizalvindwiky1998@gmail.com>`
+*  Repository: `https://github.com/rzl-zone/rzl-zone/tree/main/packages/build-tools`
+* ========================================================================
+*/
+
+function deepFreeze(value) {
+	if (typeof value !== "object" || value === null) return value;
+	const seen = /* @__PURE__ */ new WeakSet();
+	const stack = [value];
+	while (stack.length) {
+		const obj = stack.pop();
+		if (seen.has(obj) || Object.isFrozen(obj)) continue;
+		seen.add(obj);
+		if (isMap(obj)) for (const [k, v] of obj) {
+			if (typeof k === "object" && k !== null) stack.push(k);
+			if (typeof v === "object" && v !== null) stack.push(v);
+		}
+		else if (isSet(obj)) {
+			for (const v of obj) if (typeof v === "object" && v !== null) stack.push(v);
+		} else if (isArray(obj)) {
+			for (const v of obj) if (typeof v === "object" && v !== null) stack.push(v);
+		} else {
+			const record = obj;
+			for (const key of Reflect.ownKeys(record)) {
+				const v = record[key];
+				if (typeof v === "object" && v !== null) stack.push(v);
+			}
+		}
+		Object.freeze(obj);
+	}
+	return value;
+}
+const isRegExp = (value) => {
+	return value instanceof RegExp;
+};
+const isString = (value) => {
+	return typeof value === "string";
+};
+function isSet(value) {
+	return Object.prototype.toString.call(value) === "[object Set]" || value instanceof Set;
+}
+function isMap(value) {
+	return Object.prototype.toString.call(value) === "[object Map]" || value instanceof Map;
+}
+function isArray(value) {
+	return Array.isArray(value);
+}
+const isNull = (val) => val === null;
+function isPlainObject(value) {
+	if (!isObject(value)) return false;
+	const proto = Object.getPrototypeOf(value);
+	return proto === Object.prototype || proto === null;
+}
+function isObject(value) {
+	return typeof value === "object" && !isNil(value) && !isArray(value);
+}
+function isObjectOrArray(value) {
+	return isArray(value) || isObject(value);
+}
+const isNil = (value) => {
+	return value == null;
+};
+const isBoolean = (value) => {
+	return typeof value === "boolean";
+};
+const isUndefined = (value) => {
+	return typeof value === "undefined";
+};
+const isFunction = (value) => {
+	return typeof value === "function";
+};
+const isNumberObject = (value) => {
+	return isObject(value) && Object.prototype.toString.call(value) === "[object Number]";
+};
+const isStringObject = (value) => {
+	return isObject(value) && Object.prototype.toString.call(value) === "[object String]";
+};
+const isBooleanObject = (value) => {
+	return isObject(value) && Object.prototype.toString.call(value) === "[object Boolean]";
+};
+const isInfinityNumber = (value) => {
+	if (typeof value === "number" || isNumberObject(value)) {
+		const num = Number(value);
+		return num === Infinity || num === -Infinity;
+	}
+	return false;
+};
+const isSymbol = (value) => {
+	return typeof value === "symbol";
+};
+const isBigInt = (value) => {
+	return typeof value === "bigint";
+};
+const isNaN = (value) => {
+	return typeof value === "number" ? Number.isNaN(value) : isNumberObject(value) && Number.isNaN(value.valueOf());
+};
+const isNonEmptyString = (value, options = {}) => {
+	if (!isString(value)) return false;
+	return (options.trim ?? true ? value.trim() : value).length > 0;
+};
+const isNumber = (value, options = {}) => {
+	const includeNaN = isPlainObject(options) && isBoolean(options.includeNaN) ? options.includeNaN : false;
+	const aNumber = typeof value === "number";
+	return includeNaN ? aNumber : aNumber && !Number.isNaN(value);
+};
+const isError = (error) => {
+	return Object.prototype.toString.call(error) === "[object Error]" || error instanceof Error;
+};
+const isDate = (value, options = {}) => {
+	const skipInvalidDate = isPlainObject(options) && isBoolean(options.skipInvalidDate) ? options.skipInvalidDate : false;
+	const instanceDate = value instanceof Date;
+	if (skipInvalidDate) return instanceDate;
+	return instanceDate && !isNaN(value.getTime());
+};
+const safeStableStringify = (value, options = {}) => {
+	const pretty = options.pretty ?? false;
+	const sortKeys = options.sortKeys ?? true;
+	const sortArray = options.sortArray ?? false;
+	const keepUndefined = options.keepUndefined ?? false;
+	if (isUndefined(value)) return keepUndefined ? "undefined" : "null";
+	const seen = /* @__PURE__ */ new WeakSet();
+	const isPrimitive = (val) => isNull(val) || !isObjectOrArray(val) && !isFunction(val);
+	const deepProcess = (val) => {
+		if (isNumberObject(val)) {
+			const valOf = val.valueOf();
+			return isNaN(valOf) || isInfinityNumber(valOf) ? null : valOf;
+		}
+		if (isStringObject(val)) return val.valueOf();
+		if (isBooleanObject(val)) return val.valueOf();
+		if (isFunction(val) || isSymbol(val)) return void 0;
+		if (isBigInt(val)) return val.toString();
+		if (isNaN(val) || isInfinityNumber(val)) return null;
+		if (isUndefined(val)) return keepUndefined ? void 0 : null;
+		if (isObjectOrArray(val)) {
+			if (seen.has(val)) return "[Circular]";
+			seen.add(val);
+			if (isDate(val)) return val.toISOString();
+			if (isMap(val)) return { map: Array.from(val.entries()).map(([k, v]) => [k, deepProcess(v)]) };
+			if (isSet(val)) return { set: Array.from(val.values()).map(deepProcess) };
+			if (isArray(val)) {
+				const processedArr = val.map(deepProcess);
+				if (sortArray) {
+					const primitives = [];
+					const nonPrimitives = [];
+					for (const item of processedArr) if (isPrimitive(item)) primitives.push(item);
+					else nonPrimitives.push(item);
+					primitives.sort((a, b) => {
+						if (isNumber(a) && isNumber(b)) return a - b;
+						return String(a).localeCompare(String(b));
+					});
+					return [...primitives, ...nonPrimitives];
+				}
+				return processedArr;
+			}
+			const keys = Object.keys(val);
+			if (sortKeys) keys.sort((a, b) => {
+				const na = Number(a);
+				const nb = Number(b);
+				if (!isNaN(na) && !isNaN(nb)) return na - nb;
+				return a.localeCompare(b);
+			});
+			const result = {};
+			if (isObject(val)) for (const k of keys) {
+				const v = deepProcess(val[k]);
+				if (!isUndefined(v)) result[k] = v;
+			}
+			return result;
+		}
+		return val;
+	};
+	try {
+		return JSON.stringify(deepProcess(value), null, pretty ? 2 : 0);
+	} catch (err) {
+		console.warn("Error in safeStableStringify:", err);
+		return "{}";
+	}
+};
+const normalizeSpaces = (value, options = {
+	withTrim: true,
+	trimOnly: false
+}) => {
+	if (!isNonEmptyString(value)) return "";
+	if (!isPlainObject(options)) options = {};
+	const { trimOnly = false, withTrim = true } = options;
+	if (trimOnly) return value.trim();
+	if (withTrim) value = value.trim();
+	return value.replace(/\s+/g, " ");
+};
+const isStringArray = (v) => isArray(v) && v.every((i) => isString(i));
+const isStringSet = (v) => isSet(v) && [...v].every((i) => isString(i));
+const assertValidatePatternArgs = (v, parameterKey = "pattern") => {
+	if (!isString(v) && !isStringArray(v) && !isStringSet(v)) throw new TypeError(`The \`${parameterKey}\` argument must be a string, string[] or Set<string>.`);
+};
+const flattenStrings = (input) => {
+	return input.flat(Infinity).filter((v) => typeof v === "string");
+};
+const toStringSet = (pattern, options = {}) => {
+	const { withValidationType = true, parameterKey = "pattern" } = options;
+	if (withValidationType) assertValidatePatternArgs(pattern, parameterKey);
+	return toObjectSet(pattern);
+};
+const toObjectSet = (value) => {
+	if (isSet(value)) return value;
+	return new Set(isArray(value) ? value : [value]);
+};
+const toArray = (value) => {
+	return isArray(value) ? value : [value];
+};
+export { toStringSet as S, isUndefined as _, isError as a, toArray as b, isNil as c, isNumber as d, isObject as f, isString as g, isSet as h, isBoolean as i, isNonEmptyString as l, isRegExp as m, flattenStrings as n, isFunction as o, isPlainObject as p, isArray as r, isMap as s, deepFreeze as t, isNull as u, normalizeSpaces as v, toObjectSet as x, safeStableStringify as y };
+//# sourceMappingURL=helper-BdjaR8Yv.js.map

package/dist/helper-BdjaR8Yv.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"helper-BdjaR8Yv.js","names":[],"sources":["../src/_internal/utils/helper.ts"],"sourcesContent":["import type {\n  AnObjectNonArray,\n  AnyFunction,\n  Arrayable,\n  Extends,\n  IsArray,\n  IsNever,\n  NonPlainObject,\n  OrArr,\n  ReadonlyDeep\n} from \"@/_internal/types/extra\";\n\n// ----------------------------------------------------------------\n\n/** @internal */\nexport function deepFreeze<T>(value: T): ReadonlyDeep<T> {\n  if (typeof value !== \"object\" || value === null) {\n    return value as ReadonlyDeep<T>;\n  }\n\n  const seen = new WeakSet<object>();\n  const stack: object[] = [value as object];\n\n  while (stack.length) {\n    const obj = stack.pop()!;\n\n    if (seen.has(obj) || Object.isFrozen(obj)) continue;\n\n    seen.add(obj);\n\n    // Map\n    if (isMap(obj)) {\n      for (const [k, v] of obj) {\n        if (typeof k === \"object\" && k !== null) stack.push(k);\n        if (typeof v === \"object\" && v !== null) stack.push(v);\n      }\n    }\n\n    // Set\n    else if (isSet(obj)) {\n      for (const v of obj) {\n        if (typeof v === \"object\" && v !== null) stack.push(v);\n      }\n    }\n\n    // Fast path Array\n    else if (isArray(obj)) {\n      for (const v of obj) {\n        if (typeof v === \"object\" && v !== null) stack.push(v);\n      }\n    } else {\n      const record = obj as Record<PropertyKey, unknown>;\n\n      for (const key of Reflect.ownKeys(record)) {\n        const v = record[key];\n        if (typeof v === \"object\" && v !== null) stack.push(v);\n      }\n\n      // const descriptors = Object.getOwnPropertyDescriptors(obj);\n\n      // for (const key of Reflect.ownKeys(descriptors)) {\n      //   const desc = descriptors[key as keyof typeof descriptors];\n      //   if (!desc) continue;\n\n      //   if (\"value\" in desc) {\n      //     const v = desc.value;\n      //     if (typeof v === \"object\" && v !== null) stack.push(v);\n      //   }\n      // }\n    }\n\n    Object.freeze(obj);\n  }\n\n  return value as ReadonlyDeep<T>;\n}\n// ----------------------------------------------------------------\n\n/** @internal */\nexport function isObjectLoose<T>(\n  value: T\n): value is Extract<T, object | AnyFunction> {\n  return !isNil(value) && (isObjectOrArray(value) || isFunction(value));\n}\n\nexport function isObjectLike<T>(value: T): value is Extract<T, object> {\n  return !isFunction(value) && isObjectLoose(value);\n}\n// ----------------------------------------------------------------\n\n/** ----------------------------------------------------------------\n * * ***Check whether a value is thenable (Promise-like).***\n * ----------------------------------------------------------------\n *\n * Determines whether a value implements a `.then()` method and can be\n * treated as a **thenable** object.\n *\n * This includes:\n * - Native `Promise`.\n * - Promise-like objects returned by libraries.\n * - Custom objects implementing `.then()`.\n *\n * ----------------------------------------------------------------\n *\n * @typeParam T\n * The resolved value type of the thenable.\n *\n * @param v\n * The value to check.\n *\n * @returns\n * `true` if the value is thenable, otherwise `false`.\n *\n * When `true`, the value is narrowed to `PromiseLike<T>`.\n *\n * ----------------------------------------------------------------\n *\n * @example\n * ```ts\n * isThenable(Promise.resolve(1));\n * // ➔ true\n *\n * isThenable({ then: () => {} });\n * // ➔ true\n *\n * isThenable(123);\n * // ➔ false\n * ```\n *\n * @example\n * ```ts\n * async function unwrap<T>(value: T | Promise<T>) {\n *   if (isThenable<T>(value)) {\n *     return await value;\n *   }\n *\n *   return value;\n * }\n * ```\n *\n * @remarks\n * Thenables are typically resolved before function execution to support async config factories without enforcing `Promise` instances.\n * - This function checks **behavior**, not identity.\n * - The value does **not** have to be an instance of `Promise`.\n * - Useful for async utilities, lazy evaluation, and hybrid sync/async APIs.\n *\n * @internal\n */\nexport const isThenable = <T = unknown>(v: unknown): v is PromiseLike<T> =>\n  v != null &&\n  (typeof v === \"object\" || typeof v === \"function\") &&\n  typeof (v as PromiseLike<T>).then === \"function\";\n\n// ----------------------------------------------------------------\n\n/** @internal */\nexport const isRegExp = (value: unknown): value is RegExp => {\n  return value instanceof RegExp;\n};\n\n// ----------------------------------------------------------------\n\n/** @internal */\nexport const isString = (value: unknown): value is string => {\n  return typeof value === \"string\";\n};\n\n// ----------------------------------------------------------------\n\n/** @internal */\nexport function isSet<T = unknown>(value: Set<T>): value is Set<T>;\nexport function isSet(value: unknown): value is Set<unknown>;\nexport function isSet(value: unknown): boolean {\n  return (\n    Object.prototype.toString.call(value) === \"[object Set]\" ||\n    value instanceof Set\n  );\n}\n\n// ----------------------------------------------------------------\n\n/** @internal */\nexport function isMap<K = unknown, V = unknown>(\n  value: Map<K, V>\n): value is Map<K, V>;\nexport function isMap(value: unknown): value is Map<unknown, unknown>;\nexport function isMap(value: unknown): boolean {\n  return (\n    Object.prototype.toString.call(value) === \"[object Map]\" ||\n    value instanceof Map\n  );\n}\n\n// ----------------------------------------------------------------\n\n/** @internal */\ntype ArrayFallback<T> =\n  IsNever<Extract<T, unknown[] | readonly unknown[]>> extends true\n    ? unknown[] & T\n    : Extract<T, unknown[] | readonly unknown[]>;\n\n/** @internal */\nexport function isArray<T>(value: T): value is ArrayFallback<T>;\n// export function isArray<T>(value: T): value is IsNever<Extract<T, unknown[]>> extends true ? unknown[]: Extract<T, unknown[]>;\nexport function isArray(value: unknown): value is unknown[];\nexport function isArray(value: unknown): boolean {\n  return Array.isArray(value);\n}\n\n// ----------------------------------------------------------------\n\n/** @internal */\nexport const isNull = (val: unknown): val is null => val === null;\n\n// ----------------------------------------------------------------\n\n/** @internal */\ntype IsPlainObjectResult<T> = unknown extends T\n  ? Record<PropertyKey, unknown> & T\n  : T extends object\n    ? T extends NonPlainObject\n      ? never\n      : IsHasKeysObject<T> extends false\n        ? Record<PropertyKey, unknown> & T\n        : T\n    : Extract<T, Record<PropertyKey, unknown>>;\n\n/** @internal */\nexport function isPlainObject<T>(value: T): value is IsPlainObjectResult<T>;\nexport function isPlainObject<T>(\n  value: T\n): value is NonNullable<Extract<T, Record<PropertyKey, unknown>>>;\nexport function isPlainObject(value: unknown) {\n  if (!isObject(value)) return false;\n\n  const proto = Object.getPrototypeOf(value);\n  return proto === Object.prototype || proto === null;\n}\n\n// ----------------------------------------------------------------\n\n/** @internal */\ntype IsObject<T> = unknown extends T\n  ? T & Record<PropertyKey, unknown>\n  : T extends object\n    ? T extends AnObjectNonArray\n      ? T\n      : IsHasKeysObject<T> extends false\n        ? T & Record<PropertyKey, unknown>\n        : IsArray<T> extends true\n          ? Exclude<T, unknown[]>\n          : T\n    : never;\n\n/** @internal */\nexport function isObject<T extends object>(value: T): value is IsObject<T>;\nexport function isObject(value: unknown): value is Record<PropertyKey, unknown>;\nexport function isObject(value: unknown): boolean {\n  return typeof value === \"object\" && !isNil(value) && !isArray(value);\n}\n\n// ----------------------------------------------------------------\n\n/** @internal */\ntype IsHasKeysObject<T> = keyof T extends never ? false : true;\n\n// ----------------------------------------------------------------\n\n/** @internal */\ntype IsObjectOrArray<T> =\n  OrArr<\n    [IsNever<T>, Extends<T, Record<PropertyKey, unknown>>, Extends<unknown, T>]\n  > extends true\n    ? T & Record<PropertyKey, unknown> & unknown[]\n    : T extends object\n      ? T extends unknown[]\n        ? T\n        : T extends AnObjectNonArray\n          ? T\n          : IsHasKeysObject<T> extends false\n            ? T & Record<PropertyKey, unknown>\n            : T\n      : Extract<T, Record<PropertyKey, unknown> & unknown[]>;\n\n/** @internal */\nexport function isObjectOrArray(value: []): value is [];\nexport function isObjectOrArray<T>(value: T): value is IsObjectOrArray<T>;\nexport function isObjectOrArray<T>(value: T): boolean {\n  return isArray(value) || isObject(value);\n}\n\n// ----------------------------------------------------------------\n\n/** @internal */\nexport const isNil = (value: unknown): value is null | undefined => {\n  return value == null;\n};\n\n// ----------------------------------------------------------------\n\n/** @internal */\nexport const isBoolean = (value: unknown): value is boolean => {\n  return typeof value === \"boolean\";\n};\n\n// ----------------------------------------------------------------\n\n/** @internal */\nexport const isUndefined = (value: unknown): value is undefined => {\n  return typeof value === \"undefined\";\n};\n\n// ----------------------------------------------------------------\n\n/** @internal */\nexport const isFunction = (value: unknown): value is AnyFunction => {\n  return typeof value === \"function\";\n};\n\n// ----------------------------------------------------------------\n\n/** @internal */\n// eslint-disable-next-line @typescript-eslint/no-wrapper-object-types\nexport const isNumberObject = (value: unknown): value is Number => {\n  return (\n    isObject(value) &&\n    Object.prototype.toString.call(value) === \"[object Number]\"\n  );\n};\n\n// ----------------------------------------------------------------\n\n/** @internal */\n// eslint-disable-next-line @typescript-eslint/no-wrapper-object-types\nexport const isStringObject = (value: unknown): value is String => {\n  return (\n    isObject(value) &&\n    Object.prototype.toString.call(value) === \"[object String]\"\n  );\n};\n\n// ----------------------------------------------------------------\n\n/** @internal */\n// eslint-disable-next-line @typescript-eslint/no-wrapper-object-types\nexport const isBooleanObject = (value: unknown): value is Boolean => {\n  return (\n    isObject(value) &&\n    Object.prototype.toString.call(value) === \"[object Boolean]\"\n  );\n};\n\n// ----------------------------------------------------------------\n\n/** @internal */\nexport const isInfinityNumber = (value: unknown): boolean => {\n  if (typeof value === \"number\" || isNumberObject(value)) {\n    const num = Number(value);\n    return num === Infinity || num === -Infinity;\n  }\n  return false;\n};\n\n// ----------------------------------------------------------------\n\n/** @internal */\nexport const isSymbol = (value: unknown): value is symbol => {\n  return typeof value === \"symbol\";\n};\n\n// ----------------------------------------------------------------\n\n/** @internal */\nexport const isBigInt = (value: unknown): value is bigint => {\n  return typeof value === \"bigint\";\n};\n\n// ----------------------------------------------------------------\n\n/** @internal */\nexport const isNaN = (value: unknown): boolean => {\n  return typeof value === \"number\"\n    ? Number.isNaN(value)\n    : isNumberObject(value) && Number.isNaN(value.valueOf());\n};\n\n// ----------------------------------------------------------------\n\n/** @internal */\ntype IsNonEmptyStringOptions = {\n  /** Whether to trim the string before checking, defaultValue: `true`.\n   *\n   * @default true */\n  trim?: boolean;\n};\n\n/** @internal */\nexport const isNonEmptyString = (\n  value: unknown,\n  options: IsNonEmptyStringOptions = {}\n): value is string => {\n  if (!isString(value)) return false;\n\n  const trim = options.trim ?? true;\n\n  const str = trim ? value.trim() : value;\n\n  return str.length > 0;\n};\n\n// ----------------------------------------------------------------\n\n/** @internal */\ntype IsNumberOptions = {\n  /** If set to `true`, `NaN` will be considered a valid number, defaultValue: `false`.\n   *\n   * @default false\n   */\n  includeNaN?: boolean;\n};\n\n/** @internal */\nexport const isNumber = (\n  value: unknown,\n  options: IsNumberOptions = {}\n): value is number => {\n  const includeNaN =\n    isPlainObject(options) && isBoolean(options.includeNaN)\n      ? options.includeNaN\n      : false;\n\n  const aNumber = typeof value === \"number\";\n  return includeNaN ? aNumber : aNumber && !Number.isNaN(value);\n};\n\n// ----------------------------------------------------------------\n\n/** @internal */\nexport const isError = (error: unknown): error is Error => {\n  return (\n    Object.prototype.toString.call(error) === \"[object Error]\" ||\n    error instanceof Error\n  );\n};\n// ----------------------------------------------------------------\n\n/** @internal */\ntype isDateOptions = {\n  /** * ***Skip the validity check (`!isNaN(date.getTime())`).***\n   *\n   * When `true`, the function only checks that the value is an\n   * instance of `Date` without verifying that it represents a valid\n   * date value, default: `false`.\n   *\n   * @default false\n   */\n  skipInvalidDate?: boolean;\n};\n\n/** @internal */\nexport const isDate = (\n  value: unknown,\n  options: isDateOptions = {}\n): value is Date => {\n  const skipInvalidDate =\n    isPlainObject(options) && isBoolean(options.skipInvalidDate)\n      ? options.skipInvalidDate\n      : false;\n\n  const instanceDate = value instanceof Date;\n\n  if (skipInvalidDate) return instanceDate;\n  return instanceDate && !isNaN(value.getTime());\n};\n\n// ----------------------------------------------------------------\n\n/** @internal */\nexport type SafeStableStringifyOptions = {\n  /** -------------------------------------------------\n   * * ***Whether to sort **object keys** alphabetically (recursively).***\n   * -------------------------------------------------\n   *\n   * - `true` (default): object keys are sorted to ensure stable output.\n   * - `false`: preserves original insertion order of keys.\n   *\n   * @default true\n   */\n  sortKeys?: boolean;\n  /** -------------------------------------------------\n   * * ***Whether to sort **primitive values inside arrays**.***\n   * -------------------------------------------------\n   *\n   * - `true`: primitive values in arrays are sorted to ensure stable output.\n   * - `false` (default): arrays retain their original order; objects and nested arrays are not reordered.\n   *\n   * @default false\n   */\n  sortArray?: boolean;\n  /** -------------------------------------------------\n   * * ***Whether to pretty-print JSON output with 2-space indentation.***\n   * -------------------------------------------------\n   *\n   * - `true`: output is formatted with indentation and newlines.\n   * - `false` (default): produces compact single-line JSON.\n   *\n   * @default false\n   */\n  pretty?: boolean;\n  /** -------------------------------------------------\n   * * ***Preserve `undefined` values instead of converting them to `null`.***\n   * -------------------------------------------------\n   * **Controls how the internal `deepProcess` step rewrites values\n   * **before** the final `JSON.stringify` call.**\n   * - **Default (`false`):**\n   *     * Every `undefined` value (object properties **and** array elements)\n   *       is replaced with `null` **before** serialization, because this happens\n   *       first, the key is **not removed** by `JSON.stringify`.\n   * - **`true`** – Leaves `undefined` untouched so the final\n   *   `JSON.stringify` call behaves natively:\n   *     * Object properties with `undefined` are **removed**.\n   *     * Array elements that are `undefined` become `null`.\n   * @default false\n   * @example\n   * // ✅ keepUndefined = true: behaves like native JSON.stringify\n   * safeStableStringify({ a: undefined }, { keepUndefined: true });\n   * // ➔ '{}' // key removed\n   *\n   * // ✅ Default (false): convert undefined to null, key kept\n   * safeStableStringify({ a: undefined });\n   * // ➔ '{\"a\":null}' // key present, value null\n   *\n   * // Arrays\n   * safeStableStringify([undefined]);\n   * // ➔ '[null]' // same, but via pre-replacement\n   * safeStableStringify([undefined], { keepUndefined: true });\n   * // ➔ '[null]' // element becomes null\n   */\n  keepUndefined?: boolean;\n};\n\n/** @internal */\nexport const safeStableStringify = (\n  value: unknown,\n  options: SafeStableStringifyOptions = {}\n): string => {\n  const pretty = options.pretty ?? false;\n  const sortKeys = options.sortKeys ?? true;\n  const sortArray = options.sortArray ?? false;\n  const keepUndefined = options.keepUndefined ?? false;\n\n  if (isUndefined(value)) {\n    return keepUndefined ? \"undefined\" : \"null\";\n  }\n\n  const seen = new WeakSet();\n\n  const isPrimitive = (val: unknown): boolean =>\n    isNull(val) || (!isObjectOrArray(val) && !isFunction(val));\n\n  const deepProcess = (val: unknown): unknown => {\n    if (isNumberObject(val)) {\n      const valOf = val.valueOf();\n      return isNaN(valOf) || isInfinityNumber(valOf) ? null : valOf;\n    }\n    if (isStringObject(val)) return val.valueOf();\n    if (isBooleanObject(val)) return val.valueOf();\n    if (isFunction(val) || isSymbol(val)) return undefined;\n    if (isBigInt(val)) return val.toString();\n    if (isNaN(val) || isInfinityNumber(val)) return null;\n    if (isUndefined(val)) {\n      return keepUndefined ? undefined : null;\n    }\n\n    if (isObjectOrArray(val)) {\n      if (seen.has(val)) return \"[Circular]\";\n      seen.add(val);\n\n      if (isDate(val)) return val.toISOString();\n      if (isMap(val)) {\n        return {\n          map: Array.from(val.entries()).map(([k, v]) => [k, deepProcess(v)])\n        };\n      }\n      if (isSet(val)) return { set: Array.from(val.values()).map(deepProcess) };\n\n      if (isArray(val)) {\n        const processedArr = val.map(deepProcess);\n        if (sortArray) {\n          const primitives: unknown[] = [];\n          const nonPrimitives: unknown[] = [];\n\n          for (const item of processedArr) {\n            if (isPrimitive(item)) primitives.push(item);\n            else nonPrimitives.push(item);\n          }\n          primitives.sort((a, b) => {\n            if (isNumber(a) && isNumber(b)) return a - b;\n            return String(a).localeCompare(String(b));\n          });\n          return [...primitives, ...nonPrimitives];\n        }\n        return processedArr;\n      }\n\n      const keys = Object.keys(val);\n      if (sortKeys) {\n        keys.sort((a, b) => {\n          const na = Number(a);\n          const nb = Number(b);\n          if (!isNaN(na) && !isNaN(nb)) return na - nb;\n          return a.localeCompare(b);\n        });\n      }\n\n      const result: Record<string, unknown> = {};\n\n      if (isObject(val)) {\n        for (const k of keys) {\n          const v = deepProcess(val[k]);\n          if (!isUndefined(v)) result[k] = v;\n        }\n      }\n\n      return result;\n    }\n\n    return val;\n  };\n\n  try {\n    return JSON.stringify(deepProcess(value), null, pretty ? 2 : 0);\n  } catch (err) {\n    console.warn(\"Error in safeStableStringify:\", err);\n    return \"{}\";\n  }\n};\n\n// ----------------------------------------------------------------\n\n/** @internal */\ntype NormalizeSpacesOptions = {\n  /** If `true`, skips normalization and only trims whitespace from start & end, defaultValue: `false`.\n   *\n   * @default false\n   */\n  trimOnly?: boolean;\n  /** If `false`, skips trimming value, defaultValue: `true`.\n   *\n   * @default true\n   */\n  withTrim?: boolean;\n};\n\n/** @internal */\nexport const normalizeSpaces = (\n  value: string | null | undefined,\n  options: NormalizeSpacesOptions = {\n    withTrim: true,\n    trimOnly: false\n  }\n): string => {\n  if (!isNonEmptyString(value)) return \"\";\n\n  if (!isPlainObject(options)) {\n    options = {};\n  }\n\n  const { trimOnly = false, withTrim = true } = options;\n\n  if (trimOnly) return value.trim();\n\n  if (withTrim) {\n    value = value.trim();\n  }\n\n  // Remove all duplicate spaces (including tabs, newlines, etc.)\n  return value.replace(/\\s+/g, \" \");\n};\n\n// ----------------------------------------------------------------\n\n/** ----------------------------------------------------------------\n * * ***Checks whether a value is an array of strings.***\n * ----------------------------------------------------------------\n *\n * Type guard that validates the input is an `Array` where **all**\n * elements are strings.\n *\n * @param {unknown} v - The value to test.\n *\n * @returns {boolean} `true` if the value is a `string[]`.\n *\n * @internal\n */\nexport const isStringArray = (v: unknown): v is string[] =>\n  isArray(v) && v.every((i) => isString(i));\n\n/** ----------------------------------------------------------------\n * * ***Checks whether a value is a Set of strings.***\n * ----------------------------------------------------------------\n *\n * Type guard that validates the input is a `Set` where **all**\n * entries are strings.\n *\n * @param {unknown} v - The value to test.\n *\n * @returns {boolean} `true` if the value is a `Set<string>`.\n *\n * @internal\n */\nexport const isStringSet = (v: unknown): v is Set<string> =>\n  isSet(v) && [...v].every((i) => isString(i));\n\n/** ----------------------------------------------------------------\n * * ***Asserts that a value is a valid pattern input.***\n * ----------------------------------------------------------------\n *\n * Runtime assertion that validates the provided value is one of the\n * supported pattern types:\n * - `string`.\n * - `string[]`.\n * - `Set<string>`.\n *\n * This function is intended to be used at API boundaries to ensure\n * type safety before further processing.\n *\n * @param {unknown} v - The value to validate.\n * @param {string|undefined} parameterKey - The key parameter to identity which is invalid, default `\"pattern\"`.\n *\n * @throws {TypeError} If the value is not a valid pattern input.\n *\n * @example\n * ```ts\n * assertValidatePatternArgs(pattern);\n * // pattern is now typed as:\n * // string | string[] | Set<string>\n * ```\n *\n * @internal\n */\nexport const assertValidatePatternArgs: (\n  v: unknown,\n  parameterKey?: string\n) => asserts v is string | string[] | Set<string> = (\n  v: unknown,\n  parameterKey: string = \"pattern\"\n) => {\n  if (!isString(v) && !isStringArray(v) && !isStringSet(v)) {\n    throw new TypeError(\n      `The \\`${parameterKey}\\` argument must be a string, string[] or Set<string>.`\n    );\n  }\n};\n\n/** ----------------------------------------------------------------\n * * ***Flattens nested arrays and extracts string values only.***\n * ----------------------------------------------------------------\n *\n * Recursively flattens an input array to **infinite depth** and\n * filters out all non-string values.\n *\n * - *Normalization rules:*\n *    - Nested arrays are flattened using `Array.prototype.flat(Infinity)`.\n *    - Only values with `typeof === \"string\"` are kept.\n *    - Non-string values are discarded.\n *\n * The returned array is always a **new instance** and does not mutate\n * the original input.\n *\n * @param {readonly unknown[]} input - Arbitrary nested array input.\n *\n * @returns {string[]} A flat array containing only string values.\n *\n * @example\n * ```ts\n * flattenStrings([\"a\", [\"b\", [\"c\"]], 1, null]);\n * // ➔ [\"a\", \"b\", \"c\"]\n * ```\n *\n * @internal\n */\nexport const flattenStrings = (input: readonly unknown[]): string[] => {\n  return input.flat(Infinity).filter((v): v is string => typeof v === \"string\");\n};\n\n/** ----------------------------------------------------------------\n * * ***Normalizes pattern input into a new `Set<string>` instance.***\n * ----------------------------------------------------------------\n *\n * Converts a pattern value into a deduplicated `Set<string>` for\n * consistent internal handling.\n *\n * #### Normalization behavior\n * - `string` ➔ wrapped into a `Set`.\n * - `string[]` ➔ converted into a `Set` (duplicates removed).\n * - `Set<string>` ➔ cloned into a new `Set`.\n *\n * The returned set is **always a new instance** and the original\n * input is never mutated.\n *\n * #### Validation\n * When `withValidationType` is `true` (default), the input will be\n * validated before normalization.\n *\n * If the provided `pattern` is not one of the supported types,\n * a `TypeError` will be thrown.\n *\n * @param pattern - Pattern value to normalize.\n * @param options - Optional configuration object.\n * @param options.withValidationType - Whether to validate the input\n * before normalization. Defaults to `true`.\n * @param options.parameterKey - The key parameter to identity which is invalid, default `\"pattern\"`.\n *\n * @returns A new deduplicated `Set<string>` instance.\n *\n * @throws {TypeError}\n * Thrown when `pattern` is not a `string`, `string[]`, or `Set<string>`\n * and validation is enabled.\n *\n * @example\n * ```ts\n * toStringSet(\"a\");\n * // ➔ Set { \"a\" }\n * ```\n *\n * @example\n * ```ts\n * toStringSet([\"a\", \"b\", \"a\"]);\n * // ➔ Set { \"a\", \"b\" }\n * ```\n *\n * @example\n * ```ts\n * toStringSet(new Set([\"x\", \"y\"]));\n * // ➔ Set { \"x\", \"y\" }\n * ```\n *\n * @example\n * ```ts\n * toStringSet(123 as any);\n * // ❌ Throws TypeError\n * ```\n *\n * @example\n * ```ts\n * // Disable validation (use cautiously)\n * toStringSet(\"a\", { withValidationType: false });\n * toStringSet(123 as any, { withValidationType: false });\n * ```\n *\n * @internal\n */\nexport const toStringSet = (\n  pattern: string | string[] | Set<string>,\n  options: {\n    withValidationType?: boolean;\n    /**\n     * The key parameter to identity which is invalid.\n     *\n     * @default \"pattern\"\n     */\n    parameterKey?: string;\n  } = {}\n): Set<string> => {\n  const { withValidationType = true, parameterKey = \"pattern\" } = options;\n  if (withValidationType) assertValidatePatternArgs(pattern, parameterKey);\n\n  return toObjectSet(pattern);\n};\n\n/** ----------------------------------------------------------------\n * * ***Normalizes a value into a deduplicated `Set`.***\n * ----------------------------------------------------------------\n *\n * Converts a single value, array, or existing `Set` into a `Set<T>`\n * for consistent internal handling.\n *\n * - *Normalization rules:*\n *    - `T` ➔ wrapped in a `Set`.\n *    - `T[]` ➔ converted to a `Set` (duplicates removed).\n *    - `Set<T>` ➔ returned as-is.\n *\n * The returned `Set` is **not mutated** internally by this function.\n * If an existing `Set` is provided, it will be reused.\n *\n * @typeParam T - Value type stored in the set.\n *\n * @param {T | T[] | Set<T>} value - Value to normalize.\n *\n * @returns {Set<T>} A deduplicated set of values.\n *\n * @example\n * ```ts\n * toObjectSet(1);\n * // ➔ Set { 1 }\n * ```\n *\n * @example\n * ```ts\n * toObjectSet([1, 2, 1]);\n * // ➔ Set { 1, 2 }\n * ```\n *\n * @example\n * ```ts\n * toObjectSet(new Set([1, 2]));\n * // ➔ Set { 1, 2 }\n * ```\n *\n * @internal\n */\nexport const toObjectSet = <T>(value: T | T[] | Set<T>): Set<T> => {\n  if (isSet(value)) return value;\n\n  return new Set(isArray(value) ? value : [value]);\n};\n\n/** ----------------------------------------------------------------\n * * ***Normalize a value into an array.***\n * ----------------------------------------------------------------\n *\n * Converts a single value or an array-like value into a **new array**\n * with consistent typing.\n *\n * - If `value` is already an array ➔ returned as-is.\n * - If `value` is a single item ➔ wrapped in an array.\n *\n * This utility is useful for APIs or configs that accept\n * either a single value or multiple values.\n *\n * ----------------------------------------------------------------\n *\n * @typeParam T\n * The element type of the resulting array.\n *\n * @param value\n * A value or array of values.\n *\n * @returns\n * A normalized array of type `T[]`.\n *\n * ----------------------------------------------------------------\n *\n * @example\n * ```ts\n * toArray(1);\n * // ➔ [1]\n *\n * toArray(\"hello\");\n * // ➔ [\"hello\"]\n *\n * toArray([1, 2, 3]);\n * // ➔ [1, 2, 3]\n * ```\n *\n * @example\n * ```ts\n * type User = { id: number };\n *\n * toArray<User>({ id: 1 });\n * // ➔ [{ id: 1 }]\n *\n * toArray<User>([{ id: 1 }, { id: 2 }]);\n * // ➔ [{ id: 1 }, { id: 2 }]\n * ```\n *\n * @remarks\n * This function does **not** flatten nested arrays.\n * If `value` is already an array, the original reference is preserved.\n *\n * @internal\n */\nexport const toArray = <T>(value: Arrayable<T>): T[] => {\n  return isArray(value) ? value : [value];\n};\n"],"mappings":"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"}