@ix-xs/node-comfort 1.1.3 → 1.2.0

package/types/src/Arr.d.ts

@@ -0,0 +1,252 @@
+/**
+ * Splits an array into chunks of a given size.
+ *
+ * @example
+ * nodeComfort.arr.chunk([1, 2, 3, 4, 5], 2); // [[1, 2], [3, 4], [5]]
+ *
+ * @param {any[]} array - Source array.
+ * @param {number} size - Chunk size (must be >= 1).
+ * @returns {any[][]} The chunked array.
+ */
+export function chunk(array: any[], size: number): any[][];
+/**
+ * Returns a new array with duplicate values removed.
+ *
+ * Pass an `iteratee` to de-duplicate by a derived key.
+ *
+ * @example
+ * nodeComfort.arr.unique([1, 1, 2, 3]);                       // [1, 2, 3]
+ * nodeComfort.arr.unique([{ id: 1 }, { id: 1 }], "id");       // [{ id: 1 }]
+ *
+ * @param {any[]} array - Source array.
+ * @param {string|((item: any) => any)} [iteratee] - Key or function to compare by.
+ * @returns {any[]} The de-duplicated array.
+ */
+export function unique(array: any[], iteratee?: string | ((item: any) => any)): any[];
+/**
+ * Groups the items of an array by a key or function.
+ *
+ * @example
+ * nodeComfort.arr.groupBy([1, 2, 3, 4], (n) => (n % 2 ? "odd" : "even"));
+ * // { odd: [1, 3], even: [2, 4] }
+ *
+ * @param {any[]} array - Source array.
+ * @param {string|((item: any) => any)} iteratee - Key or function to group by.
+ * @returns {Record<string, any[]>} The grouped object.
+ */
+export function groupBy(array: any[], iteratee: string | ((item: any) => any)): Record<string, any[]>;
+/**
+ * Builds an object keyed by a derived value, mapping each key to the
+ * (last) matching item.
+ *
+ * @example
+ * nodeComfort.arr.keyBy([{ id: "a" }, { id: "b" }], "id");
+ * // { a: { id: "a" }, b: { id: "b" } }
+ *
+ * @param {any[]} array - Source array.
+ * @param {string|((item: any) => any)} iteratee - Key or function.
+ * @returns {Record<string, any>} The keyed object.
+ */
+export function keyBy(array: any[], iteratee: string | ((item: any) => any)): Record<string, any>;
+/**
+ * Partitions an array into two groups based on a predicate:
+ * `[matching, notMatching]`.
+ *
+ * @example
+ * nodeComfort.arr.partition([1, 2, 3, 4], (n) => n % 2 === 0);
+ * // [[2, 4], [1, 3]]
+ *
+ * @param {any[]} array - Source array.
+ * @param {(item: any, index: number) => boolean} predicate - Test function.
+ * @returns {[any[], any[]]} The two partitions.
+ */
+export function partition(array: any[], predicate: (item: any, index: number) => boolean): [any[], any[]];
+/**
+ * Recursively flattens a nested array up to a given depth.
+ *
+ * @example
+ * nodeComfort.arr.flatten([1, [2, [3, [4]]]]);      // [1, 2, 3, [4]]
+ * nodeComfort.arr.flatten([1, [2, [3]]], Infinity); // [1, 2, 3]
+ *
+ * @param {any[]} array - Source array.
+ * @param {number} [depth=1] - Maximum depth to flatten.
+ * @returns {any[]} The flattened array.
+ */
+export function flatten(array: any[], depth?: number): any[];
+/**
+ * Returns a shuffled copy of an array (Fisher–Yates).
+ *
+ * Uses `Math.random` • not cryptographically secure.
+ *
+ * @param {any[]} array - Source array.
+ * @returns {any[]} A new shuffled array.
+ */
+export function shuffle(array: any[]): any[];
+/**
+ * Returns a random element from an array.
+ *
+ * @param {any[]} array - Source array.
+ * @returns {any} A random element, or undefined if empty.
+ */
+export function sample(array: any[]): any;
+/**
+ * Returns `n` random elements from an array (without repetition).
+ *
+ * @param {any[]} array - Source array.
+ * @param {number} n - Number of elements to pick.
+ * @returns {any[]} The sampled elements.
+ */
+export function sampleSize(array: any[], n: number): any[];
+/**
+ * Sorts an array by one or more iteratees, ascending by default.
+ *
+ * Does not mutate the input.
+ *
+ * @example
+ * nodeComfort.arr.sortBy(users, "age");
+ * nodeComfort.arr.sortBy(users, [(u) => u.age, "name"]);
+ *
+ * @param {any[]} array - Source array.
+ * @param {string|((item: any) => any)|Array<string|((item: any) => any)>} iteratees - Sort key(s).
+ * @param {"asc"|"desc"} [direction="asc"] - Sort direction.
+ * @returns {any[]} A new sorted array.
+ */
+export function sortBy(array: any[], iteratees: string | ((item: any) => any) | Array<string | ((item: any) => any)>, direction?: "asc" | "desc"): any[];
+/**
+ * Returns the elements present in the first array but not in the others.
+ *
+ * @example
+ * nodeComfort.arr.difference([1, 2, 3, 4], [2, 4]); // [1, 3]
+ *
+ * @param {any[]} array - Source array.
+ * @param {...any[]} others - Arrays to subtract.
+ * @returns {any[]} The difference.
+ */
+export function difference(array: any[], ...others: any[][]): any[];
+/**
+ * Returns the elements common to all provided arrays.
+ *
+ * @example
+ * nodeComfort.arr.intersection([1, 2, 3], [2, 3, 4]); // [2, 3]
+ *
+ * @param {...any[]} arrays - Arrays to intersect.
+ * @returns {any[]} The intersection.
+ */
+export function intersection(...arrays: any[][]): any[];
+/**
+ * Returns the union (unique values) of all provided arrays.
+ *
+ * @example
+ * nodeComfort.arr.union([1, 2], [2, 3], [3, 4]); // [1, 2, 3, 4]
+ *
+ * @param {...any[]} arrays - Arrays to unite.
+ * @returns {any[]} The union.
+ */
+export function union(...arrays: any[][]): any[];
+/**
+ * Zips multiple arrays together into an array of tuples.
+ *
+ * @example
+ * nodeComfort.arr.zip(["a", "b"], [1, 2]); // [["a", 1], ["b", 2]]
+ *
+ * @param {...any[]} arrays - Arrays to zip.
+ * @returns {any[][]} The zipped tuples.
+ */
+export function zip(...arrays: any[][]): any[][];
+/**
+ * Splits an array into `matching` and removes falsy values.
+ *
+ * Removes `false`, `null`, `0`, `""`, `undefined` and `NaN`.
+ *
+ * @example
+ * nodeComfort.arr.compact([0, 1, false, 2, "", 3, null]); // [1, 2, 3]
+ *
+ * @param {any[]} array - Source array.
+ * @returns {any[]} The compacted array.
+ */
+export function compact(array: any[]): any[];
+/**
+ * Returns the first element (or the first `n` elements) of an array.
+ *
+ * @param {any[]} array - Source array.
+ * @param {number} [n] - How many elements to take.
+ * @returns {any} The first element, or the first `n` elements when `n` is given.
+ */
+export function first(array: any[], n?: number): any;
+/**
+ * Returns the last element (or the last `n` elements) of an array.
+ *
+ * @param {any[]} array - Source array.
+ * @param {number} [n] - How many elements to take.
+ * @returns {any} The last element, or the last `n` elements when `n` is given.
+ */
+export function last(array: any[], n?: number): any;
+/**
+ * Removes items from an array where the predicate is true, returning a new array.
+ *
+ * @param {any[]} array - Source array.
+ * @param {(item: any, index: number) => boolean} predicate - Removal test.
+ * @returns {any[]} A new array without the removed items.
+ */
+export function remove(array: any[], predicate: (item: any, index: number) => boolean): any[];
+/**
+ * Moves an element from one index to another (returns a new array).
+ *
+ * @param {any[]} array - Source array.
+ * @param {number} from - Source index.
+ * @param {number} to - Destination index.
+ * @returns {any[]} The reordered array.
+ */
+export function move(array: any[], from: number, to: number): any[];
+/**
+ * Counts occurrences of each derived key in an array.
+ *
+ * @example
+ * nodeComfort.arr.countBy(["a", "b", "a"]);       // { a: 2, b: 1 }
+ * nodeComfort.arr.countBy([1.1, 2.3, 1.7], Math.floor); // { 1: 2, 2: 1 }
+ *
+ * @param {any[]} array - Source array.
+ * @param {string|((item: any) => any)} [iteratee] - Key or function.
+ * @returns {Record<string, number>} The counts.
+ */
+export function countBy(array: any[], iteratee?: string | ((item: any) => any)): Record<string, number>;
+/**
+ * Sums an array by a numeric iteratee (or the values themselves).
+ *
+ * @example
+ * nodeComfort.arr.sumBy([{ n: 1 }, { n: 2 }], "n"); // 3
+ *
+ * @param {any[]} array - Source array.
+ * @param {string|((item: any) => number)} [iteratee] - Key or function returning a number.
+ * @returns {number} The sum.
+ */
+export function sumBy(array: any[], iteratee?: string | ((item: any) => number)): number;
+/**
+ * Returns the item with the maximum derived value.
+ *
+ * @param {any[]} array - Source array.
+ * @param {string|((item: any) => number)} [iteratee] - Key or function.
+ * @returns {any} The item, or undefined if the array is empty.
+ */
+export function maxBy(array: any[], iteratee?: string | ((item: any) => number)): any;
+/**
+ * Returns the item with the minimum derived value.
+ *
+ * @param {any[]} array - Source array.
+ * @param {string|((item: any) => number)} [iteratee] - Key or function.
+ * @returns {any} The item, or undefined if the array is empty.
+ */
+export function minBy(array: any[], iteratee?: string | ((item: any) => number)): any;
+/**
+ * Creates an array of a given length, filled by a value or generator function.
+ *
+ * @example
+ * nodeComfort.arr.times(3, "x");           // ["x", "x", "x"]
+ * nodeComfort.arr.times(3, (i) => i * 2);  // [0, 2, 4]
+ *
+ * @param {number} n - Number of items.
+ * @param {any|((index: number) => any)} [value] - Fill value or generator.
+ * @returns {any[]} The generated array.
+ */
+export function times(n: number, value?: any | ((index: number) => any)): any[];
+//# sourceMappingURL=Arr.d.ts.map

