@storybook/theming

@storybook/theming

Version 6.5.16
Published 3 days ago
1.52 MB
4 dependencies
MIT license

Install

npm i @storybook/theming

yarn add @storybook/theming

pnpm add @storybook/theming

Overview

Core Storybook Components

Index

Variables

variable animation

const animation: {
    readonly rotate360: Keyframes;
    readonly glow: Keyframes;
    readonly float: Keyframes;
    readonly jiggle: Keyframes;
    readonly inlineGlow: SerializedStyles;
    readonly hoverable: SerializedStyles;
};

variable background

const background: {
    app: string;
    bar: string;
    content: string;
    gridCellSize: number;
    hoverable: string;
    positive: string;
    negative: string;
    warning: string;
    critical: string;
};

variable CacheProvider

const CacheProvider: Provider<EmotionCache>;

variable color

const color: {
    primary: string;
    secondary: string;
    tertiary: string;
    ancillary: string;
    orange: string;
    gold: string;
    green: string;
    seafoam: string;
    purple: string;
    ultraviolet: string;
    lightest: string;
    lighter: string;
    light: string;
    mediumlight: string;
    medium: string;
    mediumdark: string;
    dark: string;
    darker: string;
    darkest: string;
    border: string;
    positive: string;
    negative: string;
    warning: string;
    critical: string;
    defaultText: string;
    inverseText: string;
};

variable easing

const easing: { rubber: string };

variable ignoreSsrWarning

const ignoreSsrWarning: string;

variable jsx

const jsx: any;

variable styled

const styled: CreateStyled<Theme>;

variable ThemeProvider

const ThemeProvider: ThemeProvider;

variable themes

const themes: { light: ThemeVars; dark: ThemeVars; normal: ThemeVars };

variable typography

const typography: {
    fonts: { base: string; mono: string };
    weight: { regular: number; bold: number; black: number };
    size: {
        s1: number;
        s2: number;
        s3: number;
        m1: number;
        m2: number;
        m3: number;
        l1: number;
        l2: number;
        l3: number;
        code: number;
    };
};

Functions

function ClassNames

ClassNames: (props: ClassNamesProps) => ReactElement;

JSX generic are supported only after TS@2.9

function convert

convert: (inherit?: ThemeVars) => Theme;

function create

create: (vars?: ThemeVars, rest?: Rest) => ThemeVars;

function createCache

createCache: (options: Options) => EmotionCache;

function createGlobal

createGlobal: ({
    color,
    background,
    typography,
}: {
    color: Color;
    background: Background;
    typography: Typography;
}) => Return;

function createReset

createReset: ({ typography }: { typography: Typography }) => Return;

function css

css: {
    (
        template: TemplateStringsArray,
        ...args: Array<CSSInterpolation>
    ): SerializedStyles;
    (...args: CSSInterpolation[]): SerializedStyles;
};

function darken

darken: (color: string) => string;

function ensure

ensure: (input: ThemeVars) => Theme;

function Global

Global: (props: {
    styles: emotionReact.Interpolation<Theme>;
}) => React.ReactElement;

function isPropValid

isPropValid: (string: PropertyKey) => boolean;

function keyframes

keyframes: {
    (template: TemplateStringsArray, ...args: Array<CSSInterpolation>): Keyframes;
    (...args: CSSInterpolation[]): Keyframes;
};

function lighten

lighten: (color: string) => string;

function useTheme

useTheme: <TTheme = Theme>() => TTheme;

function withTheme

withTheme: <C extends any>(component: C) => any;

Interfaces

interface BaseCreateStyled

interface BaseCreateStyled<Theme extends object = any> {}

call signature

<Tag extends React.ComponentType<any>, ExtraProps = {}>(
    tag: Tag,
    options?: StyledOptions
): CreateStyledComponentExtrinsic<Tag, ExtraProps, Theme>;

call signature

<Tag extends keyof JSXInEl, ExtraProps = {}>(
    tag: Tag,
    options?: StyledOptions
): CreateStyledComponentIntrinsic<Tag, ExtraProps, Theme>;

interface Brand

interface Brand {}

property image

image: string | null | undefined;

property target

target: string | null | undefined;

property title

title: string | undefined;

property url

url: string | null | undefined;

interface ComponentSelector

