🕹 Loscore
index.ts
Functions
f
capitalize
(
string
:
string
)
:
string
f
compact
<
T
>
(
iterable
:
Iterable
<
T
>
)
:
Iterable
<
Exclude
<
T
,
0
|
""
|
false
|
null
|
undefined
>>
f
deepClone
<
T
>
(
x
:
T
)
:
T
f
deepEqual
(
one
:
unknown
,
other
:
unknown
)
:
boolean
f
every
<
T
>
(
iterable
:
Iterable
<
T
>
)
:
boolean
|
T
f
filter
<
T
>
(
iterable
:
Iterable
<
T
>
,
test
: (
value
:
T
) =>
unknown
)
:
Iterable
<
T
>
f
filterValues
<
K
extends
string
,
V
>
(
object
:
Record
<
K
,
V
>
,
test
: (
value
:
V
) =>
unknown
)
:
Record
<
string
,
V
>
f
flatten
<
T
>
(
iterable
:
Iterable
<
Iterable
<
T
>>
)
:
Iterable
<
T
>
f
flow
<
T
>
(
...array
: ((
value
:
T
) =>
T
)[]
)
: ((
value
:
T
) =>
T
)
f
fold
<
T
,
S
>
(
iterable
:
Iterable
<
T
>
,
initial
:
S
,
accumulate
: (
accumulator
:
S
,
value
:
T
) =>
S
)
:
S
f
groupBy
<
T
,
K
extends
number
|
string
|
symbol
>
(
iterable
:
Iterable
<
T
>
,
getKey
: (
value
:
T
) =>
K
)
:
Record
<
K
,
T
[]>
f
identity
<
T
>
(
value
:
T
)
:
T
f
interleave
<
T
,
S
>
(
array
:
T
[]
,
separator
:
((
index
:
number
) =>
S
)
|
S
)
:
Iterable
<
S
|
T
>
f
isAlphabetic
(
text
:
string
)
:
boolean
f
isBoolean
(
value
:
unknown
)
: value
is
boolean
f
isLowerCase
(
text
:
string
)
:
boolean
f
isNumber
(
value
:
unknown
)
: value
is
number
f
isString
(
value
:
unknown
)
: value
is
string
f
isTruthy
<
T
>
(
value
:
T
)
: value
is
Exclude
<
T
,
0
|
""
|
false
|
null
|
undefined
>
f
isUpperCase
(
text
:
string
)
:
boolean
f
last
<
T
>
(
array
:
T
[]
)
:
T
|
undefined
f
map
<
T
,
S
>
(
iterable
:
Iterable
<
T
>
,
convert
: (
value
:
T
) =>
S
)
:
Iterable
<
S
>
f
mapValues
<
K
extends
number
|
string
|
symbol
,
V
,
W
>
(
object
:
Record
<
K
,
V
>
,
convert
: (
value
:
V
) =>
W
)
:
Record
<
string
,
W
>
f
once
<
T
extends
unknown
[]
,
S
>
(
f
: (
...args
:
T
) =>
S
)
: ((
...args
:
T
) =>
S
)
f
range
(
start
:
number
,
end
?
:
number
,
step
?
:
number
)
:
Iterable
<
number
>
f
reduce
<
T
>
(
iterable
:
Iterable
<
T
>
,
accumulate
: (
accumulator
:
T
,
value
:
T
) =>
T
)
:
T
|
undefined
f
shuffle
<
T
>
(
array
:
T
[]
)
:
T
[]
f
size
(
object
:
object
)
:
number
f
some
<
T
>
(
iterable
:
Iterable
<
T
>
)
:
false
|
T
f
sortBy
<
T
>
(
array
:
T
[]
,
test
: (
value
:
T
) =>
SortKey
)
:
T
[]
f
sum
(
iterable
:
Iterable
<
number
>
)
:
number
f
unique
<
T
>
(
iterable
:
Iterable
<
T
>
)
:
Iterable
<
T
>
f
uniqueBy
<
T
>
(
iterable
:
Iterable
<
T
>
,
buildKey
: (
value
:
T
) =>
unknown
)
:
Iterable
<
T
>
f
zip
<
T
,
S
>
(
iterable1
:
Iterable
<
T
>
,
iterable2
:
Iterable
<
S
>
)
:
Iterable
<
[
T
,
S
]
>
Type Aliases
T
SortKey
=
boolean
|
Date
|
number
|
SortKey
[]
|
string
Usage
import * as mod from "index.ts";
Symbols
f
capitalize
f
compact
f
deepClone
f
deepEqual
f
every
view all 50 symbols
Document Navigation
Functions
capitalize
compact
deepClone
deepEqual
every
filter
filterValues
flatten
flow
fold
groupBy
identity
interleave
isAlphabetic
isBoolean
isLowerCase
isNumber
isString
isTruthy
isUpperCase
last
map
mapValues
once
range
reduce
shuffle
size
some
sortBy
sum
unique
uniqueBy
zip
Type Aliases
SortKey