@types/prelude-ls

Version 1.1.34
Published 11 months ago
25 kB
No dependencies
MIT license

Install

npm i @types/prelude-ls

yarn add @types/prelude-ls

pnpm add @types/prelude-ls

Overview

TypeScript definitions for prelude-ls

Index

Variables

Functions

abs()
acos()
all()
andList()
any()
apply()
asin()
at()
atan()
atan2()
breakList()
breakStr()
camelize()
capitalize()
ceiling()
chars()
compact()
concat()
concatMap()
cos()
countBy()
curry()
dasherize()
difference()
div()
drop()
dropWhile()
each()
elemIndex()
elemIndices()
empty()
even()
exp()
filter()
find()
findIndex()
findIndices()
fix()
flatten()
flip()
floor()
fold()
fold1()
foldl()
foldl1()
foldr()
foldr1()
gcd()
groupBy()
head()
id()
initial()
intersection()
isItNaN()
isType()
join()
keys()
last()
lcm()
lines()
listsToObj()
ln()
map()
max()
maximum()
maximumBy()
mean()
min()
minimum()
minimumBy()
mod()
negate()
objToLists()
objToPairs()
odd()
orList()
over()
pairsToObj()
partition()
pow()
product()
quot()
recip()
reject()
rem()
repeat()
replicate()
reverse()
round()
scan()
scan1()
scanl()
scanl1()
scanr()
scanr1()
signum()
sin()
slice()
sort()
sortBy()
sortWith()
span()
split()
splitAt()
sqrt()
sum()
tail()
take()
takeWhile()
tan()
truncate()
unchars()
unfoldr()
union()
unique()
uniqueBy()
unlines()
unwords()
values()
words()
zip()
zipAll()
zipAllWith()
zipWith()

Namespaces

Variables

variable pi

var pi: number;

variable tau

var tau: number;

Functions

function abs

abs: (x: number) => number;

function acos

acos: (x: number) => number;

function all

all: {
    <A>(f: (x: A) => boolean): (xs: A[]) => boolean;
    <A>(f: (x: A) => boolean, xs: A[]): boolean;
};

function andList

andList: <A>(xs: A[]) => boolean;

function any

any: {
    <A>(f: (x: A) => boolean): (xs: A[]) => boolean;
    <A>(f: (x: A) => boolean, xs: A[]): boolean;
};

function apply

apply: {
    <A, B>(f: (...args: A[]) => B): (args: A[]) => B;
    <A, B>(f: (...args: A[]) => B, args: A[]): B;
};

function asin

asin: (x: number) => number;

function at

at: { <A>(n: number): (xs: A[]) => A; <A>(n: number, xs: A[]): A };

function atan

atan: (x: number) => number;

function atan2

atan2: (x: number, y: number) => number;

function breakList

breakList: {
    <A>(p: (x: A) => boolean): (xs: A[]) => [A[], A[]];
    <A>(p: (x: A) => boolean, xs: A[]): [A[], A[]];
};

function breakStr

breakStr: {
    (f: (str: string) => boolean): (str: string) => [string, string];
    (f: (str: string) => boolean, str: string): [string, string];
};

function camelize

camelize: (str: string) => string;

function capitalize

capitalize: (str: string) => string;

function ceiling

ceiling: (x: number) => number;

function chars

chars: (str: string) => string[];

function compact

compact: {
    <A>(xs: A[]): A[];
    <A>(object: { [key: string]: A }): { [key: string]: A };
    <A>(object: { [key: number]: A }): { [key: number]: A };
};

function concat

concat: <A>(xss: A[][]) => A[];

function concatMap

concatMap: {
    <A, B>(f: (x: A) => B[]): (xs: A[]) => B[];
    <A, B>(f: (x: A) => B[], xs: A[]): B[];
};

function cos

cos: (x: number) => number;

function countBy

countBy: {
    <A, B>(f: (x: A) => B): (xs: A[]) => any;
    <A, B>(f: (x: A) => B, xs: A[]): any;
};

function curry

curry: (f: Function) => Function;

function dasherize

dasherize: (str: string) => string;

function difference

difference: <A>(...xss: A[][]) => A[];

function div

div: { (x: number): (y: number) => number; (x: number, y: number): number };

function drop

drop: {
    <A>(n: number): (xs: A[]) => A[];
    <A>(n: number, xs: A[]): A[];
    (n: number): (str: string) => string;
    (n: number, str: string): string;
};