interface ComponentSelector {}

interface CreateStyled

interface CreateStyled<Theme extends object = any>
    extends BaseCreateStyled<Theme>,
        StyledTags<Theme> {}

interface CreateStyledComponentBaseThemed

interface CreateStyledComponentBaseThemed<
    InnerProps,
    ExtraProps,
    StyledInstanceTheme extends object
> {}

call signature

<
    StyleProps extends DistributiveOmit<
        Overwrapped<InnerProps, StyleProps>,
        ReactClassPropKeys
    > = DistributiveOmit<InnerProps & ExtraProps, ReactClassPropKeys>
>(
    ...styles: Array<Interpolation<WithTheme<StyleProps, StyledInstanceTheme>>>
): StyledComponent<InnerProps, StyleProps, StyledInstanceTheme>;

call signature

<
    StyleProps extends DistributiveOmit<
        Overwrapped<InnerProps, StyleProps>,
        ReactClassPropKeys
    > = DistributiveOmit<InnerProps & ExtraProps, ReactClassPropKeys>
>(
    template: TemplateStringsArray,
    ...styles: Array<Interpolation<WithTheme<StyleProps, StyledInstanceTheme>>>
): StyledComponent<InnerProps, StyleProps, StyledInstanceTheme>;

interface CreateStyledComponentBaseThemeless

interface CreateStyledComponentBaseThemeless<InnerProps, ExtraProps> {}

call signature

<
    StyleProps extends DistributiveOmit<
        Overwrapped<InnerProps, StyleProps>,
        ReactClassPropKeys
    > = DistributiveOmit<InnerProps & ExtraProps, ReactClassPropKeys>,
    Theme extends object = object
>(
    ...styles: Array<Interpolation<WithTheme<StyleProps, Theme>>>
): StyledComponent<InnerProps, StyleProps, Theme>;

call signature

<
    StyleProps extends DistributiveOmit<
        Overwrapped<InnerProps, StyleProps>,
        ReactClassPropKeys
    > = DistributiveOmit<InnerProps & ExtraProps, ReactClassPropKeys>,
    Theme extends object = object
>(
    template: TemplateStringsArray,
    ...styles: Array<Interpolation<WithTheme<StyleProps, Theme>>>
): StyledComponent<InnerProps, StyleProps, Theme>;

interface CSSObject

interface CSSObject
    extends CSSPropertiesWithMultiValues,
        CSSPseudos,
        CSSOthersObject {}

interface Rest

interface Rest {}

index signature

[key: string]: any;

interface Return

interface Return {}

index signature

[key: string]: {
    [key: string]: Value;
};

interface StyledComponent

interface StyledComponent<InnerProps, StyleProps, Theme extends object>
    extends React.FC<
            InnerProps &
                DistributiveOmit<StyleProps, 'theme'> & {
                    theme?: Theme;
                }
        >,
        ComponentSelector {}

method withComponent

withComponent: {
    <NewTag extends string | number | symbol>(tag: NewTag): StyledComponent<
        JSXInEl[NewTag],
        StyleProps,
        Theme
    >;
    <Tag extends React.ComponentType<any>>(tag: Tag): StyledComponent<
        JSX.LibraryManagedAttributes<C, React.ComponentPropsWithRef<C>>,
        StyleProps,
        Theme
    >;
};

this method is type-unsafe

interface StyledOptions

interface StyledOptions {}

property label

label?: string;

property target

target?: string;

method shouldForwardProp

shouldForwardProp: (propName: string) => boolean;

interface StyledTags

interface StyledTags<Theme extends object> {}

property a

a: CreateStyledComponentIntrinsic<'a', {}, Theme>;

HTML tags

property abbr

abbr: CreateStyledComponentIntrinsic<'abbr', {}, Theme>;

property address

address: CreateStyledComponentIntrinsic<'address', {}, Theme>;

property area

area: CreateStyledComponentIntrinsic<'area', {}, Theme>;

property article

article: CreateStyledComponentIntrinsic<'article', {}, Theme>;

property aside

aside: CreateStyledComponentIntrinsic<'aside', {}, Theme>;

property audio

audio: CreateStyledComponentIntrinsic<'audio', {}, Theme>;

property b

b: CreateStyledComponentIntrinsic<'b', {}, Theme>;

