@types/cssom

  • Version 0.4.3
  • Published
  • 6.08 kB
  • No dependencies
  • MIT license

Install

npm i @types/cssom
yarn add @types/cssom
pnpm add @types/cssom

Overview

TypeScript definitions for cssom

Index

Functions

function clone

clone: (stylesheet: CSSStyleSheet) => CSSStyleSheet;
  • Produces a deep copy of stylesheet — the instance variables of stylesheet are copied recursively.

function parse

parse: (token: string) => CSSStyleSheet;

    Classes

    class CSSDocumentRule

    class CSSDocumentRule extends CSSRule {}
    • Deprecated

      Removed from spec

    property cssRules

    cssRules: CSSRule[];

      property matcher

      matcher: MatcherList;

        property type

        readonly type: number;

          class CSSFontFaceRule

          class CSSFontFaceRule extends CSSRule {}

            property style

            style: CSSStyleDeclaration;

              property type

              readonly type: number;

                class CSSHostRule

                class CSSHostRule extends CSSRule {}
                • See Also

                  • https://www.w3.org/TR/2013/WD-shadow-dom-20130514/#host-at-rule

                  Deprecated

                  Legacy Shadow DOM v0

                property cssRules

                cssRules: CSSRule[];

                  property type

                  readonly type: number;

                    class CSSImportRule

                    class CSSImportRule extends CSSRule {}

                      property cssText

                      cssText: string;

                        property href

                        href: string;

                          property media

                          media: MediaList;

                            property styleSheet

                            styleSheet: CSSStyleSheet;

                              property type

                              readonly type: number;

                                class CSSKeyframeRule

                                class CSSKeyframeRule extends CSSRule {}

                                  property keyText

                                  keyText: string;

                                    property style

                                    style: CSSStyleDeclaration;

                                      property type

                                      readonly type: number;

                                        class CSSKeyframesRule

                                        class CSSKeyframesRule extends CSSRule {}

                                          property cssRules

                                          cssRules: CSSRule[];

                                            property name

                                            name: string;

                                              property type

                                              readonly type: number;

                                                class CSSMediaRule

                                                class CSSMediaRule extends CSSRule {}

                                                  property cssRules

                                                  cssRules: CSSRule[];

                                                    property media

                                                    media: MediaList;

                                                      property type

                                                      readonly type: number;

                                                        class CSSRule

                                                        abstract class CSSRule {}

                                                          property cssText

                                                          readonly cssText: string;

                                                            property parentRule

                                                            parentRule: CSSRule;

                                                              property parentStyleSheet

                                                              parentStyleSheet: StyleSheet;

                                                                property type

                                                                readonly type: number;

                                                                  class CSSStyleDeclaration

                                                                  class CSSStyleDeclaration {}

                                                                    property cssText

                                                                    cssText: string;

                                                                      property length

                                                                      length: number;

                                                                        property parentRule

                                                                        parentRule: CSSRule;

                                                                          method getPropertyPriority

                                                                          getPropertyPriority: (name: string) => string;

                                                                            method getPropertyValue

                                                                            getPropertyValue: (name: string) => string;

                                                                              method removeProperty

                                                                              removeProperty: (name: string) => string;

                                                                                method setProperty

                                                                                setProperty: (
                                                                                name: string,
                                                                                value: string | null,
                                                                                priority?: string | null
                                                                                ) => void;

                                                                                  class CSSStyleRule

                                                                                  class CSSStyleRule extends CSSRule {}

                                                                                    property cssText

                                                                                    cssText: string;

                                                                                      property selectorText

                                                                                      selectorText: string;

                                                                                        property style

                                                                                        style: CSSStyleDeclaration;

                                                                                          property type

                                                                                          readonly type: number;

                                                                                            method parse

                                                                                            static parse: (ruleText: any) => any;

                                                                                              class CSSStyleSheet

                                                                                              class CSSStyleSheet extends StyleSheet {}

                                                                                                property cssRules

                                                                                                cssRules: CSSRule[];

                                                                                                  method deleteRule

                                                                                                  deleteRule: (index: number) => void;

                                                                                                    method insertRule

                                                                                                    insertRule: (rule: string, index?: number) => number;

                                                                                                      class CSSSupportsRule

                                                                                                      class CSSSupportsRule extends CSSRule {}

                                                                                                        property conditionText

                                                                                                        conditionText: string;

                                                                                                          property cssRules

                                                                                                          cssRules: CSSRule[];

                                                                                                            property type

                                                                                                            readonly type: number;

                                                                                                              class CSSValue

                                                                                                              class CSSValue {}
                                                                                                              • Deprecated

                                                                                                              property cssText

                                                                                                              cssText: string;
                                                                                                              • The getter and setter are currently unimplemented and throw unconditionally.

                                                                                                              class CSSValueExpression

                                                                                                              class CSSValueExpression extends CSSValue {}
                                                                                                              • Deprecated

                                                                                                              constructor

                                                                                                              constructor(token: string, idx: number);

                                                                                                                method parse

                                                                                                                parse: () => { error: any } | { idx: number; expression: string };

                                                                                                                  class MatcherList

                                                                                                                  class MatcherList {}
                                                                                                                  • Deprecated

                                                                                                                    Removed from spec

                                                                                                                  property length

                                                                                                                  length: number;

                                                                                                                    property matcherText

                                                                                                                    matcherText: string;

                                                                                                                      method appendMatcher

                                                                                                                      appendMatcher: (matcher: string) => void;

                                                                                                                        method deleteMatcher

                                                                                                                        deleteMatcher: (matcher: string) => void;

                                                                                                                          class MediaList

                                                                                                                          class MediaList {}

                                                                                                                            property length

                                                                                                                            length: number;

                                                                                                                              property mediaText

                                                                                                                              mediaText: string;

                                                                                                                                method appendMedium

                                                                                                                                appendMedium: (medium: string) => void;

                                                                                                                                  method deleteMedium

                                                                                                                                  deleteMedium: (medium: string) => void;

                                                                                                                                    class StyleSheet

                                                                                                                                    abstract class StyleSheet {}

                                                                                                                                      property parentStyleSheet

                                                                                                                                      parentStyleSheet: StyleSheet;

                                                                                                                                        Namespaces

                                                                                                                                        namespace CSSRule

                                                                                                                                        namespace CSSRule {}

                                                                                                                                          variable CHARSET_RULE

                                                                                                                                          const CHARSET_RULE: number;
                                                                                                                                          • Deprecated

                                                                                                                                            Obsolete

                                                                                                                                          variable COUNTER_STYLE_RULE

                                                                                                                                          const COUNTER_STYLE_RULE: number;

                                                                                                                                            variable DOCUMENT_RULE

                                                                                                                                            const DOCUMENT_RULE: number;

                                                                                                                                              variable FONT_FACE_RULE

                                                                                                                                              const FONT_FACE_RULE: number;

                                                                                                                                                variable FONT_FEATURE_VALUES_RULE

                                                                                                                                                const FONT_FEATURE_VALUES_RULE: number;

                                                                                                                                                  variable IMPORT_RULE

                                                                                                                                                  const IMPORT_RULE: number;

                                                                                                                                                    variable KEYFRAME_RULE

                                                                                                                                                    const KEYFRAME_RULE: number;

                                                                                                                                                      variable KEYFRAMES_RULE

                                                                                                                                                      const KEYFRAMES_RULE: number;

                                                                                                                                                        variable MARGIN_RULE

                                                                                                                                                        const MARGIN_RULE: number;

                                                                                                                                                          variable MEDIA_RULE

                                                                                                                                                          const MEDIA_RULE: number;

                                                                                                                                                            variable NAMESPACE_RULE

                                                                                                                                                            const NAMESPACE_RULE: number;

                                                                                                                                                              variable PAGE_RULE

                                                                                                                                                              const PAGE_RULE: number;

                                                                                                                                                                variable REGION_STYLE_RULE

                                                                                                                                                                const REGION_STYLE_RULE: number;

                                                                                                                                                                  variable STYLE_RULE

                                                                                                                                                                  const STYLE_RULE: number;

                                                                                                                                                                    variable SUPPORTS_RULE

                                                                                                                                                                    const SUPPORTS_RULE: number;

                                                                                                                                                                      variable UNKNOWN_RULE

                                                                                                                                                                      const UNKNOWN_RULE: number;
                                                                                                                                                                      • Deprecated

                                                                                                                                                                        Obsolete

                                                                                                                                                                      variable VIEWPORT_RULE

                                                                                                                                                                      const VIEWPORT_RULE: number;

                                                                                                                                                                        Package Files (1)

                                                                                                                                                                        Dependencies (0)

                                                                                                                                                                        No dependencies.

                                                                                                                                                                        Dev Dependencies (0)

                                                                                                                                                                        No dev dependencies.

                                                                                                                                                                        Peer Dependencies (0)

                                                                                                                                                                        No peer dependencies.

                                                                                                                                                                        Badge

                                                                                                                                                                        To add a badge like this onejsDocs.io badgeto 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/cssom.

                                                                                                                                                                        • Markdown
                                                                                                                                                                          [![jsDocs.io](https://img.shields.io/badge/jsDocs.io-reference-blue)](https://www.jsdocs.io/package/@types/cssom)
                                                                                                                                                                        • HTML
                                                                                                                                                                          <a href="https://www.jsdocs.io/package/@types/cssom"><img src="https://img.shields.io/badge/jsDocs.io-reference-blue" alt="jsDocs.io"></a>