function dropWhile

dropWhile: {
    <A>(p: (x: A) => boolean): (xs: A[]) => A[];
    <A>(p: (x: A) => boolean, xs: A[]): A[];
    (f: (str: string) => boolean): (str: string) => string;
    (f: (str: string) => boolean, str: string): string;
};

function each

each: {
    <A>(f: (x: A) => void): (xs: A[]) => A[];
    <A>(f: (x: A) => void, xs: A[]): A[];
    <A>(f: (x: A) => void): (object: { [key: string]: A }) => { [key: string]: A };
    <A>(f: (x: A) => void, object: { [key: string]: A }): { [key: string]: A };
    <A>(f: (x: A) => void): (object: { [key: number]: A }) => { [key: number]: A };
    <A>(f: (x: A) => void, object: { [key: number]: A }): { [key: number]: A };
};

function elemIndex

elemIndex: { <A>(x: A): (xs: A[]) => number; <A>(x: A, xs: A[]): number };

function elemIndices

elemIndices: { <A>(x: A): (xs: A[]) => number[]; <A>(x: A, xs: A[]): number[] };

function empty

empty: {
    <A>(xs: A[]): boolean;
    <A>(object: any): boolean;
    (str: string): boolean;
};

function even

even: (x: number) => boolean;

function exp

exp: (x: number) => number;

function filter

filter: {
    <A>(f: (x: A) => boolean): (xs: A[]) => A[];
    <A>(f: (x: A) => boolean, xs: A[]): A[];
    <A>(f: (x: A) => boolean): (object: { [key: string]: A }) => {
        [key: string]: A;
    };
    <A>(f: (x: A) => boolean, object: { [key: string]: A }): { [key: string]: A };
    <A>(f: (x: A) => boolean): (object: { [key: number]: A }) => {
        [key: number]: A;
    };
    <A>(f: (x: A) => boolean, object: { [key: number]: A }): { [key: number]: A };
};

function find

find: {
    <A>(f: (x: A) => Boolean): (xs: A[]) => A;
    <A>(f: (x: A) => Boolean, xs: A[]): A;
    <A>(f: (x: A) => boolean): (object: { [key: string]: A }) => A;
    <A>(f: (x: A) => boolean, object: { [key: string]: A }): A;
    <A>(f: (x: A) => boolean): (object: { [key: number]: A }) => A;
    <A>(f: (x: A) => boolean, object: { [key: number]: A }): A;
};

function findIndex

findIndex: {
    <A>(f: (x: A) => boolean): (xs: A[]) => number;
    <A>(f: (x: A) => boolean, xs: A[]): number;
};

function findIndices

findIndices: {
    <A>(f: (x: A) => boolean): (xs: A[]) => number[];
    <A>(f: (x: A) => boolean, xs: A[]): number[];
};

function fix

fix: (f: Function) => Function;

function flatten

flatten: (xs: any[]) => any[];

function flip

flip: {
    <A, B, C>(f: (x: A) => (y: B) => C): (y: B) => (x: A) => C;
    <A, B, C>(f: (x: A) => (y: B) => C, y: B): (x: A) => C;
    <A, B, C>(f: (x: A) => (y: B) => C, y: B, x: A): C;
};

function floor

floor: (x: number) => number;

function fold

fold: {
    <A, B>(f: (x: A) => (y: B) => A): (memo: A) => (xs: B[]) => A;
    <A, B>(f: (x: A) => (y: B) => A, memo: A): (xs: B[]) => A;
    <A, B>(f: (x: A) => (y: B) => A, memo: A, xs: B[]): A;
};

function fold1

fold1: {
    <A>(f: (x: A) => (y: A) => A): (xs: A[]) => A;
    <A>(f: (x: A) => (y: A) => A, xs: A[]): A;
};

function foldl

foldl: {
    <A, B>(f: (x: A) => (y: B) => A): (memo: A) => (xs: B[]) => A;
    <A, B>(f: (x: A) => (y: B) => A, memo: A): (xs: B[]) => A;
    <A, B>(f: (x: A) => (y: B) => A, memo: A, xs: B[]): A;
};

function foldl1

foldl1: {
    <A>(f: (x: A) => (y: A) => A): (xs: A[]) => A;
    <A>(f: (x: A) => (y: A) => A, xs: A[]): A;
};

function foldr