property base

base: CreateStyledComponentIntrinsic<'base', {}, Theme>;

property bdi

bdi: CreateStyledComponentIntrinsic<'bdi', {}, Theme>;

property bdo

bdo: CreateStyledComponentIntrinsic<'bdo', {}, Theme>;

property big

big: CreateStyledComponentIntrinsic<'big', {}, Theme>;

property blockquote

blockquote: CreateStyledComponentIntrinsic<'blockquote', {}, Theme>;

property body

body: CreateStyledComponentIntrinsic<'body', {}, Theme>;

property br

br: CreateStyledComponentIntrinsic<'br', {}, Theme>;

property button

button: CreateStyledComponentIntrinsic<'button', {}, Theme>;

property canvas

canvas: CreateStyledComponentIntrinsic<'canvas', {}, Theme>;

property caption

caption: CreateStyledComponentIntrinsic<'caption', {}, Theme>;

property circle

circle: CreateStyledComponentIntrinsic<'circle', {}, Theme>;

SVG tags

property cite

cite: CreateStyledComponentIntrinsic<'cite', {}, Theme>;

property clipPath

clipPath: CreateStyledComponentIntrinsic<'clipPath', {}, Theme>;

property code

code: CreateStyledComponentIntrinsic<'code', {}, Theme>;

property col

col: CreateStyledComponentIntrinsic<'col', {}, Theme>;

property colgroup

colgroup: CreateStyledComponentIntrinsic<'colgroup', {}, Theme>;

property data

data: CreateStyledComponentIntrinsic<'data', {}, Theme>;

property datalist

datalist: CreateStyledComponentIntrinsic<'datalist', {}, Theme>;

property dd

dd: CreateStyledComponentIntrinsic<'dd', {}, Theme>;

property defs

defs: CreateStyledComponentIntrinsic<'defs', {}, Theme>;

property del

del: CreateStyledComponentIntrinsic<'del', {}, Theme>;

property details

details: CreateStyledComponentIntrinsic<'details', {}, Theme>;

property dfn

dfn: CreateStyledComponentIntrinsic<'dfn', {}, Theme>;

property dialog

dialog: CreateStyledComponentIntrinsic<'dialog', {}, Theme>;

property div

div: CreateStyledComponentIntrinsic<'div', {}, Theme>;

property dl

dl: CreateStyledComponentIntrinsic<'dl', {}, Theme>;

property dt

dt: CreateStyledComponentIntrinsic<'dt', {}, Theme>;

property ellipse

ellipse: CreateStyledComponentIntrinsic<'ellipse', {}, Theme>;

property em

em: CreateStyledComponentIntrinsic<'em', {}, Theme>;

property embed

embed: CreateStyledComponentIntrinsic<'embed', {}, Theme>;

property fieldset

fieldset: CreateStyledComponentIntrinsic<'fieldset', {}, Theme>;

property figcaption

figcaption: CreateStyledComponentIntrinsic<'figcaption', {}, Theme>;

property figure

figure: CreateStyledComponentIntrinsic<'figure', {}, Theme>;

footer: CreateStyledComponentIntrinsic<'footer', {}, Theme>;

property foreignObject

foreignObject: CreateStyledComponentIntrinsic<'foreignObject', {}, Theme>;

property form

form: CreateStyledComponentIntrinsic<'form', {}, Theme>;

property g

g: CreateStyledComponentIntrinsic<'g', {}, Theme>;

property h1

h1: CreateStyledComponentIntrinsic<'h1', {}, Theme>;

property h2

h2: CreateStyledComponentIntrinsic<'h2', {}, Theme>;

property h3

h3: CreateStyledComponentIntrinsic<'h3', {}, Theme>;

property h4

h4: CreateStyledComponentIntrinsic<'h4', {}, Theme>;

property h5

h5: CreateStyledComponentIntrinsic<'h5', {}, Theme>;

property h6

h6: CreateStyledComponentIntrinsic<'h6', {}, Theme>;

property head

head: CreateStyledComponentIntrinsic<'head', {}, Theme>;

header: CreateStyledComponentIntrinsic<'header', {}, Theme>;

property hgroup

hgroup: CreateStyledComponentIntrinsic<'hgroup', {}, Theme>;

property hr