package/types/src/Arr.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Arr.d.ts","sourceRoot":"","sources":["../../src/Arr.js"],"names":[],"mappings":"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"}

package/types/src/Checker.d.ts

@@ -0,0 +1,407 @@
+/**
+ * Checks if a value is a real Array.
+ *
+ * @example
+ * nodeComfort.isArray([1, 2, 3]);    // true
+ * nodeComfort.isArray("not array");  // false
+ *
+ * @param {*} value - Value to check.
+ * @returns {boolean} True if the value is an Array.
+ */
+export function isArray(value: any): boolean;
+/**
+ * Checks if a value is a number (excluding NaN).
+ *
+ * @example
+ * nodeComfort.isNumber(42);          // true
+ * nodeComfort.isNumber(NaN);         // false
+ * nodeComfort.isNumber("42");        // false
+ *
+ * @param {*} value - Value to check.
+ * @returns {boolean} True if the value is a finite number or Infinity/-Infinity.
+ */
+export function isNumber(value: any): boolean;
+/**
+ * Checks if a value is a finite number (excludes NaN, Infinity and -Infinity).
+ *
+ * @example
+ * nodeComfort.isFinite(42);        // true
+ * nodeComfort.isFinite(Infinity);  // false
+ *
+ * @param {*} value - Value to check.
+ * @returns {boolean} True if the value is a finite number.
+ */
+export function isFinite(value: any): boolean;
+/**
+ * Checks if a value is a safe integer.
+ *
+ * @example
+ * nodeComfort.isInteger(42);    // true
+ * nodeComfort.isInteger(4.2);   // false
+ *
+ * @param {*} value - Value to check.
+ * @returns {boolean} True if the value is an integer.
+ */
+export function isInteger(value: any): boolean;
+/**
+ * Checks if a value is a floating-point number (a finite non-integer number).
+ *
+ * @example
+ * nodeComfort.isFloat(4.2);   // true
+ * nodeComfort.isFloat(4);     // false
+ *
+ * @param {*} value - Value to check.
+ * @returns {boolean} True if the value is a non-integer finite number.
+ */
+export function isFloat(value: any): boolean;
+/**
+ * Checks if a value is a function.
+ *
+ * @example
+ * nodeComfort.isFunction(() => {});  // true
+ * nodeComfort.isFunction(class {});  // true
+ * nodeComfort.isFunction("fn");      // false
+ *
+ * @param {*} value - Value to check.
+ * @returns {boolean} True if the value is a function.
+ */
+export function isFunction(value: any): boolean;
+/**
+ * Checks if a value is an async function (declared with `async`).
+ *
+ * @example
+ * nodeComfort.isAsyncFunction(async () => {});  // true
+ * nodeComfort.isAsyncFunction(() => {});        // false
+ *
+ * @param {*} value - Value to check.
+ * @returns {boolean} True if the value is an async function.
+ */
+export function isAsyncFunction(value: any): boolean;
+/**
+ * Checks if a value is a non-null object.
+ *
+ * Note: Arrays, Maps, Sets, Dates, etc. are also considered objects here.
+ *
+ * @example
+ * nodeComfort.isObject({});          // true
+ * nodeComfort.isObject([]);          // true
+ * nodeComfort.isObject(null);        // false
+ * nodeComfort.isObject("str");       // false
+ *
+ * @param {*} value - Value to check.
+ * @returns {boolean} True if the value is a non-null object.
+ */
+export function isObject(value: any): boolean;
+/**
+ * Checks if a value is a plain object (created via `{}` or `new Object()`).
+ *
+ * Unlike {@link isObject}, this excludes arrays, Maps, Dates, class instances, etc.
+ *
+ * @example
+ * nodeComfort.isPlainObject({ a: 1 });    // true
+ * nodeComfort.isPlainObject([]);          // false
+ * nodeComfort.isPlainObject(new Date());  // false
+ *
+ * @param {*} value - Value to check.
+ * @returns {boolean} True if the value is a plain object.
+ */
+export function isPlainObject(value: any): boolean;
+/**
+ * Checks if a value is a boolean.
+ *
+ * @example
+ * nodeComfort.isBoolean(true);       // true
+ * nodeComfort.isBoolean(false);      // true
+ * nodeComfort.isBoolean(0);          // false
+ *
+ * @param {*} value - Value to check.
+ * @returns {boolean} True if the value is a boolean.
+ */
+export function isBoolean(value: any): boolean;
+/**
+ * Checks if a value is a string.
+ *
+ * @example
+ * nodeComfort.isString("hello");     // true
+ * nodeComfort.isString(123);         // false
+ *
+ * @param {*} value - Value to check.
+ * @returns {boolean} True if the value is a string.
+ */
+export function isString(value: any): boolean;
+/**
+ * Checks if a value is a symbol.
+ *
+ * @example
+ * nodeComfort.isSymbol(Symbol("x"));  // true
+ *
+ * @param {*} value - Value to check.
+ * @returns {boolean} True if the value is a symbol.
+ */
+export function isSymbol(value: any): boolean;
+/**
+ * Checks if a value is a BigInt.
+ *
+ * @example
+ * nodeComfort.isBigInt(10n);  // true
+ * nodeComfort.isBigInt(10);   // false
+ *
+ * @param {*} value - Value to check.
+ * @returns {boolean} True if the value is a BigInt.
+ */
+export function isBigInt(value: any): boolean;
+/**
+ * Checks if a value is exactly undefined.
+ *
+ * @example
+ * nodeComfort.isUndefined(undefined);  // true
+ * nodeComfort.isUndefined(null);       // false
+ *
+ * @param {*} value - Value to check.
+ * @returns {boolean} True if the value is undefined.
+ */
+export function isUndefined(value: any): boolean;
+/**
+ * Checks if a value is exactly null.
+ *
+ * @example
+ * nodeComfort.isNull(null);          // true
+ * nodeComfort.isNull(undefined);     // false
+ *
+ * @param {*} value - Value to check.
+ * @returns {boolean} True if the value is null.
+ */
+export function isNull(value: any): boolean;
+/**
+ * Checks if a value is `null` or `undefined`.
+ *
+ * @example
+ * nodeComfort.isNil(null);       // true
+ * nodeComfort.isNil(undefined);  // true
+ * nodeComfort.isNil(0);          // false
+ *
+ * @param {*} value - Value to check.
+ * @returns {boolean} True if the value is null or undefined.
+ */
+export function isNil(value: any): boolean;
+/**
+ * Checks if a value is a primitive (string, number, boolean, symbol, bigint, null or undefined).
+ *
+ * @example
+ * nodeComfort.isPrimitive(42);    // true
+ * nodeComfort.isPrimitive({});    // false
+ *
+ * @param {*} value - Value to check.
+ * @returns {boolean} True if the value is a primitive.
+ */
+export function isPrimitive(value: any): boolean;
+/**
+ * Checks if a value is a Promise (or a thenable object).
+ *
+ * @example
+ * nodeComfort.isPromise(Promise.resolve());       // true
+ * nodeComfort.isPromise({ then() {} });            // true
+ * nodeComfort.isPromise(42);                       // false
+ *
+ * @param {*} value - Value to check.
+ * @returns {boolean} True if the value is a Promise or thenable.
+ */
+export function isPromise(value: any): boolean;
+/**
+ * Checks if a value is a RegExp instance.
+ *
+ * @example
+ * nodeComfort.isRegExp(/a/);   // true
+ * nodeComfort.isRegExp("a");   // false
+ *
+ * @param {*} value - Value to check.
+ * @returns {boolean} True if the value is a RegExp.
+ */
+export function isRegExp(value: any): boolean;
+/**
+ * Checks if a value is a built-in Date instance.
+ *
+ * Uses `util.types.isDate` under the hood to handle cross-realm Dates.
+ *
+ * @example
+ * nodeComfort.isDate(new Date());    // true
+ * nodeComfort.isDate("2024-01-01");  // false
+ *
+ * @param {*} value - Value to check.
+ * @returns {boolean} True if the value is a Date instance.
+ */
+export function isDate(value: any): boolean;
+/**
+ * Checks if a value is a **valid** Date (a Date instance that is not `Invalid Date`).
+ *
+ * @example
+ * nodeComfort.isValidDate(new Date());            // true
+ * nodeComfort.isValidDate(new Date("nope"));      // false
+ *
+ * @param {*} value - Value to check.
+ * @returns {boolean} True if the value is a valid Date.
+ */
+export function isValidDate(value: any): boolean;
+/**
+ * Checks if a value is a built-in Map instance.
+ *
+ * @example
+ * nodeComfort.isMap(new Map());      // true
+ * nodeComfort.isMap({});             // false
+ *
+ * @param {*} value - Value to check.
+ * @returns {boolean} True if the value is a Map.
+ */
+export function isMap(value: any): boolean;
+/**
+ * Checks if a value is a built-in Set instance.
+ *
+ * @example
+ * nodeComfort.isSet(new Set());      // true
+ * nodeComfort.isSet([]);             // false
+ *
+ * @param {*} value - Value to check.
+ * @returns {boolean} True if the value is a Set.
+ */
+export function isSet(value: any): boolean;
+/**
+ * Checks if a value is a WeakMap instance.
+ *
+ * @param {*} value - Value to check.
+ * @returns {boolean} True if the value is a WeakMap.
+ */
+export function isWeakMap(value: any): boolean;
+/**
+ * Checks if a value is a WeakSet instance.
+ *
+ * @param {*} value - Value to check.
+ * @returns {boolean} True if the value is a WeakSet.
+ */
+export function isWeakSet(value: any): boolean;
+/**
+ * Checks if a value is an iterable (has a `Symbol.iterator`).
+ *
+ * Strings, arrays, Maps, Sets and generators are iterable.
+ *
+ * @example
+ * nodeComfort.isIterable([1, 2]);   // true
+ * nodeComfort.isIterable("hi");     // true
+ * nodeComfort.isIterable({});       // false
+ *
+ * @param {*} value - Value to check.
+ * @returns {boolean} True if the value is iterable.
+ */
+export function isIterable(value: any): boolean;
+/**
+ * Checks if a value is a Node.js Buffer.
+ *
+ * @param {*} value - Value to check.
+ * @returns {boolean} True if the value is a Buffer.
+ */
+export function isBuffer(value: any): boolean;
+/**
+ * Checks if a value is any TypedArray (Uint8Array, Float64Array, etc.).
+ *
+ * @param {*} value - Value to check.
+ * @returns {boolean} True if the value is a TypedArray.
+ */
+export function isTypedArray(value: any): boolean;
+/**
+ * Checks if a value is a native Error instance.
+ *
+ * Uses `util.types.isNativeError` to correctly handle errors from other realms.
+ *
+ * @example
+ * nodeComfort.isError(new Error("x"));      // true
+ * nodeComfort.isError(new TypeError("x"));  // true
+ * nodeComfort.isError({ message: "x" });    // false
+ *
+ * @param {*} value - Value to check.
+ * @returns {boolean} True if the value is a native Error.
+ */
+export function isError(value: any): boolean;
+/**
+ * Checks if a value is "empty".
+ *
+ * Emptiness rules:
+ * - `null` / `undefined` -> empty
+ * - string / array -> empty when `length === 0`
+ * - Map / Set -> empty when `size === 0`
+ * - plain object -> empty when it has no own enumerable keys
+ * - anything else (numbers, booleans, functions, ...) -> never empty
+ *
+ * @example
+ * nodeComfort.isEmpty("");        // true
+ * nodeComfort.isEmpty([]);        // true
+ * nodeComfort.isEmpty({});        // true
+ * nodeComfort.isEmpty(new Map()); // true
+ * nodeComfort.isEmpty("x");       // false
+ * nodeComfort.isEmpty(0);         // false
+ *
+ * @param {*} value - Value to check.
+ * @returns {boolean} True if the value is considered empty.
+ */
+export function isEmpty(value: any): boolean;
+/**
+ * Checks if a string is a valid, well-formed email address.
+ *
+ * This is a pragmatic check (not a full RFC 5322 parser) that covers the
+ * vast majority of real-world addresses.
+ *
+ * @example
+ * nodeComfort.isEmail("john@example.com");  // true
+ * nodeComfort.isEmail("nope");              // false
+ *
+ * @param {*} value - Value to check.
+ * @returns {boolean} True if the value looks like an email address.
+ */
+export function isEmail(value: any): boolean;
+/**
+ * Checks if a string is a valid HTTP(S) URL.
+ *
+ * @example
+ * nodeComfort.isURL("https://example.com");  // true
+ * nodeComfort.isURL("ftp://example.com");    // false (not http/https)
+ *
+ * @param {*} value - Value to check.
+ * @param {{ protocols?: string[] }} [options] - Allowed protocols (default: http, https).
+ * @returns {boolean} True if the value is a valid URL with an allowed protocol.
+ */
+export function isURL(value: any, options?: {
+    protocols?: string[];
+}): boolean;
+/**
+ * Checks if a string is a valid UUID (versions 1-5, any variant).
+ *
+ * @example
+ * nodeComfort.isUUID("123e4567-e89b-12d3-a456-426614174000");  // true
+ *
+ * @param {*} value - Value to check.
+ * @returns {boolean} True if the value is a UUID.
+ */
+export function isUUID(value: any): boolean;
+/**
+ * Checks if a string is valid, parseable JSON.
+ *
+ * @example
+ * nodeComfort.isJSON('{"a":1}');  // true
+ * nodeComfort.isJSON("{a:1}");    // false
+ *
+ * @param {*} value - Value to check.
+ * @returns {boolean} True if the value is a JSON-parseable string.
+ */
+export function isJSON(value: any): boolean;
+/**
+ * Checks if a value is numeric • a number, or a string that fully represents one.
+ *
+ * @example
+ * nodeComfort.isNumeric(42);      // true
+ * nodeComfort.isNumeric("42");    // true
+ * nodeComfort.isNumeric("4.2e3"); // true
+ * nodeComfort.isNumeric("4px");   // false
+ *
+ * @param {*} value - Value to check.
+ * @returns {boolean} True if the value is numeric.
+ */
+export function isNumeric(value: any): boolean;
+//# sourceMappingURL=Checker.d.ts.map

