🕹 Loscore
all symbols
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
async.ts
Functions
f
collectUint8Array
(
iterable
:
AsyncIterable
<
Uint8Array
>
)
:
Promise
<
Uint8Array
>
f
defer
<
T
,
F
extends
(
...args
:
never
[]
) =>
Promise
<
T
>
>
(
callback
:
F
)
: ((
...args
:
Parameters
<
F
>
) =>
Promise
<
T
>)
f
filter
<
T
>
(
iterable
:
AsyncIterable
<
T
>
,
check
: (
value
:
T
) =>
unknown
)
:
AsyncIterable
<
T
>
f
flatSlice
<
T
>
(
iterable
:
AsyncIterable
<
T
[]>
,
start
:
number
,
end
:
number
)
:
AsyncIterable
<
T
[]>
f
flatten
<
T
>
(
iterable
:
GeneralIterable
<
GeneralIterable
<
T
>>
)
:
AsyncIterable
<
T
>
f
fold
<
T
,
S
>
(
iterable
:
AsyncIterable
<
T
>
,
initial
:
S
,
accumulate
: (
accumulator
:
S
,
value
:
T
) =>
S
)
:
Promise
<
S
>
f
isAsyncIterable
(
data
:
unknown
)
: data
is
AsyncIterable
<
unknown
>
f
map
<
T
,
S
>
(
iterable
:
AsyncIterable
<
T
>
,
convert
: (
value
:
T
) =>
S
)
:
AsyncIterable
<
S
>
f
mapStream
<
T
,
S
>
(
stream
:
ReadableStream
<
T
>
,
callback
: (
value
:
T
) =>
S
)
:
ReadableStream
<
S
>
f
reduce
<
T
>
(
iterable
:
AsyncIterable
<
T
>
,
accumulate
: (
accumulator
:
T
,
value
:
T
) =>
T
)
:
Promise
<
T
|
undefined
>
f
sleep
(
ms
:
number
)
:
Promise
<
void
>
f
slice
<
T
>
(
iterable
:
AsyncIterable
<
T
>
,
start
:
number
,
end
:
number
)
:
AsyncIterable
<
T
>
f
sum
(
iterable
:
AsyncIterable
<
number
>
)
:
Promise
<
number
>
f
toStream
<
T
>
(
iterable
:
AsyncIterable
<
T
>
)
:
ReadableStream
<
T
>
Type Aliases
T
GeneralIterable
<
T
>
=
AsyncIterable
<
T
>
|
Iterable
<
T
>