{"version":3,"sources":["../../source/schema/groups/finite/finite.ts","../../source/schema/groups/float/float.ts","../../source/schema/groups/infinity/infinity.ts","../../source/schema/groups/integer/integer.ts","../../source/schema/groups/multiple-of/multiple-of.ts","../../source/schema/groups/number/number.ts","../../source/schema/groups/zero/zero.ts","../../source/schema/groups/nan/nan.ts","../../source/schema/groups/negative/negative.ts","../../source/schema/groups/positive/positive.ts","../../source/schema/groups/safe/safe.ts"],"names":["z","FINITE_NUMBER_SCHEMA","validateFiniteNumber","value","isFiniteNumber","FLOAT_NUMBER_SCHEMA","n","validateFloatNumber","isFloatNumber","NEGATIVE_INFINITY_SCHEMA","POSITIVE_INFINITY_SCHEMA","INFINITY_SCHEMA","validateInfinity","isInfinity","isNegativeInfinity","isPositiveInfinity","INTEGER_SCHEMA","NEGATIVE_INTEGER_SCHEMA","POSITIVE_INTEGER_SCHEMA","validateInteger","validateNegativeInteger","validatePositiveInteger","isInteger","isNegativeInteger","isPositiveInteger","isPrimitive","validatePrimitive","NUMBER_SCHEMA","validateNumber","isNumber","ZERO_SCHEMA","NON_ZERO_SCHEMA","validateZero","validateNonZero","isZero","isNegativeZero","isPositiveZero","isNonZero","isEven","number","isOdd","isMultipleOf","multiplier","NAN_SCHEMA","validateNaN","isItNaN","NEGATIVE_NUMBER_SCHEMA","NON_POSITIVE_NUMBER_SCHEMA","validateNegativeNumber","isNegativeNumber","validateNonPositiveNumber","isNonPositiveNumber","POSITIVE_NUMBER_SCHEMA","NON_NEGATIVE_NUMBER_SCHEMA","validatePositiveNumber","isPositiveNumber","validateNonNegativeNumber","isNonNegativeNumber","SAFE_NUMBER_SCHEMA","MAX_SAFE_NUMBER_SCHEMA","MIN_SAFE_NUMBER_SCHEMA","validateSafeNumber","isSafeNumber","validateMaxSafeNumber","isMaxSafeNumber","validateMinSafeNumber","isMinSafeNumber"],"mappings":"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","sourcesContent":["import type { Finite } from \"type-fest/source/numeric\";\nimport { z } from \"zod\";\n\nexport type { Finite } from \"type-fest/source/numeric\";\n\nexport const FINITE_NUMBER_SCHEMA = z.number().finite();\n\nexport function validateFiniteNumber<N extends number>(value: N): asserts value is Finite<N> {\n\tFINITE_NUMBER_SCHEMA.parse(value);\n}\n\nexport function isFiniteNumber<N extends number>(value: N): value is Finite<N> {\n\treturn FINITE_NUMBER_SCHEMA.safeParse(value).success;\n}\n","import type { Float } from \"type-fest/source/numeric\";\nimport { z } from \"zod\";\n\nconst FLOAT_NUMBER_SCHEMA = z.number().refine((n) => {\n\treturn !z.number().int().safeParse(n).success && z.number().finite().safeParse(n).success;\n}, \"should not be an integer\");\n\nexport type { Float } from \"type-fest/source/numeric\";\n\nexport function validateFloatNumber<N extends number>(value: N): asserts value is Float<N> {\n\tFLOAT_NUMBER_SCHEMA.parse(value);\n}\n\nexport function isFloatNumber<N extends number>(value: N): value is Float<N> {\n\treturn FLOAT_NUMBER_SCHEMA.safeParse(value).success;\n}\n","import type { NegativeInfinity, PositiveInfinity } from \"type-fest/source/numeric\";\nimport { z } from \"zod\";\n\nexport type { NegativeInfinity, PositiveInfinity } from \"type-fest/source/numeric\";\nexport type Infinity = NegativeInfinity | PositiveInfinity;\n\nexport const NEGATIVE_INFINITY_SCHEMA = z.literal(Number.POSITIVE_INFINITY);\nexport const POSITIVE_INFINITY_SCHEMA = z.literal(Number.NEGATIVE_INFINITY);\nexport const INFINITY_SCHEMA = NEGATIVE_INFINITY_SCHEMA.or(POSITIVE_INFINITY_SCHEMA);\n\nexport function validateInfinity(value: unknown): asserts value is Infinity {\n\tINFINITY_SCHEMA.parse(value);\n}\n\nexport function isInfinity(value: unknown): value is Infinity {\n\treturn INFINITY_SCHEMA.safeParse(value).success;\n}\n\nexport function isNegativeInfinity(value: unknown): value is NegativeInfinity {\n\treturn NEGATIVE_INFINITY_SCHEMA.safeParse(value).success;\n}\n\nexport function isPositiveInfinity(value: unknown): value is PositiveInfinity {\n\treturn POSITIVE_INFINITY_SCHEMA.safeParse(value).success;\n}\n","import type { Integer, Negative, NonNegative } from \"type-fest/source/numeric\";\nimport { z } from \"zod\";\n\nexport type { Integer } from \"type-fest/source/numeric\";\n\nexport const INTEGER_SCHEMA = z.number().int();\nexport const NEGATIVE_INTEGER_SCHEMA = z.number().int().negative();\nexport const POSITIVE_INTEGER_SCHEMA = z.number().int().positive();\n\nexport function validateInteger<N extends number>(value: N): asserts value is Integer<N> {\n\tINTEGER_SCHEMA.parse(value);\n}\n\nexport function validateNegativeInteger<N extends number>(value: N): asserts value is Negative<Integer<N>> {\n\tNEGATIVE_INTEGER_SCHEMA.parse(value);\n}\n\nexport function validatePositiveInteger<N extends number>(value: N): asserts value is NonNegative<Integer<N>> {\n\tPOSITIVE_INTEGER_SCHEMA.parse(value);\n}\n\nexport function isInteger<N extends number>(value: N): value is Integer<N> {\n\treturn INTEGER_SCHEMA.safeParse(value).success;\n}\n\nexport function isNegativeInteger<N extends number>(value: N): value is Negative<Integer<N>> {\n\treturn NEGATIVE_INTEGER_SCHEMA.safeParse(value).success;\n}\n\nexport function isPositiveInteger<N extends number>(value: N): value is NonNegative<Integer<N>> {\n\treturn POSITIVE_INTEGER_SCHEMA.safeParse(value).success;\n}\n","import { z } from \"zod\";\n\nimport { validateInteger } from \"../integer/integer.ts\";\nimport { validateNumber } from \"../number/number.ts\";\nimport { validateNonZero } from \"../zero/zero.ts\";\n\nexport function isEven(number: number): boolean {\n\tvalidateInteger(number);\n\n\treturn number % 2 === 0;\n}\n\nexport function isOdd(number: number): boolean {\n\treturn !isEven(number);\n}\n\nexport function isMultipleOf(number: number, multiplier: number): boolean {\n\tvalidateNumber(number);\n\tvalidateNonZero(multiplier);\n\n\treturn z.number().multipleOf(multiplier).safeParse(number).success;\n}\n","import { isPrimitive, validatePrimitive } from \"@terminal-nerds/snippets-type/primitive\";\n\nexport { NUMBER_SCHEMA } from \"@terminal-nerds/snippets-type/primitive\";\n\n/** NOTE: This snippet doesn't consider `NaN` as number! */\nexport function validateNumber(value: unknown): asserts value is number {\n\treturn validatePrimitive(value, \"number\");\n}\n\n/** NOTE: This snippet doesn't consider `NaN` as number! */\nexport function isNumber(value: unknown): value is number {\n\treturn isPrimitive(value, \"number\");\n}\n","import { z } from \"zod\";\n\nexport const ZERO_SCHEMA = z.literal(0);\nexport const NON_ZERO_SCHEMA = z.number().negative().or(z.number().positive());\n\nexport type Zero = NegativeZero | PositiveZero;\nexport type PositiveZero = 0;\nexport type NegativeZero = -0;\n\nexport function validateZero(value: number): asserts value is Zero {\n\tZERO_SCHEMA.parse(value);\n}\n\nexport function validateNonZero(value: number): asserts value is number {\n\tNON_ZERO_SCHEMA.parse(value);\n}\n\nexport function isZero(value: number): value is Zero {\n\treturn ZERO_SCHEMA.safeParse(value).success;\n}\n\nexport function isNegativeZero(value: number): value is NegativeZero {\n\tvalidateZero(value);\n\n\treturn Object.is(-0, value);\n}\n\nexport function isPositiveZero(value: number): value is PositiveZero {\n\treturn !isNegativeZero(value);\n}\n\nexport function isNonZero(value: number): value is number {\n\treturn NON_ZERO_SCHEMA.safeParse(value).success;\n}\n","import { z } from \"zod\";\n\nexport type NaN = typeof Number.NaN;\n\nexport const NAN_SCHEMA = z.nan();\n\nexport function validateNaN(value: number): asserts value is NaN {\n\tNAN_SCHEMA.parse(value);\n}\n\nexport function isItNaN(value: number): value is NaN {\n\treturn NAN_SCHEMA.safeParse(value).success;\n}\n","import type { Negative } from \"type-fest/source/numeric\";\nimport { z } from \"zod\";\n\nexport type { Negative } from \"type-fest/source/numeric\";\n\nexport const NEGATIVE_NUMBER_SCHEMA = z.number().negative();\nexport const NON_POSITIVE_NUMBER_SCHEMA = z.number().nonpositive();\n\nexport function validateNegativeNumber<N extends number>(value: N): asserts value is Negative<N> {\n\tNEGATIVE_NUMBER_SCHEMA.parse(value);\n}\n\nexport function isNegativeNumber<N extends number>(value: N): value is Negative<N> {\n\treturn NEGATIVE_NUMBER_SCHEMA.safeParse(value).success;\n}\n\nexport function validateNonPositiveNumber<N extends number>(value: N): asserts value is Negative<N> {\n\tNON_POSITIVE_NUMBER_SCHEMA.parse(value);\n}\n\nexport function isNonPositiveNumber<N extends number>(value: N): value is Negative<N> {\n\treturn NON_POSITIVE_NUMBER_SCHEMA.safeParse(value).success;\n}\n","import type { NonNegative } from \"type-fest/source/numeric\";\nimport { z } from \"zod\";\n\nexport type { NonNegative } from \"type-fest/source/numeric\";\n\nexport const POSITIVE_NUMBER_SCHEMA = z.number().positive();\nexport const NON_NEGATIVE_NUMBER_SCHEMA = z.number().nonnegative();\n\nexport function validatePositiveNumber<N extends number>(value: N): asserts value is NonNegative<N> {\n\tPOSITIVE_NUMBER_SCHEMA.parse(value);\n}\n\nexport function isPositiveNumber<N extends number>(value: N): value is NonNegative<N> {\n\treturn POSITIVE_NUMBER_SCHEMA.safeParse(value).success;\n}\n\nexport function validateNonNegativeNumber<N extends number>(value: N): asserts value is NonNegative<N> {\n\tNON_NEGATIVE_NUMBER_SCHEMA.parse(value);\n}\n\nexport function isNonNegativeNumber<N extends number>(value: N): value is NonNegative<N> {\n\treturn NON_NEGATIVE_NUMBER_SCHEMA.safeParse(value).success;\n}\n","import { z } from \"zod\";\n\nexport type MaxSafeInteger = 9_007_199_254_740_991;\nexport type MinSafeInteger = -9_007_199_254_740_991;\n\nexport const SAFE_NUMBER_SCHEMA = z.number().safe();\nexport const MAX_SAFE_NUMBER_SCHEMA = z.literal(Number.MAX_SAFE_INTEGER as MaxSafeInteger);\nexport const MIN_SAFE_NUMBER_SCHEMA = z.literal(Number.MIN_SAFE_INTEGER as MinSafeInteger);\n\nexport function validateSafeNumber(value: number): asserts value is number {\n\tSAFE_NUMBER_SCHEMA.parse(value);\n}\n\nexport function isSafeNumber(value: number): value is number {\n\treturn SAFE_NUMBER_SCHEMA.safeParse(value).success;\n}\n\nexport function validateMaxSafeNumber(value: number): asserts value is MaxSafeInteger {\n\tMAX_SAFE_NUMBER_SCHEMA.parse(value);\n}\n\nexport function isMaxSafeNumber(value: number): value is MaxSafeInteger {\n\treturn MAX_SAFE_NUMBER_SCHEMA.safeParse(value).success;\n}\n\nexport function validateMinSafeNumber(value: number): asserts value is MinSafeInteger {\n\tMIN_SAFE_NUMBER_SCHEMA.parse(value);\n}\n\nexport function isMinSafeNumber(value: number): value is MinSafeInteger {\n\treturn MIN_SAFE_NUMBER_SCHEMA.safeParse(value).success;\n}\n"]}