# API

add: {
    (a: number, b: number): number;
    (a: number): (b: number) => number;
    (a: bigint, b: bigint): bigint;
    (a: bigint): (b: bigint) => bigint;
}

// Basic
add(1, 2) // 3

// Bigint
add(1n, 2n) // 3n

// Curry
const plus2(2)
plus2(-3) // -1

advance: <T>(val: T | AnyFn<any, T>) => T

advance(1) // 1
advance(() => 1) // 1

and: <T, U>(a: T | AnyFn<any, T>, b: U | AnyFn<any, U>) => T extends FalsyLike ? false : U extends FalsyLike ? false : boolean

and(true, true) // true
and(false, true) // false
and(true, false) // false
and(false, false) // false
and(() => 1, () => 2) // true
and(() => 1, () => 0) // false

append: <T, U>(val: T, list: U[]) => (T | U)[]

append('Tom', ['hello']) // ['hello', 'Tom']
append('Tom', []) // ['Tom']
append(['Tom'], ['hello', 'world']) // ['hello', 'world', ['Tom']]

chunk: <T extends number, U extends readonly unknown[]>(size: T, array: U) => T extends 0 ? U : `${T}` extends `-${number}` ? U : U extends readonly [
] ? U : U extends readonly (infer R)[] ? R[][] : never

// Basic
chunk(1, ['a', 'b', 'c', 'd']) // [['a'], ['b'], ['c'], ['d']]
chunk(3, ['a', 'b', 'c', 'd']) // [['a', 'b', 'c'], ['d']]
chunk(5, ['a', 'b', 'c', 'd']) // [['a', 'b', 'c', 'd']]

// Illegal size
chunk(0, ['a', 'b', 'c']) // ['a', 'b', 'c']
chunk(-3, ['a', 'b', 'c']) // ['a', 'b', 'c']
chunk(5, []) // []

constructorName: (val: unknown) => string

constructorName(null) // ''
constructorName(undefined) // ''
constructorName({}) // 'Object'
constructorName('') // 'String'

curry: <T extends unknown[], R>(fn: (...args: T) => R) => T["length"] extends 0 ? () => R : Curried<T, R>

const replace = (from: string, to: string, val: string) => val.replace(from, to)
const curriedReplace = curry(replace)
const curriedReplace('hello', 'hi', 'hello world') // 'hi world'
const curriedReplace('hello')('hi', 'hello world') // 'hi world'
const curriedReplace('hello')('hi')('hello world') // 'hi world'

dec: {
    (val: number): number;
    (val: bigint): bigint;
}

dec(100) // 99
dec(10n) // 9n

defaultTo: <T extends unknown>(a: T) => <U extends unknown>(b: U) => IsNil<U> extends true ? T : IsNumber<U> extends false ? U : T | U

const defaultVal = defaultTo('anonymous')
defaultVal(undefined) // 'anonymous'
defaultVal(null) // 'anonymous'
defaultVal(NaN) // 'anonymous'

defaultVal('Tom') // 'Tom'

divide: {
    (a: number, b: number): number;
    (a: number): (b: number) => number;
    (a: bigint, b: bigint): bigint;
    (a: bigint): (b: bigint) => bigint;
} & {
    (a: typeof _, b: number): (a: number) => number;
    (a: typeof _, b: bigint): (a: bigint) => bigint;
}

// Number
divide(10, 100) // 0.1

// Bigint
divide(1n, 2n) // 3n

// First argument curry
const reciprocal = divide(1)
reciprocal(4) // 0.25

// Second argument curry
import { _ } from 'fonction'
const half = divide(_, 2)
half(20) // 10

endsWith: <T extends string, U extends string | undefined = undefined>(val: T, target?: U | undefined) => EndsWith<U>

// Basic
endsWith('world', 'hello world') // true
endsWith('earth', 'hello world') // false

// Curry
const endsWithHtml = endsWith('html')
endsWithHtml('index.html') // true

entries$0: {
    <T>(val: {
        [key: string]: T;
    } | ArrayLike<T>): [string, T][];
    (val: Record<string, unknown>): [string, unknown][];
}

entries({ a: 'b' }) // [['a', 'b']]
entries(['a', 'b', 'c']) // [['0', 'a'], ['1', 'b'], ['2', 'c']]
entries({}) // []
entries([]) // []

equal: <T, U extends T>(a: T, b: U) => boolean