foldr: {
    <A, B>(f: (x: A) => (y: B) => B): (memo: B) => (xs: A[]) => B;
    <A, B>(f: (x: A) => (y: B) => B, memo: B): (xs: A[]) => B;
    <A, B>(f: (x: A) => (y: B) => B, memo: B, xs: A[]): B;
};

function foldr1

foldr1: {
    <A>(f: (x: A) => (y: A) => A): (xs: A[]) => A;
    <A>(f: (x: A) => (y: A) => A, xs: A[]): A;
};

function gcd

gcd: { (x: number): (y: number) => number; (x: number, y: number): number };

function groupBy

groupBy: {
    <A, B>(f: (x: A) => B): (xs: A[]) => any;
    <A, B>(f: (x: A) => B, xs: A[]): any;
};

function head

head: <A>(xs: A[]) => A;

function id

id: <A>(x: A) => A;

function initial

initial: <A>(xs: A[]) => A[];

function intersection

intersection: <A>(...xss: A[][]) => A[];

function isItNaN

isItNaN: (x: number) => boolean;

function isType

isType: {
    <A>(type: string): (x: A) => boolean;
    <A>(type: string, x: A): boolean;
};

function join

join: {
    (separator: string): (xs: string[]) => string;
    (separator: string, xs: string[]): string;
};

function keys

keys: {
    <A>(object: { [key: string]: A }): string[];
    <A>(object: { [key: number]: A }): number[];
};

function last

last: <A>(xs: A[]) => A;

function lcm

lcm: { (x: number): (y: number) => number; (x: number, y: number): number };

function lines

lines: (str: string) => string[];

function listsToObj

listsToObj: {
    <A>(keys: string[]): (values: A[]) => { [key: string]: A };
    <A>(keys: string[], values: A[]): { [key: string]: A };
    <A>(keys: number[]): (values: A[]) => { [key: number]: A };
    <A>(keys: number[], values: A[]): { [key: number]: A };
};

function ln

ln: (x: number) => number;

function map

map: {
    <A, B>(f: (x: A) => B): (xs: A[]) => B[];
    <A, B>(f: (x: A) => B, xs: A[]): B[];
    <A, B>(f: (x: A) => B): (object: { [key: string]: A }) => { [key: string]: B };
    <A, B>(f: (x: A) => B, object: { [key: string]: A }): { [key: string]: B };
    <A, B>(f: (x: A) => B): (object: { [key: number]: A }) => { [key: number]: B };
    <A, B>(f: (x: A) => B, object: { [key: number]: A }): { [key: number]: B };
};

function max

max: {
    <Comparable>(x: Comparable): (y: Comparable) => Comparable;
    <Comparable>(x: Comparable, y: Comparable): Comparable;
};

function maximum

maximum: <A>(xs: A[]) => A;

function maximumBy

maximumBy: {
    <A, B>(f: (x: A) => B): (xs: A[]) => A;
    <A, B>(f: (x: A) => B, xs: A[]): A;
};

function mean

mean: (xs: number[]) => number;

function min

min: {
    <Comparable>(x: Comparable): (y: Comparable) => Comparable;
    <Comparable>(x: Comparable, y: Comparable): Comparable;
};

function minimum

minimum: <A>(xs: A[]) => A;

function minimumBy

minimumBy: {
    <A, B>(f: (x: A) => B): (xs: A[]) => A;
    <A, B>(f: (x: A) => B, xs: A[]): A;
};

function mod

mod: { (x: number): (y: number) => number; (x: number, y: number): number };

function negate

negate: (x: number) => number;

function objToLists

objToLists: {
    <A>(object: { [key: string]: A }): [string[], A[]];
    <A>(object: { [key: number]: A }): [number[], A[]];
};

function objToPairs

objToPairs: {
    <A>(object: { [key: string]: A }): Array<[string, A]>;
    <A>(object: { [key: number]: A }): [number, A][];
};

function odd

odd: (x: number) => boolean;

function orList

orList: <A>(xs: A[]) => boolean;

function over

over: {
    <A, B, C>(
        f: (x: B) => (y: B) => C | ((x: B, y: B) => C),
        g: (x: A) => B,
        x: A,
        y: A
    ): C;
    <A, B, C>(
        f: (x: B, y: B) => C | ((x: B) => (y: B) => C),
        g: (x: A) => B,
        x: A
    ): (y: A) => C;
    <A, B, C>(f: (x: B, y: B) => C, g: (x: A) => B): (x: A, y: A) => C;
    <A, B, C>(f: (x: B) => (y: B) => C, g: (x: A) => B): (x: A) => (y: A) => C;
    <A, B, C>(f: (x: B, y: B) => C): (g: (x: A) => B) => (x: A, y: A) => C;
    <A, B, C>(f: (x: B) => (y: B) => C): (g: (x: A) => B) => (x: A) => (y: A) => C;
};

