@types/svgo

  • Version 2.3.0
  • Published
  • 22.9 kB
  • No dependencies
  • MIT license

Install

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

Overview

TypeScript definitions for svgo

Index

Functions

Interfaces

Type Aliases

Functions

function extendDefaultPlugins

extendDefaultPlugins: (plugins: Plugin[]) => Plugin[];
  • If plugins field is specified default list is fully overrided. To extend default list use extendDefaultPlugins utility.

    To disable one of default plugins use active field.

function loadConfig

loadConfig: (configFile: string, cwd?: string) => Promise<OptimizeOptions>;
  • If you write a tool on top of svgo you might need a way to load svgo config.

    You can also specify relative or absolute path and customize current working directory.

function optimize

optimize: (svgString: string, options?: OptimizeOptions) => OptimizedSvg;

    Interfaces

    interface CustomPlugin

    interface CustomPlugin<P extends object = never> {}

      property fn

      fn: (ast: any, params: P, info: any) => any;

        property name

        name: string;

          property params

          params?: P;

            property type

            type: 'perItem' | 'perItemReverse' | 'full';

              interface DefaultPlugin

              interface DefaultPlugin<N extends string, P = never> {}

                property active

                active?: boolean;

                  property name

                  name: N;

                    property params

                    params?: P;

                      interface Js2SvgOptions

                      interface Js2SvgOptions {}

                        property attrEnd

                        attrEnd?: string;
                        • '"'

                        property attrStart

                        attrStart?: string;
                        • '="'

                        property cdataEnd

                        cdataEnd?: string;
                        • ']]>'

                        property cdataStart

                        cdataStart?: string;
                        • '<![CDATA['

                        property commentEnd

                        commentEnd?: string;
                        • '-->'

                        property commentStart

                        commentStart?: string;
                        • '<!--'

                        property doctypeEnd

                        doctypeEnd?: string;
                        • '>'

                        property doctypeStart

                        doctypeStart?: string;
                        • '<!DOCTYPE'

                        property encodeEntity

                        encodeEntity?: (char?: string) => string;
                        • encodeEntity

                        property indent

                        indent?: number;
                        • 4

                        property pretty

                        pretty?: boolean;
                        • false

                        property procInstEnd

                        procInstEnd?: string;
                        • '?>'

                        property procInstStart

                        procInstStart?: string;
                        • '<?'

                        property regEntities

                        regEntities?: RegExp;
                        • /[&'"<>]/g

                        property regValEntities

                        regValEntities?: RegExp;
                        • /[&"<>]/g

                        property tagCloseEnd

                        tagCloseEnd?: string;
                        • '>'

                        property tagCloseStart

                        tagCloseStart?: string;
                        • '</'

                        property tagOpenEnd

                        tagOpenEnd?: string;
                        • '>'

                        property tagOpenStart

                        tagOpenStart?: string;
                        • '<'

                        property tagShortEnd

                        tagShortEnd?: string;
                        • '/>'

                        property tagShortStart

                        tagShortStart?: string;
                        • '<'

                        property textEnd

                        textEnd?: string;
                        • ''

                        property textStart

                        textStart?: string;
                        • ''

                        property useShortTags

                        useShortTags?: boolean;
                        • true

                        interface OptimizedSvg

                        interface OptimizedSvg {}

                          property data

                          data: string;

                            property info

                            info: {
                            width: string;
                            height: string;
                            };

                              property path

                              path?: string;

                                interface OptimizeOptions

                                interface OptimizeOptions {}

                                  property datauri

                                  datauri?: 'base64' | 'enc' | 'unenc';
                                  • Output as Data URI string.

                                  property floatPrecision

                                  floatPrecision?: number;
                                  • Precision of floating point numbers. Will be passed to each plugin that suppors this param.

                                  property full

                                  full?: boolean;
                                  • Use full set of plugins.

                                  property js2svg

                                  js2svg?: Js2SvgOptions;
                                  • Options for rendering optimized SVG from AST.

                                  property multipass

                                  multipass?: boolean;
                                  • Pass over SVGs multiple times to ensure all optimizations are applied

                                  property path

                                  path?: string;

                                    property plugins

                                    plugins?: Plugin[];
                                    • Individual plugin configurations. For specific options, see plugin source in https://github.com/svg/svgo/tree/master/plugins.

                                    property svg2js

                                    svg2js?: Svg2JsOptions;
                                    • Options for parsing original SVG into AST.

                                    interface Svg2JsOptions

                                    interface Svg2JsOptions {}

                                      property lowercase

                                      lowercase?: boolean;
                                      • true

                                      property normalize

                                      normalize?: boolean;
                                      • true

                                      property position

                                      position?: boolean;
                                      • true

                                      property strict

                                      strict?: boolean;
                                      • true

                                      property trim

                                      trim?: boolean;
                                      • false

                                      property xmlns

                                      xmlns?: boolean;
                                      • true

                                      Type Aliases

                                      type AddAttributesToSVGElementPlugin

                                      type AddAttributesToSVGElementPlugin = DefaultPlugin<'addAttributesToSVGElement'>;
                                      • adds attributes to an outer element

                                      type AddClassesToSVGElementPlugin

                                      type AddClassesToSVGElementPlugin = DefaultPlugin<'addClassesToSVGElement'>;
                                      • adds classnames to an outer element

                                      type CleanupAttrsPlugin

                                      type CleanupAttrsPlugin = DefaultPlugin<
                                      'cleanupAttrs',
                                      {
                                      /** @default true */
                                      newlines?: boolean;
                                      /** @default true */
                                      trim?: boolean;
                                      /** @default true */
                                      spaces?: boolean;
                                      }
                                      >;
                                      • cleanups attributes from newlines, trailing and repeating spaces

                                      type CleanupEnableBackgroundPlugin

                                      type CleanupEnableBackgroundPlugin = DefaultPlugin<'cleanupEnableBackground'>;
                                      • remove or cleanup enable-background attribute when possible

                                      type CleanupIDsPlugin

                                      type CleanupIDsPlugin = DefaultPlugin<
                                      'cleanupIDs',
                                      {
                                      /** @default true */
                                      remove?: boolean;
                                      /** @default true */
                                      minify?: boolean;
                                      /** @default '' */
                                      prefix?: string;
                                      /** @default [] */
                                      preserve?: any[];
                                      /** @default [] */
                                      preservePrefixes?: any[];
                                      /** @default false */
                                      force?: boolean;
                                      }
                                      >;
                                      • removes unused IDs and minifies used

                                      type CleanupListOfValuesPlugin

                                      type CleanupListOfValuesPlugin = DefaultPlugin<
                                      'cleanupListOfValues',
                                      {
                                      /** @default 3 */
                                      floatPrecision?: number;
                                      /** @default true */
                                      leadingZero?: boolean;
                                      /** @default true */
                                      defaultPx?: boolean;
                                      /** @default true */
                                      convertToPx?: boolean;
                                      }
                                      >;
                                      • rounds list of values to the fixed precision

                                      type CleanupNumericValuesPlugin

                                      type CleanupNumericValuesPlugin = DefaultPlugin<
                                      'cleanupNumericValues',
                                      {
                                      /** @default 3 */
                                      floatPrecision?: number;
                                      /** @default true */
                                      leadingZero?: boolean;
                                      /** @default true */
                                      defaultPx?: boolean;
                                      /** @default true */
                                      convertToPx?: boolean;
                                      }
                                      >;
                                      • rounds numeric values to the fixed precision, removes default ‘px’ units

                                      type CollapseGroupsPlugin

                                      type CollapseGroupsPlugin = DefaultPlugin<'collapseGroups'>;
                                      • collapses useless groups

                                      type ConvertColorsPlugin

                                      type ConvertColorsPlugin = DefaultPlugin<
                                      'convertColors',
                                      {
                                      /** @default false */
                                      currentColor?: boolean;
                                      /** @default true */
                                      names2hex?: boolean;
                                      /** @default true */
                                      rgb2hex?: boolean;
                                      /** @default true */
                                      shorthex?: boolean;
                                      /** @default true */
                                      shortname?: boolean;
                                      }
                                      >;
                                      • converts colors: rgb() to #rrggbb and #rrggbb to #rgb

                                      type ConvertEllipseToCirclePlugin

                                      type ConvertEllipseToCirclePlugin = DefaultPlugin<'convertEllipseToCircle'>;
                                      • converts non-eccentric s to s

                                      type ConvertPathDataPlugin

                                      type ConvertPathDataPlugin = DefaultPlugin<
                                      'convertPathData',
                                      {
                                      /** @default true */
                                      applyTransforms?: boolean;
                                      /** @default true */
                                      applyTransformsStroked?: boolean;
                                      makeArcs?: {
                                      /** @default 2.5 */
                                      threshold?: number;
                                      /** @default 0.5 */
                                      tolerance?: number;
                                      };
                                      /** @default true */
                                      straightCurves?: boolean;
                                      /** @default true */
                                      lineShorthands?: boolean;
                                      /** @default true */
                                      curveSmoothShorthands?: boolean;
                                      /** @default 3 */
                                      floatPrecision?: number;
                                      /** @default 5 */
                                      transformPrecision?: number;
                                      /** @default true */
                                      removeUseless?: boolean;
                                      /** @default true */
                                      collapseRepeated?: boolean;
                                      /** @default true */
                                      utilizeAbsolute?: boolean;
                                      /** @default true */
                                      leadingZero?: boolean;
                                      /** @default true */
                                      negativeExtraSpace?: boolean;
                                      /** @default false */
                                      noSpaceAfterFlags?: boolean;
                                      /** @default false */
                                      forceAbsolutePath?: boolean;
                                      }
                                      >;
                                      • optimizes path data: writes in shorter form, applies transformations

                                      type ConvertShapeToPathPlugin

                                      type ConvertShapeToPathPlugin = DefaultPlugin<
                                      'convertShapeToPath',
                                      {
                                      /** @default false */
                                      convertArcs?: boolean;
                                      }
                                      >;
                                      • converts basic shapes to more compact path form

                                      type ConvertStyleToAttrsPlugin

                                      type ConvertStyleToAttrsPlugin = DefaultPlugin<
                                      'convertStyleToAttrs',
                                      {
                                      /** @default false */
                                      keepImportant?: boolean;
                                      }
                                      >;
                                      • converts style to attributes

                                      type ConvertTransformPlugin

                                      type ConvertTransformPlugin = DefaultPlugin<
                                      'convertTransform',
                                      {
                                      /** @default true */
                                      convertToShorts?: boolean;
                                      /** @default 3 */
                                      floatPrecision?: number;
                                      /** @default 5 */
                                      transformPrecision?: number;
                                      /** @default true */
                                      matrixToTransform?: boolean;
                                      /** @default true */
                                      shortTranslate?: boolean;
                                      /** @default true */
                                      shortScale?: boolean;
                                      /** @default true */
                                      shortRotate?: boolean;
                                      /** @default true */
                                      removeUseless?: boolean;
                                      /** @default true */
                                      collapseIntoOne?: boolean;
                                      /** @default true */
                                      leadingZero?: boolean;
                                      /** @default false */
                                      negativeExtraSpace?: boolean;
                                      }
                                      >;
                                      • collapses multiple transformations and optimizes it

                                      type DefaultPlugins

                                      type DefaultPlugins =
                                      | AddAttributesToSVGElementPlugin
                                      | AddClassesToSVGElementPlugin
                                      | CleanupAttrsPlugin
                                      | CleanupEnableBackgroundPlugin
                                      | CleanupIDsPlugin
                                      | CleanupListOfValuesPlugin
                                      | CleanupNumericValuesPlugin
                                      | CollapseGroupsPlugin
                                      | ConvertColorsPlugin
                                      | ConvertEllipseToCirclePlugin
                                      | ConvertPathDataPlugin
                                      | ConvertShapeToPathPlugin
                                      | ConvertStyleToAttrsPlugin
                                      | ConvertTransformPlugin
                                      | InlineStylesPlugin
                                      | MergePathsPlugin
                                      | MergeStylesPlugin
                                      | MinifyStylesPlugin
                                      | MoveElemsAttrsToGroupPlugin
                                      | MoveGroupAttrsToElemsPlugin
                                      | PrefixIdsPlugin
                                      | RemoveAttributesBySelectorPlugin
                                      | RemoveAttrsPlugin
                                      | RemoveAttrsPlugin
                                      | RemoveCommentsPlugin
                                      | RemoveDescPlugin
                                      | RemoveDimensionsPlugin
                                      | RemoveDoctypePlugin
                                      | RemoveEditorsNSDataPlugin
                                      | RemoveElementsByAttrPlugin
                                      | RemoveEmptyAttrsPlugin
                                      | RemoveEmptyContainersPlugin
                                      | RemoveEmptyTextPlugin
                                      | RemoveHiddenElemsPlugin
                                      | RemoveMetadataPlugin
                                      | RemoveNonInheritableGroupAttrsPlugin
                                      | RemoveOffCanvasPathsPlugin
                                      | RemoveRasterImagesPlugin
                                      | RemoveScriptElementPlugin
                                      | RemoveStyleElementPlugin
                                      | RemoveTitlePlugin
                                      | RemoveUnknownsAndDefaultsPlugin
                                      | RemoveUnusedNSPlugin
                                      | RemoveUselessDefsPlugin
                                      | RemoveUselessStrokeAndFillPlugin
                                      | RemoveViewBoxPlugin
                                      | RemoveXMLNSPlugin
                                      | RemoveXMLProcInstPlugin
                                      | ReusePathsPlugin
                                      | SortAttrsPlugin
                                      | SortDefsChildrenPlugin;

                                        type InlineStylesPlugin

                                        type InlineStylesPlugin = DefaultPlugin<
                                        'inlineStyles',
                                        {
                                        /** @default true */
                                        onlyMatchedOnce?: boolean;
                                        /** @default true */
                                        removeMatchedSelectors?: boolean;
                                        /** @default ['', 'screen'] */
                                        useMqs?: string[];
                                        /** @default [''] */
                                        usePseudos?: string[];
                                        }
                                        >;
                                        • inline styles (additional options)

                                        type MergePathsPlugin

                                        type MergePathsPlugin = DefaultPlugin<
                                        'mergePaths',
                                        {
                                        /** @default true */
                                        collapseRepeated?: boolean;
                                        /** @default false */
                                        force?: boolean;
                                        /** @default true */
                                        leadingZero?: boolean;
                                        /** @default true */
                                        negativeExtraSpace?: boolean;
                                        /** @default false */
                                        noSpaceAfterFlags?: boolean;
                                        }
                                        >;
                                        • merges multiple paths in one if possible

                                        type MergeStylesPlugin

                                        type MergeStylesPlugin = DefaultPlugin<'mergeStyles'>;
                                        • merge multiple style elements into one

                                        type MinifyStylesPlugin

                                        type MinifyStylesPlugin = DefaultPlugin<
                                        'minifyStyles',
                                        {
                                        usage: {
                                        /** @default false */
                                        force?: boolean;
                                        /** @default true */
                                        ids?: boolean;
                                        /** @default true */
                                        classes?: boolean;
                                        /** @default true */
                                        tags?: boolean;
                                        };
                                        }
                                        >;
                                        • minifies styles and removes unused styles based on usage data

                                        type MoveElemsAttrsToGroupPlugin

                                        type MoveElemsAttrsToGroupPlugin = DefaultPlugin<'moveElemsAttrsToGroup'>;
                                        • moves elements attributes to the existing group wrapper

                                        type MoveGroupAttrsToElemsPlugin

                                        type MoveGroupAttrsToElemsPlugin = DefaultPlugin<'moveGroupAttrsToElems'>;
                                        • moves some group attributes to the content elements

                                        type Plugin

                                        type Plugin = DefaultPlugins | DefaultPlugins['name'] | CustomPlugin;

                                          type PluginsPlugin

                                          type PluginsPlugin = DefaultPlugin<'plugins'>;
                                          • undefined

                                          type PrefixIdsPlugin

                                          type PrefixIdsPlugin = DefaultPlugin<
                                          'prefixIds',
                                          {
                                          /** @default '__' */
                                          delim?: string;
                                          /** @default true */
                                          prefixIds?: boolean;
                                          /** @default true */
                                          prefixClassNames?: boolean;
                                          }
                                          >;
                                          • prefix IDs

                                          type RemoveAttributesBySelectorPlugin

                                          type RemoveAttributesBySelectorPlugin = DefaultPlugin<'removeAttributesBySelector'>;
                                          • removes attributes of elements that match a css selector

                                          type RemoveAttrsPlugin

                                          type RemoveAttrsPlugin = DefaultPlugin<
                                          'removeAttrs',
                                          {
                                          /** @default ':' */
                                          elemSeparator?: string;
                                          /** @default false */
                                          preserveCurrentColor?: boolean;
                                          /** @default [] */
                                          attrs?: any[];
                                          }
                                          >;
                                          • removes specified attributes

                                          type RemoveCommentsPlugin

                                          type RemoveCommentsPlugin = DefaultPlugin<'removeComments'>;
                                          • removes comments

                                          type RemoveDescPlugin

                                          type RemoveDescPlugin = DefaultPlugin<
                                          'removeDesc',
                                          {
                                          /** @default true */
                                          removeAny?: boolean;
                                          }
                                          >;
                                          • removes

                                          type RemoveDimensionsPlugin

                                          type RemoveDimensionsPlugin = DefaultPlugin<'removeDimensions'>;
                                          • removes width and height in presence of viewBox (opposite to removeViewBox, disable it first)

                                          type RemoveDoctypePlugin

                                          type RemoveDoctypePlugin = DefaultPlugin<'removeDoctype'>;
                                          • removes doctype declaration

                                          type RemoveEditorsNSDataPlugin

                                          type RemoveEditorsNSDataPlugin = DefaultPlugin<
                                          'removeEditorsNSData',
                                          {
                                          /** @default [] */
                                          additionalNamespaces?: any[];
                                          }
                                          >;
                                          • removes editors namespaces, elements and attributes

                                          type RemoveElementsByAttrPlugin

                                          type RemoveElementsByAttrPlugin = DefaultPlugin<
                                          'removeElementsByAttr',
                                          {
                                          /** @default [] */
                                          id?: any[];
                                          /** @default [] */
                                          class?: any[];
                                          }
                                          >;
                                          • removes arbitrary elements by ID or className (disabled by default)

                                          type RemoveEmptyAttrsPlugin

                                          type RemoveEmptyAttrsPlugin = DefaultPlugin<'removeEmptyAttrs'>;
                                          • removes empty attributes

                                          type RemoveEmptyContainersPlugin

                                          type RemoveEmptyContainersPlugin = DefaultPlugin<'removeEmptyContainers'>;
                                          • removes empty container elements

                                          type RemoveEmptyTextPlugin

                                          type RemoveEmptyTextPlugin = DefaultPlugin<
                                          'removeEmptyText',
                                          {
                                          /** @default true */
                                          text?: boolean;
                                          /** @default true */
                                          tspan?: boolean;
                                          /** @default true */
                                          tref?: boolean;
                                          }
                                          >;
                                          • removes empty elements

                                          type RemoveHiddenElemsPlugin

                                          type RemoveHiddenElemsPlugin = DefaultPlugin<
                                          'removeHiddenElems',
                                          {
                                          /** @default true */
                                          isHidden?: boolean;
                                          /** @default true */
                                          displayNone?: boolean;
                                          /** @default true */
                                          opacity0?: boolean;
                                          /** @default true */
                                          circleR0?: boolean;
                                          /** @default true */
                                          ellipseRX0?: boolean;
                                          /** @default true */
                                          ellipseRY0?: boolean;
                                          /** @default true */
                                          rectWidth0?: boolean;
                                          /** @default true */
                                          rectHeight0?: boolean;
                                          /** @default true */
                                          patternWidth0?: boolean;
                                          /** @default true */
                                          patternHeight0?: boolean;
                                          /** @default true */
                                          imageWidth0?: boolean;
                                          /** @default true */
                                          imageHeight0?: boolean;
                                          /** @default true */
                                          pathEmptyD?: boolean;
                                          /** @default true */
                                          polylineEmptyPoints?: boolean;
                                          /** @default true */
                                          polygonEmptyPoints?: boolean;
                                          }
                                          >;
                                          • removes hidden elements (zero sized, with absent attributes)

                                          type RemoveMetadataPlugin

                                          type RemoveMetadataPlugin = DefaultPlugin<'removeMetadata'>;
                                          • removes

                                          type RemoveNonInheritableGroupAttrsPlugin

                                          type RemoveNonInheritableGroupAttrsPlugin = DefaultPlugin<'removeNonInheritableGroupAttrs'>;
                                          • removes non-inheritable group’s presentational attributes

                                          type RemoveOffCanvasPathsPlugin

                                          type RemoveOffCanvasPathsPlugin = DefaultPlugin<'removeOffCanvasPaths'>;
                                          • removes elements that are drawn outside of the viewbox (disabled by default)

                                          type RemoveRasterImagesPlugin

                                          type RemoveRasterImagesPlugin = DefaultPlugin<'removeRasterImages'>;
                                          • removes raster images (disabled by default)

                                          type RemoveScriptElementPlugin

                                          type RemoveScriptElementPlugin = DefaultPlugin<'removeScriptElement'>;
                                          • removes elements (disabled by default)

                                          type RemoveStyleElementPlugin

                                          type RemoveStyleElementPlugin = DefaultPlugin<'removeStyleElement'>;
                                          • removes element (disabled by default)

                                          type RemoveTitlePlugin

                                          type RemoveTitlePlugin = DefaultPlugin<'removeTitle'>;
                                          • removes

                                          type RemoveUnknownsAndDefaultsPlugin

                                          type RemoveUnknownsAndDefaultsPlugin = DefaultPlugin<
                                          'removeUnknownsAndDefaults',
                                          {
                                          /** @default true */
                                          unknownContent?: boolean;
                                          /** @default true */
                                          unknownAttrs?: boolean;
                                          /** @default true */
                                          defaultAttrs?: boolean;
                                          /** @default true */
                                          uselessOverrides?: boolean;
                                          /** @default true */
                                          keepDataAttrs?: boolean;
                                          /** @default true */
                                          keepAriaAttrs?: boolean;
                                          /** @default false */
                                          keepRoleAttr?: boolean;
                                          }
                                          >;
                                          • removes unknown elements content and attributes, removes attrs with default values

                                          type RemoveUnusedNSPlugin

                                          type RemoveUnusedNSPlugin = DefaultPlugin<'removeUnusedNS'>;
                                          • removes unused namespaces declaration

                                          type RemoveUselessDefsPlugin

                                          type RemoveUselessDefsPlugin = DefaultPlugin<'removeUselessDefs'>;
                                          • removes elements in without id

                                          type RemoveUselessStrokeAndFillPlugin

                                          type RemoveUselessStrokeAndFillPlugin = DefaultPlugin<
                                          'removeUselessStrokeAndFill',
                                          {
                                          /** @default true */
                                          stroke?: boolean;
                                          /** @default true */
                                          fill?: boolean;
                                          /** @default false */
                                          removeNone?: boolean;
                                          /** @default false */
                                          hasStyleOrScript?: boolean;
                                          }
                                          >;
                                          • removes useless stroke and fill attributes

                                          type RemoveViewBoxPlugin

                                          type RemoveViewBoxPlugin = DefaultPlugin<'removeViewBox'>;
                                          • removes viewBox attribute when possible

                                          type RemoveXMLNSPlugin

                                          type RemoveXMLNSPlugin = DefaultPlugin<'removeXMLNS'>;
                                          • removes xmlns attribute (for inline svg, disabled by default)

                                          type RemoveXMLProcInstPlugin

                                          type RemoveXMLProcInstPlugin = DefaultPlugin<'removeXMLProcInst'>;
                                          • removes XML processing instructions

                                          type ReusePathsPlugin

                                          type ReusePathsPlugin = DefaultPlugin<'reusePaths'>;
                                          • Finds elements with the same d, fill, and stroke, and converts them to elements referencing a single def.

                                          type SortAttrsPlugin

                                          type SortAttrsPlugin = DefaultPlugin<
                                          'sortAttrs',
                                          {
                                          /**
                                          * @default ['id', 'width', 'height', 'x', 'x1', 'x2', 'y', 'y1', 'y2', 'cx', 'cy', 'r', 'fill', 'stroke', 'marker', 'd', 'points']
                                          */
                                          order?: string[];
                                          }
                                          >;
                                          • sorts element attributes (disabled by default)

                                          type SortDefsChildrenPlugin

                                          type SortDefsChildrenPlugin = DefaultPlugin<'sortDefsChildren'>;
                                          • Sorts children of to improve compression

                                          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/svgo.

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