hr: CreateStyledComponentIntrinsic<'hr', {}, Theme>;

property html

html: CreateStyledComponentIntrinsic<'html', {}, Theme>;

property i

i: CreateStyledComponentIntrinsic<'i', {}, Theme>;

property iframe

iframe: CreateStyledComponentIntrinsic<'iframe', {}, Theme>;

property image

image: CreateStyledComponentIntrinsic<'image', {}, Theme>;

property img

img: CreateStyledComponentIntrinsic<'img', {}, Theme>;

property input

input: CreateStyledComponentIntrinsic<'input', {}, Theme>;

property ins

ins: CreateStyledComponentIntrinsic<'ins', {}, Theme>;

property kbd

kbd: CreateStyledComponentIntrinsic<'kbd', {}, Theme>;

property keygen

keygen: CreateStyledComponentIntrinsic<'keygen', {}, Theme>;

property label

label: CreateStyledComponentIntrinsic<'label', {}, Theme>;

property legend

legend: CreateStyledComponentIntrinsic<'legend', {}, Theme>;

property li

li: CreateStyledComponentIntrinsic<'li', {}, Theme>;

property line

line: CreateStyledComponentIntrinsic<'line', {}, Theme>;

property linearGradient

linearGradient: CreateStyledComponentIntrinsic<'linearGradient', {}, Theme>;

property link

link: CreateStyledComponentIntrinsic<'link', {}, Theme>;

property main

main: CreateStyledComponentIntrinsic<'main', {}, Theme>;

property map

map: CreateStyledComponentIntrinsic<'map', {}, Theme>;

property mark

mark: CreateStyledComponentIntrinsic<'mark', {}, Theme>;

property mask

mask: CreateStyledComponentIntrinsic<'mask', {}, Theme>;

menu: CreateStyledComponentIntrinsic<'menu', {}, Theme>;

marquee tag is not supported by @types/react

property menuitem

menuitem: CreateStyledComponentIntrinsic<'menuitem', {}, Theme>;

property meta

meta: CreateStyledComponentIntrinsic<'meta', {}, Theme>;

property meter

meter: CreateStyledComponentIntrinsic<'meter', {}, Theme>;

property nav

nav: CreateStyledComponentIntrinsic<'nav', {}, Theme>;

property noscript

noscript: CreateStyledComponentIntrinsic<'noscript', {}, Theme>;

property object

object: CreateStyledComponentIntrinsic<'object', {}, Theme>;

property ol

ol: CreateStyledComponentIntrinsic<'ol', {}, Theme>;

property optgroup

optgroup: CreateStyledComponentIntrinsic<'optgroup', {}, Theme>;

property option

option: CreateStyledComponentIntrinsic<'option', {}, Theme>;

property output

output: CreateStyledComponentIntrinsic<'output', {}, Theme>;

property p

p: CreateStyledComponentIntrinsic<'p', {}, Theme>;

property param

param: CreateStyledComponentIntrinsic<'param', {}, Theme>;

property path

path: CreateStyledComponentIntrinsic<'path', {}, Theme>;

property pattern

pattern: CreateStyledComponentIntrinsic<'pattern', {}, Theme>;

property picture

picture: CreateStyledComponentIntrinsic<'picture', {}, Theme>;

property polygon

polygon: CreateStyledComponentIntrinsic<'polygon', {}, Theme>;

property polyline

polyline: CreateStyledComponentIntrinsic<'polyline', {}, Theme>;

property pre

pre: CreateStyledComponentIntrinsic<'pre', {}, Theme>;

property progress

progress: CreateStyledComponentIntrinsic<'progress', {}, Theme>;

property q

q: CreateStyledComponentIntrinsic<'q', {}, Theme>;

property radialGradient

radialGradient: CreateStyledComponentIntrinsic<'radialGradient', {}, Theme>;

property rect

rect: CreateStyledComponentIntrinsic<'rect', {}, Theme>;

property rp

rp: CreateStyledComponentIntrinsic<'rp', {}, Theme>;

property rt

rt: CreateStyledComponentIntrinsic<'rt', {}, Theme>;

property ruby

ruby: CreateStyledComponentIntrinsic<'ruby', {}, Theme>;

property s

s: CreateStyledComponentIntrinsic<'s', {}, Theme>;