function pairsToObj

pairsToObj: {
    <A>(object: Array<[string, A]>): { [key: string]: A };
    <A>(object: [number, A][]): { [key: number]: A };
};

function partition

partition: {
    <A>(f: (x: A) => Boolean): (xs: A[]) => [A[], A[]];
    <A>(f: (x: A) => Boolean, xs: A[]): [A[], A[]];
    <A>(f: (x: A) => boolean): (object: {
        [key: string]: A;
    }) => [{ [key: string]: A }, { [key: string]: A }];
    <A>(f: (x: A) => boolean, object: { [key: string]: A }): [
        { [key: string]: A },
        { [key: string]: A }
    ];
    <A>(f: (x: A) => boolean): (object: {
        [key: number]: A;
    }) => [{ [key: number]: A }, { [key: number]: A }];
    <A>(f: (x: A) => boolean, object: { [key: number]: A }): [
        { [key: number]: A },
        { [key: number]: A }
    ];
};

function pow

pow: { (x: number): (y: number) => number; (x: number, y: number): number };

function product

product: (xs: number[]) => number;

function quot

quot: { (x: number): (y: number) => number; (x: number, y: number): number };

function recip

recip: (x: number) => number;

function reject

reject: {
    <A>(f: (x: A) => boolean): (xs: A[]) => A[];
    <A>(f: (x: A) => boolean, xs: A[]): A[];
    <A>(f: (x: A) => boolean): (object: { [key: string]: A }) => {
        [key: string]: A;
    };
    <A>(f: (x: A) => boolean, object: { [key: string]: A }): { [key: string]: A };
    <A>(f: (x: A) => boolean): (object: { [key: number]: A }) => {
        [key: number]: A;
    };
    <A>(f: (x: A) => boolean, object: { [key: number]: A }): { [key: number]: A };
};

function rem

rem: { (x: number): (y: number) => number; (x: number, y: number): number };

function repeat

repeat: {
    (n: number): (str: string) => string;
    (n: number, str: string): string;
};

function replicate

replicate: { <A>(n: number): (x: A) => A[]; <A>(n: number, x: A): A[] };

function reverse

reverse: { <A>(xs: A[]): A[]; (str: string): string };

function round

round: (x: number) => number;

function scan

scan: {
    <A, B>(f: (x: A) => (y: B) => A): (memo: A) => (xs: B[]) => A[];
    <A, B>(f: (x: A) => (y: B) => A, memo: A): (xs: B[]) => A[];
    <A, B>(f: (x: A) => (y: B) => A, memo: A, xs: B[]): A[];
};

function scan1

scan1: {
    <A>(f: (x: A) => (y: A) => A): (xs: A[]) => A[];
    <A>(f: (x: A) => (y: A) => A, xs: A[]): A[];
};

function scanl

scanl: {
    <A, B>(f: (x: A) => (y: B) => A): (memo: A) => (xs: B[]) => A[];
    <A, B>(f: (x: A) => (y: B) => A, memo: A): (xs: B[]) => A[];
    <A, B>(f: (x: A) => (y: B) => A, memo: A, xs: B[]): A[];
};

function scanl1

scanl1: {
    <A>(f: (x: A) => (y: A) => A): (xs: A[]) => A[];
    <A>(f: (x: A) => (y: A) => A, xs: A[]): A[];
};

function scanr

scanr: {
    <A, B>(f: (x: A) => (y: B) => B): (memo: B) => (xs: A[]) => B[];
    <A, B>(f: (x: A) => (y: B) => B, memo: B): (xs: A[]) => B[];
    <A, B>(f: (x: A) => (y: B) => B, memo: B, xs: A[]): B[];
};

function scanr1

scanr1: {
    <A>(f: (x: A) => (y: A) => A): (xs: A[]) => A[];
    <A>(f: (x: A) => (y: A) => A, xs: A[]): A[];
};

function signum

signum: (x: number) => number;

function sin

sin: (x: number) => number;

function slice