package/types/src/Checker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Checker.d.ts","sourceRoot":"","sources":["../../src/Checker.js"],"names":[],"mappings":"AAUE;;;;;;;;;GASG;AACH,+BAHW,GAAC,GACC,OAAO,CAInB;AAED;;;;;;;;;;GAUG;AACH,gCAHW,GAAC,GACC,OAAO,CAInB;AAED;;;;;;;;;GASG;AACH,gCAHW,GAAC,GACC,OAAO,CAInB;AAED;;;;;;;;;GASG;AACH,iCAHW,GAAC,GACC,OAAO,CAInB;AAED;;;;;;;;;GASG;AACH,+BAHW,GAAC,GACC,OAAO,CAInB;AAED;;;;;;;;;;GAUG;AACH,kCAHW,GAAC,GACC,OAAO,CAInB;AAED;;;;;;;;;GASG;AACH,uCAHW,GAAC,GACC,OAAO,CAInB;AAED;;;;;;;;;;;;;GAaG;AACH,gCAHW,GAAC,GACC,OAAO,CAInB;AAED;;;;;;;;;;;;GAYG;AACH,qCAHW,GAAC,GACC,OAAO,CAMnB;AAED;;;;;;;;;;GAUG;AACH,iCAHW,GAAC,GACC,OAAO,CAInB;AAED;;;;;;;;;GASG;AACH,gCAHW,GAAC,GACC,OAAO,CAInB;AAED;;;;;;;;GAQG;AACH,gCAHW,GAAC,GACC,OAAO,CAInB;AAED;;;;;;;;;GASG;AACH,gCAHW,GAAC,GACC,OAAO,CAInB;AAED;;;;;;;;;GASG;AACH,mCAHW,GAAC,GACC,OAAO,CAInB;AAED;;;;;;;;;GASG;AACH,8BAHW,GAAC,GACC,OAAO,CAInB;AAED;;;;;;;;;;GAUG;AACH,6BAHW,GAAC,GACC,OAAO,CAInB;AAED;;;;;;;;;GASG;AACH,mCAHW,GAAC,GACC,OAAO,CAInB;AAED;;;;;;;;;;GAUG;AACH,iCAHW,GAAC,GACC,OAAO,CASnB;AAED;;;;;;;;;GASG;AACH,gCAHW,GAAC,GACC,OAAO,CAInB;AAED;;;;;;;;;;;GAWG;AACH,8BAHW,GAAC,GACC,OAAO,CAInB;AAED;;;;;;;;;GASG;AACH,mCAHW,GAAC,GACC,OAAO,CAInB;AAED;;;;;;;;;GASG;AACH,6BAHW,GAAC,GACC,OAAO,CAInB;AAED;;;;;;;;;GASG;AACH,6BAHW,GAAC,GACC,OAAO,CAInB;AAED;;;;;GAKG;AACH,iCAHW,GAAC,GACC,OAAO,CAInB;AAED;;;;;GAKG;AACH,iCAHW,GAAC,GACC,OAAO,CAInB;AAED;;;;;;;;;;;;GAYG;AACH,kCAHW,GAAC,GACC,OAAO,CAInB;AAED;;;;;GAKG;AACH,gCAHW,GAAC,GACC,OAAO,CAInB;AAED;;;;;GAKG;AACH,oCAHW,GAAC,GACC,OAAO,CAInB;AAED;;;;;;;;;;;;GAYG;AACH,+BAHW,GAAC,GACC,OAAO,CAInB;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,+BAHW,GAAC,GACC,OAAO,CAQnB;AAED;;;;;;;;;;;;GAYG;AACH,+BAHW,GAAC,GACC,OAAO,CAKnB;AAED;;;;;;;;;;GAUG;AACH,6BAJW,GAAC,YACD;IAAE,SAAS,CAAC,EAAE,MAAM,EAAE,CAAA;CAAE,GACtB,OAAO,CAWnB;AAED;;;;;;;;GAQG;AACH,8BAHW,GAAC,GACC,OAAO,CAKnB;AAED;;;;;;;;;GASG;AACH,8BAHW,GAAC,GACC,OAAO,CAUnB;AAED;;;;;;;;;;;GAWG;AACH,iCAHW,GAAC,GACC,OAAO,CAMnB"}