property samp

samp: CreateStyledComponentIntrinsic<'samp', {}, Theme>;

property script

script: CreateStyledComponentIntrinsic<'script', {}, Theme>;

property section

section: CreateStyledComponentIntrinsic<'section', {}, Theme>;

property select

select: CreateStyledComponentIntrinsic<'select', {}, Theme>;

property small

small: CreateStyledComponentIntrinsic<'small', {}, Theme>;

property source

source: CreateStyledComponentIntrinsic<'source', {}, Theme>;

property span

span: CreateStyledComponentIntrinsic<'span', {}, Theme>;

property stop

stop: CreateStyledComponentIntrinsic<'stop', {}, Theme>;

property strong

strong: CreateStyledComponentIntrinsic<'strong', {}, Theme>;

property style

style: CreateStyledComponentIntrinsic<'style', {}, Theme>;

property sub

sub: CreateStyledComponentIntrinsic<'sub', {}, Theme>;

property summary

summary: CreateStyledComponentIntrinsic<'summary', {}, Theme>;

property sup

sup: CreateStyledComponentIntrinsic<'sup', {}, Theme>;

property svg

svg: CreateStyledComponentIntrinsic<'svg', {}, Theme>;

property table

table: CreateStyledComponentIntrinsic<'table', {}, Theme>;

property tbody

tbody: CreateStyledComponentIntrinsic<'tbody', {}, Theme>;

property td

td: CreateStyledComponentIntrinsic<'td', {}, Theme>;

property text

text: CreateStyledComponentIntrinsic<'text', {}, Theme>;

property textarea

textarea: CreateStyledComponentIntrinsic<'textarea', {}, Theme>;

property tfoot

tfoot: CreateStyledComponentIntrinsic<'tfoot', {}, Theme>;

property th

th: CreateStyledComponentIntrinsic<'th', {}, Theme>;

property thead

thead: CreateStyledComponentIntrinsic<'thead', {}, Theme>;

property time

time: CreateStyledComponentIntrinsic<'time', {}, Theme>;

property title

title: CreateStyledComponentIntrinsic<'title', {}, Theme>;

property tr

tr: CreateStyledComponentIntrinsic<'tr', {}, Theme>;

property track

track: CreateStyledComponentIntrinsic<'track', {}, Theme>;

property tspan

tspan: CreateStyledComponentIntrinsic<'tspan', {}, Theme>;

property u

u: CreateStyledComponentIntrinsic<'u', {}, Theme>;

property ul

ul: CreateStyledComponentIntrinsic<'ul', {}, Theme>;

property var

var: CreateStyledComponentIntrinsic<'var', {}, Theme>;

property video

video: CreateStyledComponentIntrinsic<'video', {}, Theme>;

property wbr

wbr: CreateStyledComponentIntrinsic<'wbr', {}, Theme>;

interface Theme

interface Theme {}

property animation

animation: Animation;

property appBorderColor

appBorderColor: string;

property appBorderRadius

appBorderRadius: number;

property background

background: Background;

property barBg

barBg: string;

property barSelectedColor

barSelectedColor: string;

property barTextColor

barTextColor: string;

property brand

brand: Brand;

property code

code: {
    [key: string]: string | object;
};

property color

color: Color;

property easing

easing: Easing;

property input

input: {
    border: string;
    background: string;
    color: string;
    borderRadius: number;
};

property layoutMargin

layoutMargin: number;

property typography

typography: Typography;

index signature

[key: string]: any;

interface ThemeProvider

interface ThemeProvider {}

call signature

(props: ThemeProviderProps): React.ReactElement;

interface ThemeVars

interface ThemeVars {}

property appBg

appBg?: string;

property appBorderColor

appBorderColor?: string;

property appBorderRadius

appBorderRadius?: number;

property appContentBg

appContentBg?: string;

property barBg

barBg?: string;

property barSelectedColor

barSelectedColor?: string;

property barTextColor

barTextColor?: string;

property base

base: 'light' | 'dark';

property brandImage

brandImage?: string;

property brandTarget

brandTarget?: string;

property brandTitle

brandTitle?: string;

property brandUrl

brandUrl?: string;

property colorPrimary

colorPrimary?: string;

property colorSecondary

colorSecondary?: string;

property fontBase