slice: {
    <A>(x: number): (y: number) => (xs: A[]) => A[];
    <A>(x: number, y: number): (xs: A[]) => A[];
    <A>(x: number, y: number, xs: A[]): A[];
    (x: number): (y: number) => (str: string) => string;
    (x: number, y: number): (str: string) => string;
    (x: number, y: number, str: string): string;
};

function sort

sort: <A>(xs: A[]) => A[];

function sortBy

sortBy: {
    <A, B>(f: (x: A) => B): (xs: A[]) => A[];
    <A, B>(f: (x: A) => B, xs: A[]): A[];
};

function sortWith

sortWith: {
    <A>(f: (x: A) => (y: A) => number): (xs: A[]) => A[];
    <A>(f: (x: A) => (y: A) => number, xs: A[]): A[];
};

function span

span: {
    <A>(p: (x: A) => boolean): (xs: A[]) => [A[], A[]];
    <A>(p: (x: A) => boolean, xs: A[]): [A[], A[]];
    (f: (str: string) => boolean): (str: string) => [string, string];
    (f: (str: string) => boolean, str: string): [string, string];
};

function split

split: {
    (separator: string): (str: string) => string[];
    (separator: string, str: string): string[];
};

function splitAt

splitAt: {
    <A>(n: number): (xs: A[]) => [A[], A[]];
    <A>(n: number, xs: A[]): [A[], A[]];
    (n: number): (str: string) => [string, string];
    (n: number, str: string): [string, string];
};

function sqrt

sqrt: (x: number) => number;

function sum

sum: (xs: number[]) => number;

function tail

tail: <A>(xs: A[]) => A[];

function take

take: {
    <A>(n: number): (xs: A[]) => A[];
    <A>(n: number, xs: A[]): A[];
    (n: number): (str: string) => string;
    (n: number, str: string): string;
};

function takeWhile

takeWhile: {
    <A>(p: (x: A) => boolean): (xs: A[]) => A[];
    <A>(p: (x: A) => boolean, xs: A[]): A[];
    (f: (str: string) => boolean): (str: string) => string;
    (f: (str: string) => boolean, str: string): string;
};

function tan

tan: (x: number) => number;

function truncate

truncate: (x: number) => number;

function unchars

unchars: (xs: string[]) => string;

function unfoldr

unfoldr: {
    <A, B>(f: (x: B) => [A, B] | void): (x: B) => A[];
    <A, B>(f: (x: B) => void | [A, B], x: B): A[];
};

function union

union: <A>(...xss: A[][]) => A[];

function unique

unique: <A>(xs: A[]) => A[];

function uniqueBy

uniqueBy: {
    <A, B>(f: (x: A) => B): (xs: A[]) => A[];
    <A, B>(f: (x: A) => B, xs: A[]): A[];
};

function unlines

unlines: (xs: string[]) => string;

function unwords

unwords: (xs: string[]) => string;

function values

values: {
    <A>(object: { [key: string]: A }): A[];
    <A>(object: { [key: number]: A }): A[];
};

function words

words: (str: string) => string[];

function zip

zip: {
    <A, B>(xs: A[]): (ys: B[]) => Array<[A, B]>;
    <A, B>(xs: A[], ys: B[]): [A, B][];
};

function zipAll

zipAll: <A>(...xss: A[][]) => A[][];

function zipAllWith

zipAllWith: <A, B>(f: (...xs: A[]) => B, ...xss: A[][]) => B[];

function zipWith

zipWith: {
    <A, B, C>(f: (x: A) => (y: B) => C): (xs: A[]) => (ys: B[]) => C[];
    <A, B, C>(f: (x: A) => (y: B) => C, xs: A[]): (ys: B[]) => C[];
    <A, B, C>(f: (x: A) => (y: B) => C, xs: A[], ys: B[]): C[];
};

Namespaces

namespace Obj

namespace Obj {}

function compact

compact: {
    <A>(object: { [key: string]: A }): { [key: string]: A };
    <A>(object: { [key: number]: A }): { [key: number]: A };
};

function each

each: {
    <A>(f: (x: A) => void): (object: { [key: string]: A }) => { [key: string]: A };
    <A>(f: (x: A) => void, object: { [key: string]: A }): { [key: string]: A };
    <A>(f: (x: A) => void): (object: { [key: number]: A }) => { [key: number]: A };
    <A>(f: (x: A) => void, object: { [key: number]: A }): { [key: number]: A };
};

