@hot-updater/firebase 0.33.0 → 0.33.1

package/dist/iac/index.cjs

@@ -47,14 +47,48 @@ let node_stream = require("node:stream");
 let node_buffer = require("node:buffer");
 let node_fs_promises = require("node:fs/promises");
 node_fs_promises = __toESM(node_fs_promises);
-//#region ../../node_modules/.pnpm/es-toolkit@1.32.0/node_modules/es-toolkit/dist/_internal/compareValues.mjs
+//#region ../../node_modules/.pnpm/es-toolkit@1.47.0/node_modules/es-toolkit/dist/_internal/compareValues.mjs
 function compareValues(a, b, order) {
 	if (a < b) return order === "asc" ? -1 : 1;
 	if (a > b) return order === "asc" ? 1 : -1;
 	return 0;
 }
 //#endregion
-//#region ../../node_modules/.pnpm/es-toolkit@1.32.0/node_modules/es-toolkit/dist/array/orderBy.mjs
+//#region ../../node_modules/.pnpm/es-toolkit@1.47.0/node_modules/es-toolkit/dist/array/orderBy.mjs
+/**
+* Sorts an array of objects based on the given `criteria` and their corresponding order directions.
+*
+* - If you provide keys, it sorts the objects by the values of those keys.
+* - If you provide functions, it sorts based on the values returned by those functions.
+*
+* The function returns the array of objects sorted in corresponding order directions.
+* If two objects have the same value for the current criterion, it uses the next criterion to determine their order.
+* If the number of orders is less than the number of criteria, it uses the last order for the rest of the criteria.
+*
+* @template T - The type of elements in the array.
+* @param {T[]} arr - The array of objects to be sorted.
+* @param {Array<((item: T) => unknown) | keyof T>} criteria  - The criteria for sorting. This can be an array of object keys or functions that return values used for sorting.
+* @param {Array<'asc' | 'desc'>} orders - An array of order directions ('asc' for ascending or 'desc' for descending).
+* @returns {T[]} - The sorted array.
+*
+* @example
+* // Sort an array of objects by 'user' in ascending order and 'age' in descending order.
+* const users = [
+*   { user: 'fred', age: 48 },
+*   { user: 'barney', age: 34 },
+*   { user: 'fred', age: 40 },
+*   { user: 'barney', age: 36 },
+* ];
+*
+* const result = orderBy(users, [obj => obj.user, 'age'], ['asc', 'desc']);
+* // result will be:
+* // [
+* //   { user: 'barney', age: 36 },
+* //   { user: 'barney', age: 34 },
+* //   { user: 'fred', age: 48 },
+* //   { user: 'fred', age: 40 },
+* // ]
+*/
 function orderBy(arr, criteria, orders) {
 	return arr.slice().sort((a, b) => {
 		const ordersLength = orders.length;
@@ -69,12 +103,59 @@ function orderBy(arr, criteria, orders) {
 	});
 }
 //#endregion
-//#region ../../node_modules/.pnpm/es-toolkit@1.32.0/node_modules/es-toolkit/dist/array/sortBy.mjs
+//#region ../../node_modules/.pnpm/es-toolkit@1.47.0/node_modules/es-toolkit/dist/array/sortBy.mjs
+/**
+* Sorts an array of objects based on the given `criteria`.
+*
+* - If you provide keys, it sorts the objects by the values of those keys.
+* - If you provide functions, it sorts based on the values returned by those functions.
+*
+* The function returns the array of objects sorted in ascending order.
+* If two objects have the same value for the current criterion, it uses the next criterion to determine their order.
+*
+* @template T - The type of the objects in the array.
+* @param {T[]} arr - The array of objects to be sorted.
+* @param {Array<((item: T) => unknown) | keyof T>} criteria - The criteria for sorting. This can be an array of object keys or functions that return values used for sorting.
+* @returns {T[]} - The sorted array.
+*
+* @example
+* const users = [
+*  { user: 'foo', age: 24 },
+*  { user: 'bar', age: 7 },
+*  { user: 'foo', age: 8 },
+*  { user: 'bar', age: 29 },
+* ];
+*
+* sortBy(users, ['user', 'age']);
+* sortBy(users, [obj => obj.user, 'age']);
+* // results will be:
+* // [
+* //   { user : 'bar', age: 7 },
+* //   { user : 'bar', age: 29 },
+* //   { user : 'foo', age: 8 },
+* //   { user : 'foo', age: 24 },
+* // ]
+*/
 function sortBy(arr, criteria) {
 	return orderBy(arr, criteria, ["asc"]);
 }
 //#endregion
-//#region ../../node_modules/.pnpm/es-toolkit@1.32.0/node_modules/es-toolkit/dist/array/uniqWith.mjs
+//#region ../../node_modules/.pnpm/es-toolkit@1.47.0/node_modules/es-toolkit/dist/array/uniqWith.mjs
+/**
+* Returns a new array containing only the unique elements from the original array,
+* based on the values returned by the comparator function.
+*
+* @template T - The type of elements in the array.
+* @param {T[]} arr - The array to process.
+* @param {(item1: T, item2: T) => boolean} areItemsEqual - The function used to compare the array elements.
+* @returns {T[]} A new array containing only the unique elements from the original array, based on the values returned by the comparator function.
+*
+* @example
+* ```ts
+* uniqWith([1.2, 1.5, 2.1, 3.2, 5.7, 5.3, 7.19], (a, b) => Math.abs(a - b) < 1);
+* // [1.2, 3.2, 5.7, 7.19]
+* ```
+*/
 function uniqWith(arr, areItemsEqual) {
 	const result = [];
 	for (let i = 0; i < arr.length; i++) {
@@ -84,21 +165,65 @@ function uniqWith(arr, areItemsEqual) {
 	return result;
 }
 //#endregion
-//#region ../../node_modules/.pnpm/es-toolkit@1.32.0/node_modules/es-toolkit/dist/function/noop.mjs
+//#region ../../node_modules/.pnpm/es-toolkit@1.47.0/node_modules/es-toolkit/dist/_internal/globalThis.mjs
+const globalThis_ = typeof globalThis === "object" && globalThis || typeof window === "object" && window || typeof self === "object" && self || typeof global === "object" && global || (function() {
+	return this;
+})() || Function("return this")();
+//#endregion
+//#region ../../node_modules/.pnpm/es-toolkit@1.47.0/node_modules/es-toolkit/dist/function/noop.mjs
+/**
+* A no-operation function that does nothing.
+* This can be used as a placeholder or default function.
+*
+* @example
+* noop(); // Does nothing
+*
+* @returns {void} This function does not return anything.
+*/
 function noop$2() {}
 //#endregion
-//#region ../../node_modules/.pnpm/es-toolkit@1.32.0/node_modules/es-toolkit/dist/compat/_internal/getSymbols.mjs
+//#region ../../node_modules/.pnpm/es-toolkit@1.47.0/node_modules/es-toolkit/dist/predicate/isBuffer.mjs
+/**
+* Checks if the given value is a Buffer instance.
+*
+* This function tests whether the provided value is an instance of Buffer.
+* It returns `true` if the value is a Buffer, and `false` otherwise.
+*
+* This function can also serve as a type predicate in TypeScript, narrowing the type of the argument to `Buffer`.
+*
+* @param {unknown} x - The value to check if it is a Buffer.
+* @returns {boolean} Returns `true` if `x` is a Buffer, else `false`.
+*
+* @example
+* const buffer = Buffer.from("test");
+* console.log(isBuffer(buffer)); // true
+*
+* const notBuffer = "not a buffer";
+* console.log(isBuffer(notBuffer)); // false
+*/
+function isBuffer(x) {
+	return typeof globalThis_.Buffer !== "undefined" && globalThis_.Buffer.isBuffer(x);
+}
+//#endregion
+//#region ../../node_modules/.pnpm/es-toolkit@1.47.0/node_modules/es-toolkit/dist/compat/_internal/getSymbols.mjs
 function getSymbols(object) {
 	return Object.getOwnPropertySymbols(object).filter((symbol) => Object.prototype.propertyIsEnumerable.call(object, symbol));
 }
 //#endregion
-//#region ../../node_modules/.pnpm/es-toolkit@1.32.0/node_modules/es-toolkit/dist/compat/_internal/getTag.mjs
+//#region ../../node_modules/.pnpm/es-toolkit@1.47.0/node_modules/es-toolkit/dist/compat/_internal/getTag.mjs
+/**
+* Gets the `toStringTag` of `value`.
+*
+* @private
+* @param {T} value The value to query.
+* @returns {string} Returns the `Object.prototype.toString.call` result.
+*/
 function getTag(value) {
 	if (value == null) return value === void 0 ? "[object Undefined]" : "[object Null]";
 	return Object.prototype.toString.call(value);
 }
 //#endregion
-//#region ../../node_modules/.pnpm/es-toolkit@1.32.0/node_modules/es-toolkit/dist/compat/_internal/tags.mjs
+//#region ../../node_modules/.pnpm/es-toolkit@1.47.0/node_modules/es-toolkit/dist/compat/_internal/tags.mjs
 const regexpTag = "[object RegExp]";
 const stringTag = "[object String]";
 const numberTag = "[object Number]";
@@ -125,7 +250,49 @@ const bigInt64ArrayTag = "[object BigInt64Array]";
 const float32ArrayTag = "[object Float32Array]";
 const float64ArrayTag = "[object Float64Array]";
 //#endregion
-//#region ../../node_modules/.pnpm/es-toolkit@1.32.0/node_modules/es-toolkit/dist/predicate/isPlainObject.mjs
+//#region ../../node_modules/.pnpm/es-toolkit@1.47.0/node_modules/es-toolkit/dist/predicate/isPlainObject.mjs
+/**
+* Checks if a given value is a plain object.
+*
+* @param {object} value - The value to check.
+* @returns {value is Record<PropertyKey, any>} - True if the value is a plain object, otherwise false.
+*
+* @example
+* ```typescript
+* // ✅👇 True
+*
+* isPlainObject({ });                       // ✅
+* isPlainObject({ key: 'value' });          // ✅
+* isPlainObject({ key: new Date() });       // ✅
+* isPlainObject(new Object());              // ✅
+* isPlainObject(Object.create(null));       // ✅
+* isPlainObject({ nested: { key: true} });  // ✅
+* isPlainObject(new Proxy({}, {}));         // ✅
+* isPlainObject({ [Symbol('tag')]: 'A' });  // ✅
+*
+* // ✅👇 (cross-realms, node context, workers, ...)
+* const runInNewContext = await import('node:vm').then(
+*     (mod) => mod.runInNewContext
+* );
+* isPlainObject(runInNewContext('({})'));   // ✅
+*
+* // ❌👇 False
+*
+* class Test { };
+* isPlainObject(new Test())           // ❌
+* isPlainObject(10);                  // ❌
+* isPlainObject(null);                // ❌
+* isPlainObject('hello');             // ❌
+* isPlainObject([]);                  // ❌
+* isPlainObject(new Date());          // ❌
+* isPlainObject(new Uint8Array([1])); // ❌
+* isPlainObject(Buffer.from('ABC'));  // ❌
+* isPlainObject(Promise.resolve({})); // ❌
+* isPlainObject(Object.create({}));   // ❌
+* isPlainObject(new (class Cls {}));  // ❌
+* isPlainObject(globalThis);          // ❌,
+* ```
+*/
 function isPlainObject$1(value) {
 	if (!value || typeof value !== "object") return false;
 	const proto = Object.getPrototypeOf(value);
@@ -133,28 +300,134 @@ function isPlainObject$1(value) {
 	return Object.prototype.toString.call(value) === "[object Object]";
 }
 //#endregion
-//#region ../../node_modules/.pnpm/es-toolkit@1.32.0/node_modules/es-toolkit/dist/object/merge.mjs
+//#region ../../node_modules/.pnpm/es-toolkit@1.47.0/node_modules/es-toolkit/dist/_internal/isUnsafeProperty.mjs
+/**
+* Checks if a property key is unsafe to modify directly.
+*
+* This function is used in functions like `merge` to prevent prototype pollution attacks
+* by identifying property keys that could modify the object's prototype chain or constructor.
+*
+* @param key - The property key to check
+* @returns `true` if the property is unsafe to modify directly, `false` otherwise
+* @internal
+*/
+function isUnsafeProperty(key) {
+	return key === "__proto__";
+}
+//#endregion
+//#region ../../node_modules/.pnpm/es-toolkit@1.47.0/node_modules/es-toolkit/dist/object/merge.mjs
+/**
+* Merges the properties of the source object into the target object.
+*
+* This function performs a deep merge, meaning nested objects and arrays are merged recursively.
+* If a property in the source object is an array or an object and the corresponding property in the target object is also an array or object, they will be merged.
+* If a property in the source object is undefined, it will not overwrite a defined property in the target object.
+*
+* Note that this function mutates the target object.
+*
+* @param {T} target - The target object into which the source object properties will be merged. This object is modified in place.
+* @param {S} source - The source object whose properties will be merged into the target object.
+* @returns {T & S} The updated target object with properties from the source object merged in.
+*
+* @template T - Type of the target object.
+* @template S - Type of the source object.
+*
+* @example
+* const target = { a: 1, b: { x: 1, y: 2 } };
+* const source = { b: { y: 3, z: 4 }, c: 5 };
+*
+* const result = merge(target, source);
+* console.log(result);
+* // Output: { a: 1, b: { x: 1, y: 3, z: 4 }, c: 5 }
+*
+* @example
+* const target = { a: [1, 2], b: { x: 1 } };
+* const source = { a: [3], b: { y: 2 } };
+*
+* const result = merge(target, source);
+* console.log(result);
+* // Output: { a: [3, 2], b: { x: 1, y: 2 } }
+*
+* @example
+* const target = { a: null };
+* const source = { a: [1, 2, 3] };
+*
+* const result = merge(target, source);
+* console.log(result);
+* // Output: { a: [1, 2, 3] }
+*/
 function merge(target, source) {
 	const sourceKeys = Object.keys(source);
 	for (let i = 0; i < sourceKeys.length; i++) {
 		const key = sourceKeys[i];
+		if (isUnsafeProperty(key)) continue;
 		const sourceValue = source[key];
 		const targetValue = target[key];
-		if (Array.isArray(sourceValue)) if (Array.isArray(targetValue)) target[key] = merge(targetValue, sourceValue);
-		else target[key] = merge([], sourceValue);
-		else if (isPlainObject$1(sourceValue)) if (isPlainObject$1(targetValue)) target[key] = merge(targetValue, sourceValue);
-		else target[key] = merge({}, sourceValue);
+		if (isMergeableValue(sourceValue) && isMergeableValue(targetValue)) target[key] = merge(targetValue, sourceValue);
+		else if (Array.isArray(sourceValue)) target[key] = merge([], sourceValue);
+		else if (isPlainObject$1(sourceValue)) target[key] = merge({}, sourceValue);
 		else if (targetValue === void 0 || sourceValue !== void 0) target[key] = sourceValue;
 	}
 	return target;
 }
+function isMergeableValue(value) {
+	return isPlainObject$1(value) || Array.isArray(value);
+}
 //#endregion
-//#region ../../node_modules/.pnpm/es-toolkit@1.32.0/node_modules/es-toolkit/dist/compat/util/eq.mjs
-function eq(value, other) {
+//#region ../../node_modules/.pnpm/es-toolkit@1.47.0/node_modules/es-toolkit/dist/_internal/isEqualsSameValueZero.mjs
+/**
+* Performs a `SameValueZero` comparison between two values to determine if they are equivalent.
+*
+* @param {any} value - The value to compare.
+* @param {any} other - The other value to compare.
+* @returns {boolean} Returns `true` if the values are equivalent, else `false`.
+*
+* @example
+* eq(1, 1); // true
+* eq(0, -0); // true
+* eq(NaN, NaN); // true
+* eq('a', Object('a')); // false
+*/
+function isEqualsSameValueZero(value, other) {
 	return value === other || Number.isNaN(value) && Number.isNaN(other);
 }
 //#endregion
-//#region ../../node_modules/.pnpm/es-toolkit@1.32.0/node_modules/es-toolkit/dist/predicate/isEqualWith.mjs
+//#region ../../node_modules/.pnpm/es-toolkit@1.47.0/node_modules/es-toolkit/dist/predicate/isEqualWith.mjs
+/**
+* Compares two values for equality using a custom comparison function.
+*
+* The custom function allows for fine-tuned control over the comparison process. If it returns a boolean, that result determines the equality. If it returns undefined, the function falls back to the default equality comparison.
+*
+* This function also uses the custom equality function to compare values inside objects,
+* arrays, maps, sets, and other complex structures, ensuring a deep comparison.
+*
+* This approach provides flexibility in handling complex comparisons while maintaining efficient default behavior for simpler cases.
+*
+* The custom comparison function can take up to six parameters:
+* - `x`: The value from the first object `a`.
+* - `y`: The value from the second object `b`.
+* - `property`: The property key used to get `x` and `y`.
+* - `xParent`: The parent of the first value `x`.
+* - `yParent`: The parent of the second value `y`.
+* - `stack`: An internal stack (Map) to handle circular references.
+*
+* @param {unknown} a - The first value to compare.
+* @param {unknown} b - The second value to compare.
+* @param {(x: any, y: any, property?: PropertyKey, xParent?: any, yParent?: any, stack?: Map<any, any>) => boolean | void} areValuesEqual - A function to customize the comparison.
+*   If it returns a boolean, that result will be used. If it returns undefined,
+*   the default equality comparison will be used.
+* @returns {boolean} `true` if the values are equal according to the customizer, otherwise `false`.
+*
+* @example
+* const customizer = (a, b) => {
+*   if (typeof a === 'string' && typeof b === 'string') {
+*     return a.toLowerCase() === b.toLowerCase();
+*   }
+* };
+* isEqualWith('Hello', 'hello', customizer); // true
+* isEqualWith({ a: 'Hello' }, { a: 'hello' }, customizer); // true
+* isEqualWith([1, 2, 3], [1, 2, 3], customizer); // true
+*/
 function isEqualWith(a, b, areValuesEqual) {
 	return isEqualWithImpl(a, b, void 0, void 0, void 0, void 0, areValuesEqual);
 }
@@ -182,7 +455,7 @@ function areObjectsEqual(a, b, stack, areValuesEqual) {
 	if (aTag !== bTag) return false;
 	switch (aTag) {
 		case stringTag: return a.toString() === b.toString();
-		case numberTag: return eq(a.valueOf(), b.valueOf());
+		case numberTag: return isEqualsSameValueZero(a.valueOf(), b.valueOf());
 		case booleanTag:
 		case dateTag:
 		case symbolTag: return Object.is(a.valueOf(), b.valueOf());
@@ -227,7 +500,7 @@ function areObjectsEqual(a, b, stack, areValuesEqual) {
 			case bigInt64ArrayTag:
 			case float32ArrayTag:
 			case float64ArrayTag:
-				if (typeof Buffer !== "undefined" && Buffer.isBuffer(a) !== Buffer.isBuffer(b)) return false;
+				if (isBuffer(a) !== isBuffer(b)) return false;
 				if (a.length !== b.length) return false;
 				for (let i = 0; i < a.length; i++) if (!isEqualWithImpl(a[i], b[i], i, a, b, stack, areValuesEqual)) return false;
 				return true;
@@ -260,7 +533,21 @@ function areObjectsEqual(a, b, stack, areValuesEqual) {
 	}
 }
 //#endregion
-//#region ../../node_modules/.pnpm/es-toolkit@1.32.0/node_modules/es-toolkit/dist/predicate/isEqual.mjs
+//#region ../../node_modules/.pnpm/es-toolkit@1.47.0/node_modules/es-toolkit/dist/predicate/isEqual.mjs
+/**
+* Checks if two values are equal, including support for `Date`, `RegExp`, and deep object comparison.
+*
+* @param {unknown} a - The first value to compare.
+* @param {unknown} b - The second value to compare.
+* @returns {boolean} `true` if the values are equal, otherwise `false`.
+*
+* @example
+* isEqual(1, 1); // true
+* isEqual({ a: 1 }, { a: 1 }); // true
+* isEqual(/abc/g, /abc/g); // true
+* isEqual(new Date('2020-01-01'), new Date('2020-01-01')); // true
+* isEqual([1, 2, 3], [1, 2, 3]); // true
+*/
 function isEqual(a, b) {
 	return isEqualWith(a, b, noop$2);
 }
@@ -838,7 +1125,7 @@ const fallbackSymbols = {
 const figures = isUnicodeSupported() ? mainSymbols : fallbackSymbols;
 Object.entries(specialMainSymbols);
 //#endregion
-//#region ../../node_modules/.pnpm/yoctocolors@2.1.1/node_modules/yoctocolors/base.js
+//#region ../../node_modules/.pnpm/yoctocolors@2.1.2/node_modules/yoctocolors/base.js
 const hasColors = node_tty.default?.WriteStream?.prototype?.hasColors?.() ?? false;
 const format = (open, close) => {
 	if (!hasColors) return (input) => input;
@@ -850,8 +1137,9 @@ const format = (open, close) => {
 		if (index === -1) return openCode + string + closeCode;
 		let result = openCode;
 		let lastIndex = 0;
+		const replaceCode = (close === 22 ? closeCode : "") + openCode;
 		while (index !== -1) {
-			result += string.slice(lastIndex, index) + openCode;
+			result += string.slice(lastIndex, index) + replaceCode;
 			lastIndex = index + closeCode.length;
 			index = string.indexOf(closeCode, lastIndex);
 		}
@@ -3251,7 +3539,7 @@ function parseMilliseconds(milliseconds) {
 	throw new TypeError("Expected a finite number or bigint");
 }
 //#endregion
-//#region ../../node_modules/.pnpm/pretty-ms@9.2.0/node_modules/pretty-ms/index.js
+//#region ../../node_modules/.pnpm/pretty-ms@9.3.0/node_modules/pretty-ms/index.js
 const isZero = (value) => value === 0 || value === 0n;
 const pluralize = (word, count) => count === 1 || count === 1n ? word : `${word}s`;
 const SECOND_ROUNDING_EPSILON = 1e-7;
@@ -3300,7 +3588,7 @@ function prettyMilliseconds(milliseconds, options) {
 		add(Number(parsed.hours), "hour", "h");
 	}
 	add(Number(parsed.minutes), "minute", "m");
-	if (!options.hideSeconds) if (options.separateMilliseconds || options.formatSubMilliseconds || !options.colonNotation && milliseconds < 1e3) {
+	if (!options.hideSeconds) if (options.separateMilliseconds || options.formatSubMilliseconds || !options.colonNotation && milliseconds < 1e3 && !options.subSecondsAsDecimals) {
 		const seconds = Number(parsed.seconds);
 		const milliseconds = Number(parsed.milliseconds);
 		const microseconds = Number(parsed.microseconds);