fontBase?: string;

property fontCode

fontCode?: string;

property gridCellSize

gridCellSize?: number;

property inputBg

inputBg?: string;

property inputBorder

inputBorder?: string;

property inputBorderRadius

inputBorderRadius?: number;

property inputTextColor

inputTextColor?: string;

property textColor

textColor?: string;

property textInverseColor

textInverseColor?: string;

property textMutedColor

textMutedColor?: string;

Type Aliases

type AddOptionalTo

type AddOptionalTo<T, U> = DistributiveOmit<T, U> &
    Partial<Pick<T, Extract<keyof T, U>>>;

type Animation

type Animation = typeof animation;

type Background

type Background = typeof background;

type Color

type Color = typeof color;

type CreateStyledComponentBase

type CreateStyledComponentBase<
    InnerProps,
    ExtraProps,
    StyledInstanceTheme extends object
> = object extends StyledInstanceTheme
    ? CreateStyledComponentBaseThemeless<InnerProps, ExtraProps>
    : CreateStyledComponentBaseThemed<InnerProps, ExtraProps, StyledInstanceTheme>;

type CreateStyledComponentExtrinsic

type CreateStyledComponentExtrinsic<
    Tag extends React.ComponentType<any>,
    ExtraProps,
    Theme extends object
> = CreateStyledComponentBase<PropsOf<Tag>, ExtraProps, Theme>;

type CreateStyledComponentIntrinsic

type CreateStyledComponentIntrinsic<
    Tag extends keyof JSXInEl,
    ExtraProps,
    Theme extends object
> = CreateStyledComponentBase<JSXInEl[Tag], ExtraProps, Theme>;

type DistributiveOmit

type DistributiveOmit<T, U> = T extends any ? Pick<T, Exclude<keyof T, U>> : never;

type Easing

type Easing = typeof easing;

type JSXInEl

type JSXInEl = JSX.IntrinsicElements;

type Keyframes

type Keyframes = {
    name: string;
    styles: string;
    anim: number;
    toString: () => string;
} & string;

type Overwrapped

type Overwrapped<T, U> = Pick<T, Extract<keyof T, keyof U>>;

type PropsOf

type PropsOf<
    C extends keyof JSX.IntrinsicElements | React.JSXElementConstructor<any>
> = JSX.LibraryManagedAttributes<C, React.ComponentPropsWithRef<C>>;

type ReactClassPropKeys

type ReactClassPropKeys = keyof React.ClassAttributes<any>;

type TextSize

type TextSize = number | string;

type Typography

type Typography = typeof typography;

type Value

type Value = string | number;

type WithTheme

type WithTheme<P, T> = P extends {
    theme: infer Theme;
}
    ? P & {
          theme: Exclude<Theme, undefined>;
      }
    : P & {
          theme: T;
      };

Namespaces

namespace jsx

namespace jsx {}

namespace jsx.JSX

namespace jsx.JSX {}

interface Element

interface Element extends EmotionJSX.Element {}

interface ElementAttributesProperty

interface ElementAttributesProperty extends EmotionJSX.ElementAttributesProperty {}

interface ElementChildrenAttribute

interface ElementChildrenAttribute extends EmotionJSX.ElementChildrenAttribute {}

interface ElementClass

interface ElementClass extends EmotionJSX.ElementClass {}

interface IntrinsicAttributes

interface IntrinsicAttributes extends EmotionJSX.IntrinsicAttributes {}

interface IntrinsicClassAttributes

interface IntrinsicClassAttributes<T>
    extends EmotionJSX.IntrinsicClassAttributes<T> {}

type IntrinsicElements

type IntrinsicElements = EmotionJSX.IntrinsicElements;

type LibraryManagedAttributes

type LibraryManagedAttributes<C, P> = EmotionJSX.LibraryManagedAttributes<C, P>;

Package Files (6)

Dev Dependencies (10)

@emotion/cache
@emotion/is-prop-valid
@emotion/react
@emotion/styled
@types/node
deep-object-diff
global
polished
ts-dedent
ts-node

Peer Dependencies (2)

react
react-dom

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/@storybook/theming.

Markdown

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

HTML

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

Updated just now.
Package analyzed in 5381 ms.
Missing or incorrect documentation? Open an issue for this package.