function empty

empty: <A>(object: any) => boolean;

function filter

filter: {
    <A>(f: (x: A) => boolean): (object: { [key: string]: A }) => {
        [key: string]: A;
    };
    <A>(f: (x: A) => boolean, object: { [key: string]: A }): { [key: string]: A };
    <A>(f: (x: A) => boolean): (object: { [key: number]: A }) => {
        [key: number]: A;
    };
    <A>(f: (x: A) => boolean, object: { [key: number]: A }): { [key: number]: A };
};

function find

find: {
    <A>(f: (x: A) => boolean): (object: { [key: string]: A }) => A;
    <A>(f: (x: A) => boolean, object: { [key: string]: A }): A;
    <A>(f: (x: A) => boolean): (object: { [key: number]: A }) => A;
    <A>(f: (x: A) => boolean, object: { [key: number]: A }): A;
};

function map

map: {
    <A, B>(f: (x: A) => B): (object: { [key: string]: A }) => { [key: string]: B };
    <A, B>(f: (x: A) => B, object: { [key: string]: A }): { [key: string]: B };
    <A, B>(f: (x: A) => B): (object: { [key: number]: A }) => { [key: number]: B };
    <A, B>(f: (x: A) => B, object: { [key: number]: A }): { [key: number]: B };
};

function partition

partition: {
    <A>(f: (x: A) => boolean): (object: {
        [key: string]: A;
    }) => [{ [key: string]: A }, { [key: string]: A }];
    <A>(f: (x: A) => boolean, object: { [key: string]: A }): [
        { [key: string]: A },
        { [key: string]: A }
    ];
    <A>(f: (x: A) => boolean): (object: {
        [key: number]: A;
    }) => [{ [key: number]: A }, { [key: number]: A }];
    <A>(f: (x: A) => boolean, object: { [key: number]: A }): [
        { [key: number]: A },
        { [key: number]: A }
    ];
};

function reject

reject: {
    <A>(f: (x: A) => boolean): (object: { [key: string]: A }) => {
        [key: string]: A;
    };
    <A>(f: (x: A) => boolean, object: { [key: string]: A }): { [key: string]: A };
    <A>(f: (x: A) => boolean): (object: { [key: number]: A }) => {
        [key: number]: A;
    };
    <A>(f: (x: A) => boolean, object: { [key: number]: A }): { [key: number]: A };
};

namespace Str

namespace Str {}

function breakStr

breakStr: {
    (f: (str: string) => boolean): (str: string) => [string, string];
    (f: (str: string) => boolean, str: string): [string, string];
};

function drop

drop: { (n: number): (str: string) => string; (n: number, str: string): string };

function dropWhile

dropWhile: {
    (f: (str: string) => boolean): (str: string) => string;
    (f: (str: string) => boolean, str: string): string;
};

function empty

empty: (str: string) => boolean;

function reverse

reverse: (str: string) => string;

function slice

slice: {
    (x: number): (y: number) => (str: string) => string;
    (x: number, y: number): (str: string) => string;
    (x: number, y: number, str: string): string;
};

function span

span: {
    (f: (str: string) => boolean): (str: string) => [string, string];
    (f: (str: string) => boolean, str: string): [string, string];
};

function splitAt

splitAt: {
    (n: number): (str: string) => [string, string];
    (n: number, str: string): [string, string];
};

function take

take: { (n: number): (str: string) => string; (n: number, str: string): string };

function takeWhile

takeWhile: {
    (f: (str: string) => boolean): (str: string) => string;
    (f: (str: string) => boolean, str: string): string;
};

Package Files (1)

index.d.ts

Dependencies (0)

No dependencies.

Dev Dependencies (0)

No dev dependencies.

Peer Dependencies (0)

No peer dependencies.

Badge

To add a badge like this oneto your package's README, use the codes available below.

You may also use Shields.io to create a custom badge linking to https://www.jsdocs.io/package/@types/prelude-ls.

Markdown

[![jsDocs.io](https://img.shields.io/badge/jsDocs.io-reference-blue)](https://www.jsdocs.io/package/@types/prelude-ls)

HTML

<a href="https://www.jsdocs.io/package/@types/prelude-ls"><img src="https://img.shields.io/badge/jsDocs.io-reference-blue" alt="jsDocs.io"></a>

Updated 11 months ago.
Package analyzed in 6770 ms.
Missing or incorrect documentation? Open an issue for this package.