equals(-0, 0) // true
equals(NaN, NaN) // true
equals([[[[]]]], [[[[]]]]) // true
equals({ a: { b: [1, 2, 3]}}, { a: { b: [1, 2, 3]}}) // true

F: AnyFn<unknown, false>

F() // false
F(1, 'hello', 'world') // false

first: <T extends string | readonly unknown[]>(val: T) => First<T>

// String
first('') // ''
first('hello') // 'h'

// Array
first('hello', 'new', 'world') // 'hello'
first([]) // undefined
first(['one', 2, 3, 4]) // 'one'

flattenDeep: <T extends readonly unknown[]>(val: T) => FlattenDeep<T>

flattenDeep([]) // []
flattenDeep([1, [2, [3, [4]], 5]]) // [1, 2, 3, 4, 5]

gt: <T extends Ord>(a: T, b: T) => boolean

// Number
gt(2, 1) // true
gt(2, 2) // false

// Bigint
gt(2n, 1n) // true
gt(2n, 2n) // false

// String
gt('z', 'a') // true
gt('a', 'z') // false

// Boolean
gt(true, false) // true
gt(false, true) // false
gt(true, true) // false
gt(false, false) // false

// Date
gt(new Date('2000/1/2'), new Date('2000/1/1')) // true
gt(new Date('1999/12/31'), new Date('2000/1/1')) // false
gt(new Date('2000/1/1'), new Date('2000/1/1')) // false

gte: <T extends Ord>(a: T, b: T) => boolean

// Number
gte(2, 1) // true
gte(2, 2) // true
gte(2, 3) // false

// Bigint
gte(2n, 1n) // true
gte(2n, 2n) // true
gte(2n, 3n) // false

// String
gte('z', 'a') // true
gte('a', 'a') // true
gte('a', 'z') // false

// Boolean
gte(true, false) // true
gte(true, true) // true
gte(false, false) // true
gte(false, true) // false

// Date
gte(new Date('2000/1/2'), new Date('2000/1/1')) // true
gte(new Date('2000/1/1'), new Date('2000/1/1')) // true
gte(new Date('1999/12/31'), new Date('2000/1/1')) // false

has: <T extends string | number | (string | number)[], U extends Record<PropertyKey, unknown>>(props: T, obj: U) => T extends unknown[] ? boolean : T extends string | number ? U extends Record<T, unknown> ? true : false : never

// Flat
has('hello', { hello: 'world' }) // true
has(0, { 0 : 1}) // true
has('', {}) // false
has('hello', { hi : hello: 'world' }) // false

