{"version":3,"sources":["../source/compare/compare.ts","../source/schema/bigint/bigint.ts","../source/schema/native/native.ts","../source/schema/empty/empty.ts","../source/schema/float/float.ts","../source/schema/integer/integer.ts","../source/difference/difference.ts","../source/filter/filter.ts","../source/intersection/intersection.ts","../source/random/random.ts","../source/shuffle/shuffle.ts","../source/union/union.ts","../source/unique/unique.ts"],"names":["deepEqual","BUILT_IN_OBJECTS_SCHEMAS","BIGINT_ARRAY_TYPES","BIGINT64_ARRAY_SCHEMA","BIGUINT64_ARRAY_SCHEMA","BIGINT_ARRAY_SCHEMAS","validateBigIntArray","value","options","type","isBigIntArray","z","ARRAY_SCHEMA","validateArray","validateArrays","arrays","currentArray","EMPTY_ARRAY_SCHEMA","validateEmptyArray","array","isEmptyArray","FLOAT_ARRAY_BITS","FLOAT32_ARRAY_SCHEMA","FLOAT64_ARRAY_SCHEMA","FLOAT_ARRAY_SCHEMAS","validateFloatArray","bit","isFloatArray","INTEGER_ARRAY_TYPES","INTEGER_ARRAY_BITS","INTEGER_ARRAY_CATEGORIES","INT8_ARRAY_SCHEMA","INT16_ARRAY_SCHEMA","INT32_ARRAY_SCHEMA","INT_ARRAY_SCHEMAS","UINT8_ARRAY_SCHEMA","UINT8_CLAMPED_ARRAY_SCHEMA","UINT16_ARRAY_SCHEMA","UINT32_ARRAY_SCHEMA","UINT_ARRAY_SCHEMAS","INTEGER_ARRAY_SCHEMAS","isUnsigned","is8Bit","validateIntegerArray","clamped","isIntegerArray","areArraysEqual","left","right","areArraysItemsSame","arrayDiffer","getArrayDifference","input","values","getArraysSymmetricDifference","setLeft","setRight","differencesLeft","x","differencesRight","exclude","items","item","extract","getArraysIntersection","validatePositiveInteger","getRandomIntNumber","getRandomIndex","length","getRandomItem","getRandomItems","count","results","shuffleArray","shuffled","currentIndex","newIndex","arrayUnion","getArraysUnion","_arguments","getArrayUniques"],"mappings":"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","sourcesContent":["import deepEqual from \"fast-deep-equal/es6/react\";\n\nimport { validateArrays } from \"../schema/schema.ts\";\n\nexport function areArraysEqual<ValueType>(left: ReadonlyArray<ValueType>, right: ReadonlyArray<ValueType>): boolean {\n\tvalidateArrays(left, right);\n\n\treturn left.length === right.length ? deepEqual(left, right) : false;\n}\n\n/**\n * Check whether the arrays has same items, but in a different order.\n */\nexport function areArraysItemsSame<ValueType>(\n\tleft: ReadonlyArray<ValueType>,\n\tright: ReadonlyArray<ValueType>,\n): boolean {\n\tvalidateArrays(left, right);\n\n\treturn left.length === right.length ? deepEqual((left as []).sort(), (right as []).sort()) : false;\n}\n","import { BUILT_IN_OBJECTS_SCHEMAS } from \"@terminal-nerds/snippets-type/built-in\";\n\nexport const BIGINT_ARRAY_TYPES = [\"signed\", \"unsigned\"] as const;\nexport type BigIntArrayType = (typeof BIGINT_ARRAY_TYPES)[number];\n\nexport const BIGINT64_ARRAY_SCHEMA = BUILT_IN_OBJECTS_SCHEMAS.BigInt64Array;\nexport const BIGUINT64_ARRAY_SCHEMA = BUILT_IN_OBJECTS_SCHEMAS.BigUint64Array;\n\nexport const BIGINT_ARRAY_SCHEMAS = {\n\tsigned: BIGINT64_ARRAY_SCHEMA,\n\tunsigned: BIGUINT64_ARRAY_SCHEMA,\n} as const;\n\nexport interface BigIntArrays {\n\tsigned: BigInt64Array;\n\tunsigned: BigUint64Array;\n}\n\nexport type BigIntArray<Type extends BigIntArrayType> = BigIntArrays[Type];\n\ntype BigIntArrayOptions<Type extends BigIntArrayType> = {\n\ttype: Type;\n};\n\nexport function validateBigIntArray<Type extends BigIntArrayType>(\n\tvalue: unknown,\n\toptions: BigIntArrayOptions<Type>,\n): asserts value is BigIntArray<Type> {\n\tconst { type } = options;\n\n\tBIGINT_ARRAY_SCHEMAS[type].parse(value);\n}\n\nexport function isBigIntArray<Type extends BigIntArrayType>(\n\tvalue: unknown,\n\toptions: BigIntArrayOptions<Type>,\n): value is BigIntArray<Type> {\n\tconst { type } = options;\n\n\treturn BIGINT_ARRAY_SCHEMAS[type].safeParse(value).success;\n}\n","import { z } from \"zod\";\n\nexport const ARRAY_SCHEMA = z.array(z.any());\n\nexport type AnyArray = ReadonlyArray<unknown>;\n\nexport function validateArray(value: unknown): asserts value is AnyArray {\n\tARRAY_SCHEMA.parse(value);\n}\n\nexport function validateArrays(...arrays: AnyArray[]): void {\n\tfor (const currentArray of arrays) {\n\t\tvalidateArray(currentArray);\n\t}\n}\n","import { ARRAY_SCHEMA, validateArray } from \"../native/native.ts\";\n\nexport const EMPTY_ARRAY_SCHEMA = ARRAY_SCHEMA.length(0);\n\nexport type EmptyArray = [];\n\nexport function validateEmptyArray(array: Array<unknown> | readonly unknown[]): asserts array is EmptyArray {\n\tEMPTY_ARRAY_SCHEMA.parse(array);\n}\n\nexport function isEmptyArray(array: Array<unknown> | readonly unknown[]): array is EmptyArray {\n\tvalidateArray(array);\n\n\treturn EMPTY_ARRAY_SCHEMA.safeParse(array).success;\n}\n","import { BUILT_IN_OBJECTS_SCHEMAS } from \"@terminal-nerds/snippets-type/built-in\";\n\nexport const FLOAT_ARRAY_BITS = [32, 64] as const;\nexport type FloatArrayBit = (typeof FLOAT_ARRAY_BITS)[number];\n\nexport const FLOAT32_ARRAY_SCHEMA = BUILT_IN_OBJECTS_SCHEMAS.Float32Array;\nexport const FLOAT64_ARRAY_SCHEMA = BUILT_IN_OBJECTS_SCHEMAS.Float64Array;\n\nexport const FLOAT_ARRAY_SCHEMAS = {\n\t32: FLOAT32_ARRAY_SCHEMA,\n\t64: FLOAT64_ARRAY_SCHEMA,\n} as const;\n\nexport type FloatArrays = {\n\t32: Float32Array;\n\t64: Float64Array;\n};\n\nexport type FloatArray<Bit extends FloatArrayBit> = FloatArrays[Bit];\n\nexport interface FloatArrayOptions<Bit extends FloatArrayBit> {\n\tbit: Bit;\n}\n\nexport function validateFloatArray<Bit extends FloatArrayBit>(\n\tvalue: unknown,\n\toptions: FloatArrayOptions<Bit>,\n): asserts value is FloatArray<Bit> {\n\tconst { bit } = options;\n\n\tFLOAT_ARRAY_SCHEMAS[bit].parse(value);\n}\n\nexport function isFloatArray<Bit extends FloatArrayBit>(\n\tvalue: unknown,\n\toptions: FloatArrayOptions<Bit>,\n): value is FloatArray<Bit> {\n\tconst { bit } = options;\n\n\treturn FLOAT_ARRAY_SCHEMAS[bit].safeParse(value).success;\n}\n","import { BUILT_IN_OBJECTS_SCHEMAS } from \"@terminal-nerds/snippets-type/built-in\";\n\nexport const INTEGER_ARRAY_TYPES = [\"signed\", \"unsigned\"] as const;\nexport type IntegerArrayType = (typeof INTEGER_ARRAY_TYPES)[number];\n\nexport const INTEGER_ARRAY_BITS = [8, 16, 32] as const;\nexport type IntegerArrayBit = (typeof INTEGER_ARRAY_BITS)[number];\n\nexport const INTEGER_ARRAY_CATEGORIES = [\"clamped\", \"standard\"] as const;\nexport type IntegerArrayCategory = (typeof INTEGER_ARRAY_CATEGORIES)[number];\n\nexport const INT8_ARRAY_SCHEMA = BUILT_IN_OBJECTS_SCHEMAS.Int8Array;\nexport const INT16_ARRAY_SCHEMA = BUILT_IN_OBJECTS_SCHEMAS.Int16Array;\nexport const INT32_ARRAY_SCHEMA = BUILT_IN_OBJECTS_SCHEMAS.Int32Array;\n\nexport const INT_ARRAY_SCHEMAS = {\n\t8: { standard: INT8_ARRAY_SCHEMA },\n\t16: { standard: INT16_ARRAY_SCHEMA },\n\t32: { standard: INT32_ARRAY_SCHEMA },\n} as const;\n\nexport const UINT8_ARRAY_SCHEMA = BUILT_IN_OBJECTS_SCHEMAS.Uint8Array;\nexport const UINT8_CLAMPED_ARRAY_SCHEMA = BUILT_IN_OBJECTS_SCHEMAS.Uint8ClampedArray;\nexport const UINT16_ARRAY_SCHEMA = BUILT_IN_OBJECTS_SCHEMAS.Uint16Array;\nexport const UINT32_ARRAY_SCHEMA = BUILT_IN_OBJECTS_SCHEMAS.Uint32Array;\n\nexport const UINT_ARRAY_SCHEMAS = {\n\t8: { standard: UINT8_ARRAY_SCHEMA, clamped: UINT8_CLAMPED_ARRAY_SCHEMA },\n\t16: { standard: UINT16_ARRAY_SCHEMA },\n\t32: { standard: UINT32_ARRAY_SCHEMA },\n} as const;\n\nexport const INTEGER_ARRAY_SCHEMAS = {\n\tsigned: INT_ARRAY_SCHEMAS,\n\tunsigned: UINT_ARRAY_SCHEMAS,\n} as const;\n\nexport interface IntegerArrays {\n\tsigned: {\n\t\t8: { standard: Int8Array };\n\t\t16: { standard: Int16Array };\n\t\t32: { standard: Int32Array };\n\t};\n\tunsigned: {\n\t\t8: { standard: Uint8Array; clamped: Uint8ClampedArray };\n\t\t16: { standard: Uint16Array };\n\t\t32: { standard: Uint32Array };\n\t};\n}\n\nexport type IntArray<Bit extends IntegerArrayBit> = IntegerArrays[\"signed\"][Bit][\"standard\"];\nexport type UintArray<Bit extends IntegerArrayBit, Category extends IntegerArrayCategory> = Bit extends 8\n\t? IntegerArrays[\"unsigned\"][8][Category]\n\t: IntegerArrays[\"unsigned\"][Bit][\"standard\"];\nexport type IntegerArray<\n\tType extends IntegerArrayType,\n\tBit extends IntegerArrayBit,\n\tCategory extends IntegerArrayCategory = Type extends \"unsigned\"\n\t\t? Bit extends 8\n\t\t\t? IntegerArrayCategory\n\t\t\t: \"standard\"\n\t\t: \"standard\",\n> = Type extends \"signed\" ? IntArray<Bit> : Type extends \"unsigned\" ? UintArray<Bit, Category> : never;\n\ntype IntArrayOptions<Type extends IntegerArrayType, Bit extends IntegerArrayBit> = {\n\ttype: Type;\n\tbit: Bit;\n};\n\ntype Uint8ArrayOptions<Clamped extends boolean | undefined = undefined> = {\n\ttype: \"unsigned\";\n\tclamped?: Clamped;\n\tbit: 8;\n};\n\nexport type IntegerArrayOptions<\n\tType extends IntegerArrayType,\n\tBit extends IntegerArrayBit,\n\tClamped extends boolean | undefined = undefined,\n> = Type extends \"unsigned\"\n\t? Bit extends 8\n\t\t? Uint8ArrayOptions<Type extends \"unsigned\" ? (Bit extends 8 ? Clamped : undefined) : undefined>\n\t\t: IntArrayOptions<Type, Bit>\n\t: IntArrayOptions<Type, Bit>;\n\nexport function isUnsigned(type: IntegerArrayType): type is \"unsigned\" {\n\treturn type === \"unsigned\";\n}\n\nexport function is8Bit(bit: IntegerArrayBit): bit is 8 {\n\treturn bit === 8;\n}\n\n/**\n * FIXME:\n * There's an unwanted case, where the passed options -`{ type: \"standard\", bit: 8 }`\n * the return value will be: `Uint8Array` | `Uint8ClampedArray`.\n * What is expected: it should pick one, and base it on the `clamped` optional key in options.\n */\nexport function validateIntegerArray<\n\tType extends IntegerArrayType,\n\tBit extends IntegerArrayBit,\n\tClamped extends boolean | undefined = undefined,\n>(\n\tvalue: unknown,\n\toptions: IntegerArrayOptions<Type, Bit, Clamped>,\n): asserts value is IntegerArray<Type, Bit, IntegerArrayCategory> {\n\tconst { type, bit } = options;\n\n\tif (isUnsigned(type) && is8Bit(bit)) {\n\t\tconst { clamped = false } = options as IntegerArrayOptions<\"unsigned\", 8, Clamped>;\n\n\t\tINTEGER_ARRAY_SCHEMAS[type][bit][clamped ? \"clamped\" : \"standard\"].parse(value);\n\t} else {\n\t\tINTEGER_ARRAY_SCHEMAS[type][bit][\"standard\"].parse(value);\n\t}\n}\n\n/**\n * FIXME:\n * There's an unwanted case, where the passed options -`{ type: \"standard\", bit: 8 }`\n * the return value will be: `Uint8Array` | `Uint8ClampedArray`.\n * What is expected: it should pick one, and base it on the `clamped` optional key in options.\n */\nexport function isIntegerArray<\n\tType extends IntegerArrayType,\n\tBit extends IntegerArrayBit,\n\tClamped extends boolean | undefined = undefined,\n>(\n\tvalue: unknown,\n\toptions: IntegerArrayOptions<Type, Bit, Clamped>,\n): value is IntegerArray<Type, Bit, IntegerArrayCategory> {\n\tconst { type, bit } = options;\n\n\tif (isUnsigned(type) && is8Bit(bit)) {\n\t\tconst { clamped = false } = options as IntegerArrayOptions<\"unsigned\", 8, Clamped>;\n\n\t\treturn INTEGER_ARRAY_SCHEMAS[type][bit][clamped ? \"clamped\" : \"standard\"].safeParse(value).success;\n\t} else {\n\t\treturn INTEGER_ARRAY_SCHEMAS[type][bit][\"standard\"].safeParse(value).success;\n\t}\n}\n","import arrayDiffer from \"array-differ\";\n\nimport { validateArrays } from \"../schema/schema.ts\";\n\n/** NOTE: This doesn't consider non-primitive values. */\nexport function getArrayDifference<ValueType>(\n\tinput: ReadonlyArray<ValueType>,\n\t...values: Array<ReadonlyArray<ValueType>>\n): Array<ValueType> {\n\tvalidateArrays(input, ...values);\n\n\treturn arrayDiffer(input, ...values);\n}\n\n/** NOTE: This doesn't consider non-primitive values. */\nexport function getArraysSymmetricDifference<ValueType>(\n\tleft: ReadonlyArray<ValueType>,\n\tright: ReadonlyArray<ValueType>,\n): Array<ValueType> {\n\tvalidateArrays(left, right);\n\n\tconst setLeft = new Set(left);\n\tconst setRight = new Set(right);\n\n\tconst differencesLeft = left.filter((x) => !setRight.has(x));\n\tconst differencesRight = right.filter((x) => !setLeft.has(x));\n\n\treturn [...differencesLeft, ...differencesRight];\n}\n","import { validateArrays } from \"../schema/schema.ts\";\n\n/** Filter out wanted items from an array. */\nexport function exclude<ValueType>(\n\tarray: ReadonlyArray<ValueType>,\n\titems: ReadonlyArray<ValueType>,\n): Exclude<ReadonlyArray<ValueType>, ValueType> {\n\tvalidateArrays(array, items);\n\n\treturn array.filter((item) => !items.includes(item)) as unknown as Exclude<ReadonlyArray<ValueType>, ValueType>;\n}\n\n/** Filter out unwanted items from an array. */\nexport function extract<ValueType>(\n\tarray: ReadonlyArray<ValueType>,\n\titems: ReadonlyArray<ValueType>,\n): Extract<ReadonlyArray<ValueType>, ValueType> {\n\tvalidateArrays(array, items);\n\n\treturn array.filter((item) => items.includes(item)) as Extract<ReadonlyArray<ValueType>, ValueType>;\n}\n","import { validateArrays } from \"../schema/schema.ts\";\n\n/** NOTE: It doesn't consider non-primitive types on items */\nexport function getArraysIntersection<ValueType>(\n\tleft: ReadonlyArray<ValueType>,\n\tright: ReadonlyArray<ValueType>,\n): Array<ValueType> {\n\tvalidateArrays(left, right);\n\n\tconst setLeft = new Set(left);\n\n\treturn [...new Set(right.filter((item) => setLeft.has(item)))];\n}\n","import { validatePositiveInteger } from \"@terminal-nerds/snippets-number\";\nimport { getRandomIntNumber } from \"@terminal-nerds/snippets-number/random\";\n\nimport { validateArray } from \"../schema/schema.ts\";\n\nexport async function getRandomIndex(length: number): Promise<number> {\n\treturn await getRandomIntNumber({ min: 0, max: length - 1 });\n}\n\nexport async function getRandomItem<Type = unknown>(array: Array<Type> | readonly Type[]): Promise<Type> {\n\tvalidateArray(array);\n\n\treturn array.at(await getRandomIndex(array.length)) as Type;\n}\n\ninterface RandomArrayItemsOptions {\n\t/**\n\t * A positive integer, with a count of how many random items you want to be picked.\n\t */\n\tcount: number;\n}\n\n/** NOTE: It could create duplicates. */\nexport async function getRandomItems<Type = unknown>(\n\tarray: Array<Type> | readonly Type[],\n\toptions: RandomArrayItemsOptions,\n): Promise<Array<Type>> {\n\tconst { count } = options;\n\n\tvalidatePositiveInteger(count);\n\n\tconst results: Array<Type> = [];\n\n\twhile (results.length < count) {\n\t\tresults.push(await getRandomItem(array));\n\t}\n\n\treturn results;\n}\n","import { getRandomIndex } from \"../random/random.ts\";\nimport { isEmptyArray } from \"../schema/empty/empty.ts\";\nimport { validateArray } from \"../schema/schema.ts\";\n\nexport async function shuffleArray<ValueType>(array: ReadonlyArray<ValueType>): Promise<Array<ValueType>> {\n\tvalidateArray(array);\n\n\tif (isEmptyArray(array)) return [];\n\telse {\n\t\tconst shuffled = [...array];\n\n\t\tfor (let currentIndex = array.length - 1; currentIndex > 0; currentIndex--) {\n\t\t\tconst newIndex = await getRandomIndex(array.length);\n\n\t\t\t/* prettier-ignore */\n\t\t\t[\n                shuffled[currentIndex],\n                shuffled[newIndex],\n            ] = [\n\t\t\t\tshuffled[newIndex] as ValueType,\n\t\t\t\tshuffled[currentIndex] as ValueType,\n\t\t\t];\n\t\t}\n\n\t\treturn shuffled;\n\t}\n}\n","import arrayUnion from \"array-union\";\n\nimport { validateArrays } from \"../schema/schema.ts\";\n\nexport function getArraysUnion<ArgumentsType extends readonly unknown[]>(\n\t..._arguments: readonly ArgumentsType[]\n): ArgumentsType {\n\tvalidateArrays(..._arguments);\n\n\treturn arrayUnion(..._arguments);\n}\n","import { validateArray } from \"../schema/schema.ts\";\n\n/** NOTE: It does not consider non-primitve items. */\nexport function getArrayUniques<ValueType>(array: ReadonlyArray<ValueType>): Array<ValueType> {\n\tvalidateArray(array);\n\n\treturn [...new Set(array)];\n}\n"]}