// Nest
hasPath(['hello'], { hello: 'world' }) // true
hasPath([0], { 0: 1 }) // true
hasPath(['hello', 'world'], { hello: { world: '' } } // true

hasPath(['hi'], { hello: '' } ) // false
hasPath(['hi', 'Tom'], { hi: { John: 1 } } ) // false

hasPath: <T extends unknown>(path: (string | number)[], obj: Record<PropertyKey, T>) => boolean

hasPath(['hello'], { hello: 'world' }) // true
hasPath([0], { 0: 1 }) // true
hasPath(['hello', 'world'], { hello: { world: '' } } // true

hasPath(['hi'], { hello: '' } ) // false
hasPath(['hi', 'Tom'], { hi: { John: 1 } } ) // false

head: {
    (val: string): string;
    <T extends unknown[]>(val: T): T;
}

// String
head('hello') // 'hell'
head('h') // ''
head('') // ''

head([1, 2, 3]) // [1, 2]
head(['hello', 'world']) // ['hello']
head(['hello']) // []
head([]) // []

identity: <T>(val: T) => T

identity(1) // 1
identity({}) // {}

ifElse: <V, T, F>(val: V | AnyFn<any, V>, onTrue: T | AnyFn<any, T>, onFalse: F | AnyFn<any, F>) => V extends FalsyLike ? F : V extends true ? T : T | F

ifElse(true, 1, 0) // 1
ifElse(false, 1, 0) // 0
ifElse(undefined, 1, 0) // 0
ifElse(() => true, () => 1, () => 0) // 1

ifElseFn: <V, R, T, F>(condition: (val: V) => R, onTrue: T | ((val: V) => T), onFalse: F | ((val: V) => F)) => (val: V) => R extends true ? T : R extends FalsyLike ? F : T | F

ifElseFn((x: number) => x > 10, 'big', 'small')(20) // 'big'
const fn = ifElseFn((x: number) => x > 10, (x) => x + 1, (x) => x - 1)
fn(11) // 12
fn(9) // 8

inc: {
    (val: number): number;
    (val: bigint): bigint;
}

inc(100) // 101
inc(10n) // 11n

includes: ((collection: string | unknown[], val: unknown) => boolean) & ((collection: string | unknown[]) => (val: unknown) => boolean)

includes('hello', 'lo') // true
includes([1, 2, 3], 3) // true

isArray: (val: unknown) => val is any[]

isArray([]) // true
isArray(['hello', 'world']) // true
isArray({}) // false

isBigint: (val: unknown) => val is bigint

isBigint(1n) // true
isBigint(1000) // false

isBoolean: (val: unknown) => val is boolean

isBoolean(true) // true
isBoolean('hello') // false

isEmpty: (val: unknown) => val is Empty

isEmpty('') // true
isEmpty({}) // true
isEmpty([]) // true

isEmpty('hello world') // false
isEmpty(1000) // false

isFunction: (val: unknown) => val is AnyFn<any, unknown>

isFunction(function) // true
isFunction('hello') // false

isJSONObject: (val: unknown) => val is Record<PropertyKey, unknown>

isJSONObject({ hoge: 'huga'}) // true
isJSONObject(Object()) // true
isJSONObject(new Object()) // true

isJSONObject([]) // false
isJSONObject(new Set()) // false

isLength0: (val: unknown) => val is 0

isLength0([]) // true
isLength0([]) // true
isLength0('hello') // false
isLength0(undefined) // false

isNaN: (val: unknown) => val is number

isNaN(NaN) // true
isNaN(100) // false

isNil: (val: unknown) => val is null | undefined

isNil(undefined) // true
isNil(null) // true
isNil([]) // false

isNill: (val: unknown) => val is null | undefined

isNumber(0) // true
isNumber('hello') // false

isNull: (val: unknown) => val is null

isNull(null) // true
isNull(undefined) // false

isNumber: (val: unknown) => val is number

isNumber(0) // true
isNumber('hello') // false

isObject: (val: unknown) => val is Record<string, unknown>

isObject([]) // true
isObject('hello') // false

isPrimitive: (val: unknown) => val is Primitive

isPrimitive(true) // true
isPrimitive([]) // false

isString: (val: unknown) => val is string

isString('hello world') // true
isString(1000) // false

isSymbol: (val: unknown) => val is symbol

isSymbol(Symbol('hello')) // true
isSymbol('hello') // false

isUndefined: (val: unknown) => val is undefined

isUndefined(undefined) // true
isUndefined('hello') // false

K: <T extends unknown>(val: T) => () => T

const k = K('k')
k() // 'k'

keys$0: <T extends PropertyKey>(val: Record<T, unknown>) => string[]

keys({}) // []
keys({ 'a': 'b' }) // ['a']
keys({ 0: 'hello', 1: 'world' }) // ['0', '1']

last: <T extends string | readonly unknown[]>(val: T) => Last<T>

// String
last('hello') // 'o'

// Array
last('hello', 'new', 'world') // 'world'
last([]) // undefined
last(['one', 2, 3, 4]) // 4

length: <T extends {
    length: number;
}>(val: T) => T["length"]

length('hello') // 5
length(['hello', 'world', 1]) // 3
length({length: 5, text: 'hello'}) // 5

lowerCase: <T extends string>(val: T) => Lowercase<T>

toLower('Hello') // hello

lt: <T extends Ord>(a: T, b: T) => boolean

// Number
lt(1, 2) // true
lt(2, 2) // false

// Bigint
lt(1n, 2n) // true
lt(2n, 2n) // false

// String
lt('a', 'z') // true
lt('a', 'a') // false

// Boolean
lt(false, true) // true
lt(true, true) // false
lt(false, false) // false
lt(true, false) // false

// Date
lt(new Date('1999/12/31'), new Date('2000/1/1')) // true
lt(new Date('2000/1/1'), new Date('2000/1/1')) // false
lt(new Date('2000/1/2'), new Date('2000/1/1')) // false

lte: <T extends Ord>(a: T, b: T) => boolean

// Number
lte(1, 2) // true
lte(2, 2) // true
lte(2, 1) // false

// Bigint
lte(1n, 2n) // true
lte(2n, 2n) // true
lte(2n, 1n) // true

// String
lte('a', 'z') // true
lte('a', 'a') // true
lte('z', 'a') // false

// Boolean
lte(true, true) // true
lte(false, false) // true
lte(false, true) // true
lte(true, false) // false

// Date
lte(new Date('2000/1/1'), new Date('2000/1/1')) // true
lte(new Date('1999/12/31'), new Date('2000/1/1')) // true
lte(new Date('2000/1/2'), new Date('2000/1/1')) // false

map: {
    <T extends readonly unknown[], U>(fn: (value: T[number], index: number, list: T) => U, list: T): MapArray<U, T>;
    <T extends {
        [k: string]: unknown;
    }, U>(fn: (val: T[keyof T], prop: keyof T, list: T) => U, list: T): MapObject<U, T>;
}

const triple = (val: number):number => val * 3
map(triple, [1, 2, 3]) // [3, 6, 9]
map(triple, { tom: 1, john: 2, bob: 3 }) // { tom: 3, john: 6, bob: 9}

multiply: {
    (a: number, b: number): number;
    (a: number): (b: number) => number;
    (a: bigint, b: bigint): bigint;
    (a: bigint): (b: bigint) => bigint;
}

// Basic
multiply(2, 3) // 6

// Bigint
multiply(2n, 3n) // 6n

// Curry
const double = multiply(2)
double(4) // 8

N: <T>(val: T) => T extends FalsyLike ? true : boolean

N('') // true
N(false) // true
N(0) // true
N(NaN) // true
N(undefined) // true
N(null) // true

N({}) // false
N([]) // false

NN: <T>(val: T) => T extends FalsyLike ? false : boolean

NN('') // false
NN(false) // false
NN(0) // false
NN(NaN) // false
NN(undefined) // false
NN(null) // false

NN({}) // true
NN([]) // true

not: <T extends AnyFn<any, unknown>>(fn: T) => (...val: Parameters<T>) => boolean

not(() => true)() // false
const gt10 = (val: number) => val > 10
not(gt10)(11) // false

or: <T, U>(a: T | AnyFn<any, T>, b: U | AnyFn<any, U>) => T extends FalsyLike ? U extends FalsyLike ? false : boolean : boolean

or(true, true) // true
or(false, true) // true
or(true, false) // true
or(false, false) // false

or(() => 0, () => 1) // true
or(() => 0, () => 0) // false

pipe: Pipe

const fn = pipe(add , inc)
fn(1, 1) // 3

prepend: <T, U>(val: T, list: U[]) => (T | U)[]

prepend('Tom', ['hello']) // ['Tom', 'hello']
prepend('Tom', []) // ['Tom']
prepend(['Tom'], ['hello', 'world']) // [['Tom'], 'hello', 'world']

product: {
    (val: [
    ]): 0;
    (val: number[]): number;
    (val: bigint[]): bigint;
}

product([1, 2, 3, 4, 5]) // 120
product([1n, 2n, 3n, 4n, 5n]) //120n
product([]) // 0

props: <T extends string | number, U extends Record<PropertyKey, unknown>>(val: T, obj: U) => U extends Record<T, unknown> ? U[T] : undefined

props('x', { x: 'hello' }) // 'hello'
props(1, { 1: 100 }) // 100
props('x', {}) // undefined

replace: <From extends string, To extends string, T extends string>(from: From, to: To, val: T) => Replace<T, From, To>

replace('hello Tom', 'Tom', 'Bob') // 'hello Bob'
replace('hogehoge', 'hoge', 'fuga') // 'fugahoge'

replaceAll: <From extends string, To extends string, T extends string>(from: From, to: To, val: T) => ReplaceAll<T, From, To>

replaceAll('hello Tom', 'Tom', 'Bob') // 'hello Bob'
replaceAll('hogehoge', 'hoge', 'fuga') // 'fugafuga'

reverse: {
    (val: string): string;
    (val: ""): "";
    <T extends [
    ]>(val: T): [
    ];
    <T extends unknown[]>(val: T): T;
}

// String
reverse('hello') // 'olleh'

// Any Array
reverse(['hello', 'new', 'world']) // ['world', 'new', 'hello']
reverse([0, {}, []]) // [[], {}, 0]

slice: <T extends string | readonly unknown[]>(from: number, to: number, val: T) => T

// String
slice(6, 11 ,'hello world') // 'world'

// Array
slice(1, 2 ,[1, 2, 3, 4]) // [2]

startsWith: <T extends string, U extends string | undefined = undefined>(val: T, target?: U | undefined) => StartsWith<U>

// Basic
startsWith('hello', 'hello world') // true
startsWith('good', 'hello world') // false

// Curry
const startWithSlash = startsWith('/')
startWithSlash('/path/to') // true

subtract: {
    (a: number, b: number): number;
    (a: number): (b: number) => number;
    (a: bigint, b: bigint): bigint;
    (a: bigint): (b: bigint) => bigint;
} & {
    (a: typeof _, b: number): (a: number) => number;
    (a: typeof _, b: bigint): (a: bigint) => bigint;
}

// Number
subtract(2, 1) // 1

// Bigint
subtract(3n, 2n) //1n

// First argument curry
const from5Minus = subtract(5)
from5Minus(10) // -5

// Second argument curry
import { _ } from 'fonction'
const minus5 = (_, 5)
minus5(20) // 15

sum: {
    (val: [
    ]): 0;
    (val: number[]): number;
    (val: bigint[]): bigint;
}

sum([1, 2, 3, 4, 5]) // 15
sum([1n, 2n, 3n, 4n, 5n]) // 15n
sum([]) // 0

T: AnyFn<unknown, true>

T() // true
T(1, 'hello', 'world') // true

tail: {
    (val: string): string;
    <T extends unknown[]>(val: T): T;
}

// String
tail('hello') // 'ello'
tail('h') // ''
tail('') // ''

tail([1, 2, 3]) // [2, 3]
tail(['hello', 'world']) // ['world']
tail(['hello']) // []
tail([]) // []

take: <T extends string | readonly unknown[]>(howMany: number, val: T) => T

// String
take(3, 'hello') // 'hel'

// Array
take(3, [1, 2, 3, 4]) // [1, 2, 3]

takeLast: <T extends string | readonly unknown[]>(howMany: number, val: T) => T

// String
takeLast(3, 'hello') // 'llo'

// Array
takeLast(3, [1, 2, 3, 4]) // [2, 3, 4]

tap: <T>(fn: Arity1Fn<T, unknown>) => <R extends T>(val: R) => R

tap(console.log)('hello') // hello
// log: hello

test: ((regExp: RegExp, val: string) => boolean) & ((regExp: RegExp) => (val: string) => boolean)

test(new RegExp('^test'), 'testdata') // true
test(/xyz$/, 'testxyz') // true

trim: <T extends string>(val: T) => TrimLeft<TrimRight<T>>

trim('   hello   ') // 'hello'

trimLeft: <T extends string>(val: T) => TrimLeft<T>

trimLeft('   hello') // 'hello'
trimLeft(' \n\thello') // 'hello'

trimRight: <T extends string>(val: T) => TrimRight<T>

trimRight('hello   ') // 'hello'
trimRight('hello \n\t') // 'hello'

tryCatch: <R, E, P = unknown>(tryer: AnyFn<any, R>, catcher?: E | AnyFn<P, E> | undefined) => R | E

tryCatch(() => { throw Error('error') }) // Error('error')
tryCatch(() => { throw Error('error') }, 0) // 0
tryCatch(() => { throw Error('error') }, (e: Error) => e.message ) // 'error'

uniq: <T extends unknown>(val: readonly T[]) => T[]

uniq([1, 2, 1, 1]) // [1, 2]
uniq([{}, {}, [], []]) // [{}, []]
uniq([[1, 2, 3], [1, 2, 3]]) // [[1, 2, 3]]

upperCase: <T extends string>(val: T) => Uppercase<T>

toUpper('Hello') // HELLO

values$0: <T extends unknown>(val: Record<PropertyKey, T> | ArrayLike<T>) => T[]

// Object
values({}) // []
values({ 'a': 'b' }) // ['b']
values({ 0: 'hello', 1: 'world' }) // ['hello', 'world']

// Array
values([]) // []
values(['hello', 'world']) // ['hello', 'world']

xor: <T, U>(a: T | AnyFn<any, T>, b: U | AnyFn<any, U>) => T extends FalsyLike ? U extends FalsyLike ? false : boolean : boolean

xor(true, false) // true
xor(false, true) // true
xor(true, true) // false
xor(false, false) // false
xor(() => 1, () => 0) // true
xor(() => 0, () => 0) // false

type AnyFn<T = any, U = unknown> = (...args: T[]) => U;