.markdown li,body{word-wrap:break-word}body,ol ol,ol ul,ul ol,ul ul{margin:0}pre,table{overflow:auto}blockquote,pre{margin:0 0 var(--ifm-spacing-vertical)}.breadcrumbs__link,.button{transition-timing-function:var(--ifm-transition-timing-default)}.admonition-icon,.button,code{vertical-align:middle}.button--outline.button--active,.button--outline:active,.button--outline:hover,:root{--ifm-button-color:var(--ifm-font-color-base-inverse)}.button,.clean-btn,.close,.menu__link,.navbar__link{cursor:pointer}.navbar--dark,:root{--ifm-navbar-link-hover-color:var(--ifm-color-primary)}.tabs__item,hr,img{box-sizing:content-box}:root,html[data-theme=dark]{--ifm-color-emphasis-500:var(--ifm-color-gray-500);--ifm-link-color:var(--ifm-color-primary);--ifm-contents-border-color:var(--ifm-color-emphasis-75)}body,html{-moz-text-size-adjust:100%;text-size-adjust:100%;-webkit-text-size-adjust:100%}input[type=email],input[type=text],table.comparison tr td.bar:hover,table.comparison tr td.result{background:var(--ifm-panel-background)}header,section{margin-bottom:calc(var(--ifm-leading)*2)}.admonition,.section-list>.section>h3,.section-list>.section>h4,.section-list>.section>h5,.section-list>.section>h6{margin-bottom:1em}.markdown svg,.row .col,img{max-width:100%}.markdown table,table{border-collapse:collapse}.DocSearch-Hit-content-wrapper,.navbar__title,.table-of-contents ul.contents li,.text--truncate{text-overflow:ellipsis;white-space:nowrap}.react-toggle,html{-webkit-tap-highlight-color:transparent}.container svg [stroke="#000000"],.footer svg [stroke="#000000"],.integrations g.item circle,.markdown svg [stroke="#000000"],.navbar__brand svg [stroke="#000000"],.sidebar__logo svg [stroke="#000000"],html[data-theme=dark] .container svg [stroke="#000000"],html[data-theme=dark] .footer svg [stroke="#000000"],html[data-theme=dark] .markdown svg [stroke="#000000"],html[data-theme=dark] .navbar__brand svg [stroke="#000000"],html[data-theme=dark] .sidebar__logo svg [stroke="#000000"]{stroke:var(--ifm-heading-color)}:root{--ra-admonition-background-color:var(--ifm-alert-background-color);--ra-admonition-border-width:var(--ifm-alert-border-width);--ra-admonition-border-color:var(--ifm-alert-border-color);--ra-admonition-border-radius:var(--ifm-alert-border-radius);--ra-admonition-color:var(--ifm-alert-color);--ra-admonition-padding-vertical:var(--ifm-alert-padding-vertical);--ra-admonition-padding-horizontal:var(--ifm-alert-padding-horizontal);--ra-color-note:var(--ifm-color-secondary);--ra-color-important:var(--ifm-color-info);--ra-color-tip:var(--ifm-color-success);--ra-color-caution:var(--ifm-color-warning);--ra-color-warning:var(--ifm-color-danger);--ra-color-text-dark:var(--ifm-color-gray-900)}.admonition{--ra-admonition-icon-color:var(--ra-admonition-color)}.admonition:not(.alert){--ra-admonition-background-color:var(--ifm-color-primary);background-color:var(--ra-admonition-background-color);border:var(--ra-admonition-border-width) solid var(--ra-admonition-border-color);border-radius:var(--ra-admonition-border-radius);box-sizing:border-box;color:var(--ra-admonition-color);padding:var(--ra-admonition-padding-vertical) var(--ra-admonition-padding-horizontal)}.container,.row .col{padding:0 var(--ifm-spacing-horizontal);width:100%}.admonition h5{margin-bottom:8px;margin-top:0;text-transform:uppercase}.admonition-icon{display:inline-block;margin-right:.2em}.admonition-icon svg{stroke-width:0;fill:var(--ra-admonition-icon-color);stroke:var(--ra-admonition-icon-color);display:inline-block;height:22px;width:22px}.admonition-content>:last-child,blockquote>:last-child{margin-bottom:0}.admonition-note{--ra-admonition-color:var(--ra-color-text-dark)}:root{--ifm-dark-value:10%;--ifm-darker-value:15%;--ifm-darkest-value:30%;--ifm-light-value:15%;--ifm-lighter-value:30%;--ifm-lightest-value:50%;--ifm-color-primary:#3578e5;--ifm-color-primary-dark:#306cce;--ifm-color-primary-darker:#2d66c3;--ifm-color-primary-darkest:#2554a0;--ifm-color-primary-light:#538ce9;--ifm-color-primary-lighter:#72a1ed;--ifm-color-primary-lightest:#9abcf2;--ifm-color-secondary:#ebedf0;--ifm-color-secondary-dark:#d4d5d8;--ifm-color-secondary-darker:#c8c9cc;--ifm-color-secondary-darkest:#a4a6a8;--ifm-color-secondary-light:#eef0f2;--ifm-color-secondary-lighter:#f1f2f5;--ifm-color-secondary-lightest:#f5f6f8;--ifm-color-success:#00a400;--ifm-color-success-dark:#009400;--ifm-color-success-darker:#008b00;--ifm-color-success-darkest:#007300;--ifm-color-success-light:#26b226;--ifm-color-success-lighter:#4dbf4d;--ifm-color-success-lightest:#80d280;--ifm-color-info:#54c7ec;--ifm-color-info-dark:#4cb3d4;--ifm-color-info-darker:#47a9c9;--ifm-color-info-darkest:#3b8ba5;--ifm-color-info-light:#6ecfef;--ifm-color-info-lighter:#87d8f2;--ifm-color-info-lightest:#aae3f6;--ifm-color-warning:#ffba00;--ifm-color-warning-dark:#e6a700;--ifm-color-warning-darker:#d99e00;--ifm-color-warning-darkest:#b38200;--ifm-color-warning-light:#ffc426;--ifm-color-warning-lighter:#ffcf4d;--ifm-color-warning-lightest:#ffdd80;--ifm-color-danger:#fa383e;--ifm-color-danger-dark:#e13238;--ifm-color-danger-darker:#d53035;--ifm-color-danger-darkest:#af272b;--ifm-color-danger-light:#fb565b;--ifm-color-danger-lighter:#fb7478;--ifm-color-danger-lightest:#fd9c9f;--ifm-color-white:#fff;--ifm-color-black:#000;--ifm-color-gray-0:var(--ifm-color-white);--ifm-color-gray-100:#f5f6f7;--ifm-color-gray-200:#ebedf0;--ifm-color-gray-300:#dadde1;--ifm-color-gray-400:#ccd0d5;--ifm-color-gray-500:#bec3c9;--ifm-color-gray-600:#8d949e;--ifm-color-gray-700:#606770;--ifm-color-gray-800:#444950;--ifm-color-gray-900:#1c1e21;--ifm-color-gray-1000:var(--ifm-color-black);--ifm-color-emphasis-0:var(--ifm-color-gray-0);--ifm-color-emphasis-100:var(--ifm-color-gray-100);--ifm-color-emphasis-200:var(--ifm-color-gray-200);--ifm-color-emphasis-300:var(--ifm-color-gray-300);--ifm-color-emphasis-400:var(--ifm-color-gray-400);--ifm-color-emphasis-600:var(--ifm-color-gray-600);--ifm-color-emphasis-700:var(--ifm-color-gray-700);--ifm-color-emphasis-800:var(--ifm-color-gray-800);--ifm-color-emphasis-900:var(--ifm-color-gray-900);--ifm-color-emphasis-1000:var(--ifm-color-gray-1000);--ifm-color-content:var(--ifm-color-emphasis-900);--ifm-color-content-inverse:var(--ifm-color-emphasis-0);--ifm-color-content-secondary:#525860;--ifm-background-color:transparent;--ifm-background-surface-color:var(--ifm-color-content-inverse);--ifm-global-border-width:1px;--ifm-global-radius:0.4rem;--ifm-hover-overlay:rgba(0,0,0,0.05);--ifm-font-color-base:var(--ifm-color-content);--ifm-font-color-base-inverse:var(--ifm-color-content-inverse);--ifm-font-color-secondary:var(--ifm-color-content-secondary);--ifm-font-family-base:system-ui,-apple-system,Segoe UI,Roboto,Ubuntu,Cantarell,Noto Sans,sans-serif,BlinkMacSystemFont,"Segoe UI",Helvetica,Arial,sans-serif,"Apple Color Emoji","Segoe UI Emoji","Segoe UI Symbol";--ifm-font-family-monospace:SFMono-Regular,Menlo,Monaco,Consolas,"Liberation Mono","Courier New",monospace;--ifm-font-size-base:100%;--ifm-font-weight-light:300;--ifm-font-weight-normal:400;--ifm-font-weight-semibold:500;--ifm-font-weight-bold:700;--ifm-font-weight-base:var(--ifm-font-weight-normal);--ifm-line-height-base:1.65;--ifm-global-spacing:1rem;--ifm-spacing-vertical:var(--ifm-global-spacing);--ifm-spacing-horizontal:var(--ifm-global-spacing);--ifm-transition-fast:200ms;--ifm-transition-slow:400ms;--ifm-transition-timing-default:cubic-bezier(0.08,0.52,0.52,1);--ifm-global-shadow-lw:0 1px 2px 0 rgba(0,0,0,0.1);--ifm-global-shadow-md:0 5px 40px rgba(0,0,0,0.2);--ifm-global-shadow-tl:0 12px 28px 0 rgba(0,0,0,0.2),0 2px 4px 0 rgba(0,0,0,0.1);--ifm-z-index-dropdown:5;--ifm-z-index-fixed:7;--ifm-z-index-overlay:9;--ifm-container-width:1140px;--ifm-container-width-xl:1320px;--ifm-code-background:rgba(0,0,0,.05);--ifm-code-border-radius:var(--ifm-global-radius);--ifm-code-font-size:90%;--ifm-code-padding-horizontal:0.3rem;--ifm-code-padding-vertical:0.1rem;--ifm-pre-background:var(--ifm-color-emphasis-100);--ifm-pre-border-radius:var(--ifm-code-border-radius);--ifm-pre-color:inherit;--ifm-pre-line-height:1.45;--ifm-pre-padding:1rem;--ifm-heading-color:inherit;--ifm-heading-margin-top:0;--ifm-heading-margin-bottom:var(--ifm-spacing-vertical);--ifm-heading-font-family:inherit;--ifm-heading-font-weight:var(--ifm-font-weight-bold);--ifm-heading-line-height:1.25;--ifm-h1-font-size:2rem;--ifm-h2-font-size:1.5rem;--ifm-h3-font-size:1.25rem;--ifm-h4-font-size:1rem;--ifm-h5-font-size:0.875rem;--ifm-h6-font-size:0.85rem;--ifm-image-alignment-padding:1.25rem;--ifm-leading-desktop:1.25;--ifm-leading:calc(var(--ifm-leading-desktop)*1rem);--ifm-list-left-padding:2rem;--ifm-list-margin:1rem;--ifm-list-item-margin:0.25rem;--ifm-list-paragraph-margin:1rem;--ifm-table-cell-padding:0.75rem;--ifm-table-background:transparent;--ifm-table-stripe-background:var(--ifm-color-emphasis-100);--ifm-table-border-width:1px;--ifm-table-border-color:var(--ifm-color-emphasis-300);--ifm-table-head-background:inherit;--ifm-table-head-color:inherit;--ifm-table-head-font-weight:var(--ifm-font-weight-bold);--ifm-table-cell-color:inherit;--ifm-link-decoration:none;--ifm-link-hover-color:var(--ifm-link-color);--ifm-link-hover-decoration:underline;--ifm-paragraph-margin-bottom:var(--ifm-leading);--ifm-blockquote-color:#6a737d;--ifm-blockquote-font-size:var(--ifm-font-size-base);--ifm-blockquote-padding-horizontal:1rem;--ifm-blockquote-padding-vertical:1rem;--ifm-hr-border-color:var(--ifm-color-emphasis-500);--ifm-hr-border-width:1px;--ifm-hr-margin-vertical:1.5rem;--ifm-scrollbar-size:7px;--ifm-scrollbar-track-background-color:#f1f1f1;--ifm-scrollbar-thumb-background-color:#888;--ifm-scrollbar-thumb-hover-background-color:#555;--ifm-alert-background-color:inherit;--ifm-alert-border-color:inherit;--ifm-alert-border-radius:var(--ifm-global-radius);--ifm-alert-border-width:var(--ifm-global-border-width);--ifm-alert-color:var(--ifm-font-color-base-inverse);--ifm-alert-padding-horizontal:var(--ifm-spacing-horizontal);--ifm-alert-padding-vertical:var(--ifm-spacing-vertical);--ifm-avatar-intro-margin:1rem;--ifm-avatar-intro-alignment:inherit;--ifm-avatar-photo-size-sm:2rem;--ifm-avatar-photo-size-md:3rem;--ifm-avatar-photo-size-lg:4rem;--ifm-avatar-photo-size-xl:6rem;--ifm-badge-background-color:inherit;--ifm-badge-border-color:inherit;--ifm-badge-border-radius:var(--ifm-global-radius);--ifm-badge-border-width:var(--ifm-global-border-width);--ifm-badge-color:var(--ifm-color-white);--ifm-badge-padding-horizontal:calc(var(--ifm-spacing-horizontal)*0.5);--ifm-badge-padding-vertical:calc(var(--ifm-spacing-vertical)*0.25);--ifm-breadcrumb-border-radius:1.5rem;--ifm-breadcrumb-spacing:0.0625rem;--ifm-breadcrumb-color-active:var(--ifm-color-primary);--ifm-breadcrumb-item-background-active:var(--ifm-hover-overlay);--ifm-breadcrumb-padding-horizontal:1rem;--ifm-breadcrumb-padding-vertical:0.5rem;--ifm-breadcrumb-size-multiplier:1;--ifm-breadcrumb-separator:url('data:image/svg+xml;utf8,<svg xmlns="http://www.w3.org/2000/svg" x="0px" y="0px" viewBox="0 0 256 256"><g><g><polygon points="79.093,0 48.907,30.187 146.72,128 48.907,225.813 79.093,256 207.093,128"/></g></g><g></g><g></g><g></g><g></g><g></g><g></g><g></g><g></g><g></g><g></g><g></g><g></g><g></g><g></g><g></g></svg>');--ifm-breadcrumb-separator-filter:none;--ifm-breadcrumb-separator-size:0.5rem;--ifm-breadcrumb-separator-size-multiplier:1.25;--ifm-button-background-color:inherit;--ifm-button-border-color:var(--ifm-button-background-color);--ifm-button-border-width:var(--ifm-global-border-width);--ifm-button-font-weight:var(--ifm-font-weight-bold);--ifm-button-padding-horizontal:1.5rem;--ifm-button-padding-vertical:0.375rem;--ifm-button-size-multiplier:1;--ifm-button-transition-duration:var(--ifm-transition-fast);--ifm-button-border-radius:calc(var(--ifm-global-radius)*var(--ifm-button-size-multiplier));--ifm-button-group-margin:2px;--ifm-card-background-color:var(--ifm-background-surface-color);--ifm-card-border-radius:calc(var(--ifm-global-radius)*2);--ifm-card-horizontal-spacing:var(--ifm-global-spacing);--ifm-card-vertical-spacing:var(--ifm-global-spacing);--ifm-toc-border-color:var(--ifm-color-emphasis-300);--ifm-toc-link-color:var(--ifm-color-content-secondary);--ifm-toc-padding-vertical:0.5rem;--ifm-toc-padding-horizontal:0.5rem;--ifm-dropdown-background-color:var(--ifm-background-surface-color);--ifm-dropdown-font-weight:var(--ifm-font-weight-semibold);--ifm-dropdown-link-color:var(--ifm-font-color-base);--ifm-dropdown-hover-background-color:var(--ifm-hover-overlay);--ifm-footer-background-color:var(--ifm-color-emphasis-100);--ifm-footer-color:inherit;--ifm-footer-link-color:var(--ifm-color-emphasis-700);--ifm-footer-link-hover-color:var(--ifm-color-primary);--ifm-footer-link-horizontal-spacing:0.5rem;--ifm-footer-padding-horizontal:calc(var(--ifm-spacing-horizontal)*2);--ifm-footer-padding-vertical:calc(var(--ifm-spacing-vertical)*2);--ifm-footer-title-color:inherit;--ifm-hero-background-color:var(--ifm-background-surface-color);--ifm-hero-text-color:var(--ifm-color-emphasis-800);--ifm-menu-color:var(--ifm-color-emphasis-700);--ifm-menu-color-active:var(--ifm-color-primary);--ifm-menu-color-background-active:var(--ifm-hover-overlay);--ifm-menu-color-background-hover:var(--ifm-hover-overlay);--ifm-menu-link-padding-horizontal:1rem;--ifm-menu-link-padding-vertical:0.375rem;--ifm-menu-link-sublist-icon:url('data:image/svg+xml;utf8,<svg xmlns="http://www.w3.org/2000/svg" width="16px" height="16px" viewBox="0 0 24 24"><path fill="rgba(0,0,0,0.5)" d="M7.41 15.41L12 10.83l4.59 4.58L18 14l-6-6-6 6z"></path></svg>');--ifm-menu-link-sublist-icon-filter:none;--ifm-navbar-background-color:var(--ifm-background-surface-color);--ifm-navbar-height:3.75rem;--ifm-navbar-item-padding-horizontal:0.75rem;--ifm-navbar-item-padding-vertical:0.25rem;--ifm-navbar-link-color:var(--ifm-font-color-base);--ifm-navbar-link-active-color:var(--ifm-link-color);--ifm-navbar-padding-horizontal:var(--ifm-spacing-horizontal);--ifm-navbar-padding-vertical:calc(var(--ifm-spacing-vertical)*0.5);--ifm-navbar-shadow:var(--ifm-global-shadow-lw);--ifm-navbar-search-input-background-color:var(--ifm-color-emphasis-200);--ifm-navbar-search-input-color:var(--ifm-color-emphasis-800);--ifm-navbar-search-input-placeholder-color:var(--ifm-color-emphasis-500);--ifm-navbar-search-input-icon:url('data:image/svg+xml;utf8,<svg fill="currentColor" xmlns="http://www.w3.org/2000/svg" viewBox="0 0 16 16" height="16px" width="16px"><path d="M6.02945,10.20327a4.17382,4.17382,0,1,1,4.17382-4.17382A4.15609,4.15609,0,0,1,6.02945,10.20327Zm9.69195,4.2199L10.8989,9.59979A5.88021,5.88021,0,0,0,12.058,6.02856,6.00467,6.00467,0,1,0,9.59979,10.8989l4.82338,4.82338a.89729.89729,0,0,0,1.29912,0,.89749.89749,0,0,0-.00087-1.29909Z" /></svg>');--ifm-navbar-sidebar-width:80vw;--ifm-pagination-border-radius:calc(var(--ifm-global-radius)*var(--ifm-pagination-size-multiplier));--ifm-pagination-color-active:var(--ifm-color-primary);--ifm-pagination-font-size:1rem;--ifm-pagination-item-active-background:var(--ifm-hover-overlay);--ifm-pagination-page-spacing:0.0625rem;--ifm-pagination-padding-horizontal:calc(var(--ifm-spacing-horizontal)*1);--ifm-pagination-padding-vertical:calc(var(--ifm-spacing-vertical)*0.25);--ifm-pagination-size-multiplier:1;--ifm-pagination-nav-border-radius:var(--ifm-global-radius);--ifm-pagination-nav-color-hover:var(--ifm-color-primary);--ifm-pills-color-active:var(--ifm-color-primary);--ifm-pills-color-background-active:var(--ifm-hover-overlay);--ifm-pills-spacing:0.0625rem;--ifm-tabs-color:var(--ifm-font-color-secondary);--ifm-tabs-color-active:var(--ifm-color-primary);--ifm-tabs-padding-horizontal:1rem;--ifm-tabs-padding-vertical:1rem;--ifm-tabs-spacing:0.0625rem}.badge--danger,.badge--info,.badge--primary,.badge--secondary,.badge--success,.badge--warning{--ifm-badge-border-color:var(--ifm-badge-background-color)}.button--link,.button--outline{--ifm-button-background-color:transparent}.navbar--dark,.navbar--primary{--ifm-navbar-search-input-background-color:hsla(0,0%,100%,0.1);--ifm-navbar-search-input-placeholder-color:hsla(0,0%,100%,0.5)}*{box-sizing:border-box}html{-webkit-font-smoothing:antialiased;text-rendering:optimizelegibility;background-color:var(--ifm-background-color);color:var(--ifm-font-color-base);font:var(--ifm-font-size-base)/var(--ifm-line-height-base) var(--ifm-font-family-base)}.container{margin:0 auto;max-width:var(--ifm-container-width)}.padding-bottom--none,.padding-vert--none{padding-bottom:0!important}.padding-top--none,.padding-vert--none{padding-top:0!important}.container--fluid{max-width:inherit}.row{display:flex;flex-direction:row;flex-wrap:wrap;margin:0 calc(var(--ifm-spacing-horizontal)*-1)}.margin-bottom--none,.margin-vert--none,.markdown>:last-child{margin-bottom:0!important}.margin-top--none,.margin-vert--none,.markdown>:first-child,.tabItem_1uMI{margin-top:0!important}.row .col{--ifm-col-width:100%;flex:1 0;margin-left:0}.row .col.col--1,.row .col.col--2,.row .col.col--3,.row .col[class*=col--]{flex:0 0 var(--ifm-col-width);max-width:var(--ifm-col-width)}.row .col.col--1{--ifm-col-width:8.33333%}.row .col.col--offset-1{margin-left:8.33333%}.row .col.col--2{--ifm-col-width:16.66667%}.row .col.col--offset-2{margin-left:16.66667%}.row .col.col--3{--ifm-col-width:25%}.row .col.col--offset-3{margin-left:25%}.row .col.col--4{--ifm-col-width:33.33333%;flex:0 0 var(--ifm-col-width);max-width:var(--ifm-col-width)}.row .col.col--offset-4{margin-left:33.33333%}.row .col.col--5{--ifm-col-width:41.66667%;flex:0 0 var(--ifm-col-width);max-width:var(--ifm-col-width)}.row .col.col--6,.row .col.col--7{flex:0 0 var(--ifm-col-width);max-width:var(--ifm-col-width)}.row .col.col--offset-5{margin-left:41.66667%}.row .col.col--6{--ifm-col-width:50%}.row .col.col--offset-6{margin-left:50%}.row .col.col--7{--ifm-col-width:58.33333%}.row .col.col--offset-7{margin-left:58.33333%}.row .col.col--8{--ifm-col-width:66.66667%;flex:0 0 var(--ifm-col-width);max-width:var(--ifm-col-width)}.row .col.col--offset-8{margin-left:66.66667%}.row .col.col--9{--ifm-col-width:75%;flex:0 0 var(--ifm-col-width);max-width:var(--ifm-col-width)}.row .col.col--10,.row .col.col--11{flex:0 0 var(--ifm-col-width);max-width:var(--ifm-col-width)}.row .col.col--offset-9{margin-left:75%}.row .col.col--10{--ifm-col-width:83.33333%}.row .col.col--offset-10{margin-left:83.33333%}.row .col.col--11{--ifm-col-width:91.66667%}.row .col.col--offset-11{margin-left:91.66667%}.row .col.col--12{--ifm-col-width:100%;flex:0 0 var(--ifm-col-width);max-width:var(--ifm-col-width)}.row .col.col--offset-12{margin-left:100%}.row--no-gutters{margin-left:0;margin-right:0}.margin-horiz--none,.margin-left--none{margin-left:0!important}.margin-horiz--none,.margin-right--none{margin-right:0!important}.container--flush,.row--no-gutters>.col,table.comparison th{padding-left:0;padding-right:0}.padding-horiz--none,.padding-left--none{padding-left:0!important}.padding-horiz--none,.padding-right--none{padding-right:0!important}.row--align-top{align-items:flex-start}.row--align-bottom{align-items:flex-end}.row--align-center{align-items:center}.row--align-stretch{align-items:stretch}.row--align-baseline{align-items:baseline}.margin--none{margin:0!important}.margin-bottom--xs,.margin-vert--xs{margin-bottom:.25rem!important}.margin-top--xs,.margin-vert--xs{margin-top:.25rem!important}.margin-horiz--xs,.margin-left--xs{margin-left:.25rem!important}.margin-horiz--xs,.margin-right--xs{margin-right:.25rem!important}.margin--xs{margin:.25rem!important}.margin-bottom--sm,.margin-vert--sm{margin-bottom:.5rem!important}.margin-top--sm,.margin-vert--sm{margin-top:.5rem!important}.margin-horiz--sm,.margin-left--sm{margin-left:.5rem!important}.margin-horiz--sm,.margin-right--sm{margin-right:.5rem!important}.margin--sm{margin:.5rem!important}.margin-bottom--md,.margin-vert--md{margin-bottom:1rem!important}.margin-top--md,.margin-vert--md{margin-top:1rem!important}.margin-horiz--md,.margin-left--md{margin-left:1rem!important}.margin-horiz--md,.margin-right--md{margin-right:1rem!important}.margin--md{margin:1rem!important}.margin-bottom--lg,.margin-vert--lg{margin-bottom:2rem!important}.margin-top--lg,.margin-vert--lg{margin-top:2rem!important}.margin-horiz--lg,.margin-left--lg{margin-left:2rem!important}.margin-horiz--lg,.margin-right--lg{margin-right:2rem!important}.margin--lg{margin:2rem!important}.margin-bottom--xl,.margin-vert--xl{margin-bottom:5rem!important}.margin-top--xl,.margin-vert--xl{margin-top:5rem!important}.margin-horiz--xl,.margin-left--xl{margin-left:5rem!important}.margin-horiz--xl,.margin-right--xl{margin-right:5rem!important}.margin--xl{margin:5rem!important}.padding--none{padding:0!important}.padding-bottom--xs,.padding-vert--xs{padding-bottom:.25rem!important}.padding-top--xs,.padding-vert--xs{padding-top:.25rem!important}.padding-horiz--xs,.padding-left--xs{padding-left:.25rem!important}.padding-horiz--xs,.padding-right--xs{padding-right:.25rem!important}.padding--xs{padding:.25rem!important}.padding-bottom--sm,.padding-vert--sm{padding-bottom:.5rem!important}.padding-top--sm,.padding-vert--sm{padding-top:.5rem!important}.padding-horiz--sm,.padding-left--sm{padding-left:.5rem!important}.padding-horiz--sm,.padding-right--sm{padding-right:.5rem!important}.padding--sm{padding:.5rem!important}.padding-bottom--md,.padding-vert--md{padding-bottom:1rem!important}.padding-top--md,.padding-vert--md{padding-top:1rem!important}.padding-horiz--md,.padding-left--md{padding-left:1rem!important}.padding-horiz--md,.padding-right--md{padding-right:1rem!important}.padding--md{padding:1rem!important}.padding-bottom--lg,.padding-vert--lg{padding-bottom:2rem!important}.padding-top--lg,.padding-vert--lg{padding-top:2rem!important}.padding-horiz--lg,.padding-left--lg{padding-left:2rem!important}.padding-horiz--lg,.padding-right--lg{padding-right:2rem!important}.padding--lg{padding:2rem!important}.padding-bottom--xl,.padding-vert--xl{padding-bottom:5rem!important}.padding-top--xl,.padding-vert--xl{padding-top:5rem!important}.padding-horiz--xl,.padding-left--xl{padding-left:5rem!important}.padding-horiz--xl,.padding-right--xl{padding-right:5rem!important}.padding--xl{padding:5rem!important}code{background-color:var(--ifm-code-background);border:.1rem solid rgba(0,0,0,.1);border-radius:var(--ifm-code-border-radius);font-family:var(--ifm-font-family-monospace);font-size:var(--ifm-code-font-size);padding:var(--ifm-code-padding-vertical) var(--ifm-code-padding-horizontal)}a code{color:inherit;color:var(--ifm-link-color)}pre{background-color:var(--ifm-pre-background);border-radius:var(--ifm-pre-border-radius);color:var(--ifm-pre-color);font:var(--ifm-code-font-size)/var(--ifm-pre-line-height) var(--ifm-font-family-monospace);padding:var(--ifm-pre-padding)}pre code{background-color:transparent;border:none;font-size:100%;line-height:inherit;padding:0}.hero h1,header h1{font-size:2.5rem}kbd{background-color:var(--ifm-color-emphasis-0);border:1px solid var(--ifm-color-emphasis-400);border-radius:.2rem;box-shadow:inset 0 -1px 0 var(--ifm-color-emphasis-400);color:var(--ifm-color-emphasis-800);font:80% var(--ifm-font-family-monospace);padding:.15rem .3rem}h1,h2,h3,h4,h5,h6{color:var(--ifm-heading-color);font-weight:var(--ifm-heading-font-weight);line-height:var(--ifm-heading-line-height);margin:var(--ifm-heading-margin-top) 0 var(--ifm-heading-margin-bottom) 0}h1{font-size:var(--ifm-h1-font-size)}h2{font-size:var(--ifm-h2-font-size);font-family:var(--ifm-heading-font-family)}h3{font-size:var(--ifm-h3-font-size)}h4{font-size:var(--ifm-h4-font-size)}h5{font-size:var(--ifm-h5-font-size)}h6{font-size:var(--ifm-h6-font-size)}img{border-style:none}img[align=right]{padding-left:var(--image-alignment-padding)}img[align=left]{padding-right:var(--image-alignment-padding)}.markdown{--ifm-h1-vertical-rhythm-top:3;--ifm-h2-vertical-rhythm-top:2;--ifm-h3-vertical-rhythm-top:1.5;--ifm-heading-vertical-rhythm-top:1.25;--ifm-h1-vertical-rhythm-bottom:1.25;--ifm-heading-vertical-rhythm-bottom:1;--ifm-h1-h2-vertical-rhythm-top:1;--ifm-h1-h2-vertical-rhythm-bottom:var(--ifm-h1-h2-vertical-rhythm-top);--ifm-h3-vertical-rhythm-top:1.25;--ifm-h3-vertical-rhythm-bottom:calc(var(--ifm-h3-vertical-rhythm-top)/2);--ifm-h4-vertical-rhythm-top:1.25;--ifm-h4-vertical-rhythm-bottom:calc(var(--ifm-h4-vertical-rhythm-top)/2);--ifm-h5-vertical-rhythm-top:1.25;--ifm-h5-vertical-rhythm-bottom:calc(var(--ifm-h5-vertical-rhythm-top)/2);--ifm-h6-vertical-rhythm-top:1.25;--ifm-h6-vertical-rhythm-bottom:calc(var(--ifm-h6-vertical-rhythm-top)/2)}.markdown:after,.markdown:before,hr:after,hr:before{content:"";display:table}.markdown:after,hr:after{clear:both}.markdown>h1{--ifm-h1-font-size:3rem;margin-bottom:calc(var(--ifm-h1-vertical-rhythm-bottom)*var(--ifm-leading));margin-top:calc(var(--ifm-h1-vertical-rhythm-top)*var(--ifm-leading))}.markdown>h2,.markdown>h3,.markdown>h4,.markdown>h5,.markdown>h6{margin-bottom:calc(var(--ifm-heading-vertical-rhythm-bottom)*var(--ifm-leading))}.markdown>h2{--ifm-h2-font-size:2rem;margin-top:calc(var(--ifm-h2-vertical-rhythm-top)*var(--ifm-leading))}.markdown>h4,.markdown>h5,.markdown>h6{margin-top:calc(var(--ifm-heading-vertical-rhythm-top)*var(--ifm-leading))}.codeBlockContainer_K1bP,.markdown>p,.markdown>pre,.markdown>ul{margin-bottom:var(--ifm-leading)}.markdown li>p{margin-top:var(--ifm-list-paragraph-margin)}.markdown li+li{margin-top:var(--ifm-list-item-margin)}ol,ul{margin:0 0 var(--ifm-list-margin);padding-left:var(--ifm-list-left-padding)}ol ol,ul ol{list-style-type:lower-roman}ol ol ol,ol ul ol,ul ol ol,ul ul ol{list-style-type:lower-alpha}table{margin-bottom:var(--ifm-spacing-vertical);width:100%;display:table}.avatar__photo,.card,.text--truncate,hr{overflow:hidden}table thead tr{border-bottom:2px solid var(--ifm-table-border-color)}table tr{background-color:var(--ifm-table-background);border-top:var(--ifm-table-border-width) solid var(--ifm-table-border-color)}table tr:nth-child(2n){background-color:var(--ifm-table-stripe-background)}table td,table th{border:var(--ifm-table-border-width) solid var(--ifm-table-border-color);padding:var(--ifm-table-cell-padding)}table th{background-color:var(--ifm-table-head-background);color:var(--ifm-table-head-color);font-weight:var(--ifm-table-head-font-weight)}table td{color:var(--ifm-table-cell-color)}strong{font-weight:var(--ifm-font-weight-bold)}a{color:var(--ifm-link-color);text-decoration:var(--ifm-link-decoration);transition:color var(--ifm-transition-fast) var(--ifm-transition-timing-default)}a:hover{color:var(--ifm-link-hover-color);text-decoration:var(--ifm-link-hover-decoration)}.breadcrumbs__link:hover,.button:hover,.text--no-decoration,.text--no-decoration:hover,a:not([href]){text-decoration:none}p{margin:0 0 var(--ifm-paragraph-margin-bottom)}blockquote{border-left:6px solid var(--ifm-color-emphasis-300);color:var(--ifm-blockquote-color);font-size:var(--ifm-blockquote-font-size);padding:var(--ifm-blockquote-padding-vertical) var(--ifm-blockquote-padding-horizontal)}blockquote>:first-child{margin-top:0}hr{border:var(--ifm-hr-border-width) solid var(--ifm-hr-border-color);margin:var(--ifm-hr-margin-vertical) 0}.shadow--lw{box-shadow:var(--ifm-global-shadow-lw)!important}.shadow--md{box-shadow:var(--ifm-global-shadow-md)!important}.shadow--tl{box-shadow:var(--ifm-global-shadow-tl)!important}.text--primary{color:var(--ifm-color-primary)}.text--secondary{color:var(--ifm-color-secondary)}.text--success{color:var(--ifm-color-success)}.text--info{color:var(--ifm-color-info)}.text--warning{color:var(--ifm-color-warning)}.text--danger{color:var(--ifm-color-danger)}.text--center{text-align:center}.installationChecks_utNn>div:last-child,.markdown table>thead>tr>th:not([align]),.text--left{text-align:left}.text--justify{text-align:justify}.text--right{text-align:right}.text--capitalize{text-transform:capitalize}.text--lowercase{text-transform:lowercase}.indexAnnouncement_3fuK span,.jump-to span.badge.badge--category,.menu .menu__list-title,.table-of-contents .title,.text--upcase,.text--uppercase{text-transform:uppercase}.text--light{font-weight:var(--ifm-font-weight-light)}.text--normal{font-weight:var(--ifm-font-weight-normal)}.text--semibold{font-weight:var(--ifm-font-weight-semibold)}.text--bold{font-weight:var(--ifm-font-weight-bold)}.text--italic{font-style:italic}.text--break{word-wrap:break-word!important;word-break:break-word!important}.clean-btn{background:none;border:none;color:inherit;padding:0}.alert,.alert a{color:var(--ifm-alert-color)}.alert{background-color:var(--ifm-alert-background-color);border:var(--ifm-alert-border-width) solid var(--ifm-alert-border-color);border-radius:var(--ifm-alert-border-radius);padding:var(--ifm-alert-padding-vertical) var(--ifm-alert-padding-horizontal)}.alert--primary{--ifm-alert-background-color:var(--ifm-color-primary);--ifm-alert-border-color:var(--ifm-color-primary)}.alert--secondary{--ifm-alert-background-color:var(--ifm-color-secondary);--ifm-alert-border-color:var(--ifm-color-secondary);--ifm-alert-color:var(--ifm-color-gray-900)}.alert--success{--ifm-alert-background-color:var(--ifm-color-success);--ifm-alert-border-color:var(--ifm-color-success)}.alert--info{--ifm-alert-background-color:var(--ifm-color-info);--ifm-alert-border-color:var(--ifm-color-info)}.alert--warning{--ifm-alert-background-color:var(--ifm-color-warning);--ifm-alert-border-color:var(--ifm-color-warning)}.alert--danger{--ifm-alert-background-color:var(--ifm-color-danger);--ifm-alert-border-color:var(--ifm-color-danger)}.alert a{text-decoration:underline}.alert .close{margin:calc(var(--ifm-alert-padding-vertical)*-1) calc(var(--ifm-alert-padding-horizontal)*-1) 0 0}.avatar,.navbar,.navbar>.container,.navbar>.container-fluid{display:flex}.avatar__photo-link{display:block}.avatar__photo{border-radius:50%;height:var(--ifm-avatar-photo-size-md);width:var(--ifm-avatar-photo-size-md)}.avatar__photo--sm{height:var(--ifm-avatar-photo-size-sm);width:var(--ifm-avatar-photo-size-sm)}.avatar__photo--lg{height:var(--ifm-avatar-photo-size-lg);width:var(--ifm-avatar-photo-size-lg)}.avatar__photo--xl{height:var(--ifm-avatar-photo-size-xl);width:var(--ifm-avatar-photo-size-xl)}.avatar__photo+.avatar__intro{margin-left:var(--ifm-avatar-intro-margin)}.avatar__intro{display:flex;flex:1 1;flex-direction:column;justify-content:center;text-align:var(--ifm-avatar-intro-alignment)}.badge,.breadcrumbs__item,.breadcrumbs__link,.button,.dropdown>.navbar__link:after,.menu__link--sublist:after{display:inline-block}.avatar__name{font:700 var(--ifm-h4-font-size)/var(--ifm-heading-line-height) var(--ifm-font-family-base)}.avatar__subtitle{margin-top:.25rem}.avatar--vertical{--ifm-avatar-intro-alignment:center;--ifm-avatar-intro-margin:0.5rem;align-items:center;flex-direction:column}.avatar--vertical .avatar__intro{margin-left:0}.badge{background-color:var(--ifm-badge-background-color);border:var(--ifm-badge-border-width) solid var(--ifm-badge-border-color);border-radius:var(--ifm-badge-border-radius);color:var(--ifm-badge-color);font-size:75%;font-weight:var(--ifm-font-weight-bold);line-height:1;padding:var(--ifm-badge-padding-vertical) var(--ifm-badge-padding-horizontal)}.badge--primary{--ifm-badge-background-color:var(--ifm-color-primary)}.badge--secondary{--ifm-badge-background-color:var(--ifm-color-secondary);color:var(--ifm-color-black)}.badge--success{--ifm-badge-background-color:var(--ifm-color-success)}.badge--info{--ifm-badge-background-color:var(--ifm-color-info)}.badge--warning{--ifm-badge-background-color:var(--ifm-color-warning)}.badge--danger{--ifm-badge-background-color:var(--ifm-color-danger)}.breadcrumbs{margin-bottom:0;padding-left:0}.breadcrumbs__item:not(:first-child){margin-left:var(--ifm-breadcrumb-spacing)}.breadcrumbs__item:not(:last-child){margin-right:var(--ifm-breadcrumb-spacing)}.breadcrumbs__item:not(:last-child):after{background:var(--ifm-breadcrumb-separator) center;content:" ";display:inline-block;-webkit-filter:var(--ifm-breadcrumb-separator-filter);filter:var(--ifm-breadcrumb-separator-filter);height:calc(var(--ifm-breadcrumb-separator-size)*var(--ifm-breadcrumb-size-multiplier)*var(--ifm-breadcrumb-separator-size-multiplier));margin:0 .5rem;opacity:.5;width:calc(var(--ifm-breadcrumb-separator-size)*var(--ifm-breadcrumb-size-multiplier)*var(--ifm-breadcrumb-separator-size-multiplier))}.breadcrumbs__item--active .breadcrumbs__link{color:var(--ifm-breadcrumb-color-active)}.breadcrumbs__item--active .breadcrumbs__link,.breadcrumbs__item:not(.breadcrumbs__item--active):hover .breadcrumbs__link{background:var(--ifm-breadcrumb-item-background-active)}.breadcrumbs__link{border-radius:var(--ifm-breadcrumb-border-radius);color:var(--ifm-font-color-base);font-size:calc(1rem*var(--ifm-breadcrumb-size-multiplier));padding:calc(var(--ifm-breadcrumb-padding-vertical)*var(--ifm-breadcrumb-size-multiplier)) calc(var(--ifm-breadcrumb-padding-horizontal)*var(--ifm-breadcrumb-size-multiplier));transition-duration:var(--ifm-transition-fast);transition-property:background,color}.breadcrumbs--sm{--ifm-breadcrumb-size-multiplier:0.8}.breadcrumbs--lg{--ifm-breadcrumb-size-multiplier:1.2}.button{background-color:var(--ifm-button-background-color);border:var(--ifm-button-border-width) solid var(--ifm-button-border-color);border-radius:var(--ifm-button-border-radius);font-size:calc(.875rem*var(--ifm-button-size-multiplier));font-weight:var(--ifm-button-font-weight);line-height:1.5;padding:calc(var(--ifm-button-padding-vertical)*var(--ifm-button-size-multiplier)) calc(var(--ifm-button-padding-horizontal)*var(--ifm-button-size-multiplier));text-align:center;transition-duration:var(--ifm-button-transition-duration);transition-property:color,background,border-color;-webkit-user-select:none;-ms-user-select:none;user-select:none;white-space:nowrap}.DocSearch-Button,.DocSearch-Help{-webkit-user-select:none;-ms-user-select:none}.button,.button:hover{color:var(--ifm-button-color)}.button--outline{--ifm-button-color:var(--ifm-button-border-color)}.button--outline:hover{--ifm-button-background-color:var(--ifm-button-border-color)}.button--link{--ifm-button-border-color:transparent;color:var(--ifm-link-color);text-decoration:var(--ifm-link-decoration)}.button--link.button--active,.button--link:active,.button--link:hover{color:var(--ifm-link-hover-color);text-decoration:var(--ifm-link-hover-decoration)}.button.disabled,.button:disabled,.button[disabled]{opacity:.65;pointer-events:none}.button--sm{--ifm-button-size-multiplier:0.8}.button--lg,.input--lg{--ifm-button-size-multiplier:1.35}.button--block{display:block;width:100%}.button.button--secondary{color:var(--ifm-color-gray-900)}.button.button--secondary.button--outline:not(.button--active):not(:hover),.sidebarItemLink_1RT6{color:var(--ifm-font-color-base)}.button--primary{--ifm-button-border-color:var(--ifm-color-primary)}.button--primary:not(.button--outline){--ifm-button-background-color:var(--ifm-color-primary)}.button--primary:not(.button--outline):hover{--ifm-button-background-color:var(--ifm-color-primary-dark);--ifm-button-border-color:var(--ifm-color-primary-dark)}.button--primary.button--active,.button--primary:active{--ifm-button-border-color:var(--ifm-color-primary-darker);--ifm-button-background-color:var(--ifm-color-primary-darker);background-color:var(
        --ifm-color-primary-darker
      );border-color:var(
        --ifm-color-primary-darker
      )}.button--secondary{--ifm-button-border-color:var(--ifm-color-secondary)}.button--secondary:not(.button--outline){--ifm-button-background-color:var(--ifm-color-secondary)}.button--secondary:not(.button--outline):hover{--ifm-button-background-color:var(--ifm-color-secondary-dark);--ifm-button-border-color:var(--ifm-color-secondary-dark)}.button--secondary.button--active,.button--secondary:active{--ifm-button-border-color:var(--ifm-color-secondary-darker);--ifm-button-background-color:var(--ifm-color-secondary-darker);background-color:var(
        --ifm-color-secondary-darker
      );border-color:var(
        --ifm-color-secondary-darker
      )}.button--success{--ifm-button-border-color:var(--ifm-color-success)}.button--success:not(.button--outline){--ifm-button-background-color:var(--ifm-color-success)}.button--success:not(.button--outline):hover{--ifm-button-background-color:var(--ifm-color-success-dark);--ifm-button-border-color:var(--ifm-color-success-dark)}.button--success.button--active,.button--success:active{--ifm-button-border-color:var(--ifm-color-success-darker);--ifm-button-background-color:var(--ifm-color-success-darker);background-color:var(
        --ifm-color-success-darker
      );border-color:var(
        --ifm-color-success-darker
      )}.button--info{--ifm-button-border-color:var(--ifm-color-info)}.button--info:not(.button--outline){--ifm-button-background-color:var(--ifm-color-info)}.button--info:not(.button--outline):hover{--ifm-button-background-color:var(--ifm-color-info-dark);--ifm-button-border-color:var(--ifm-color-info-dark)}.button--info.button--active,.button--info:active{--ifm-button-border-color:var(--ifm-color-info-darker);--ifm-button-background-color:var(--ifm-color-info-darker);background-color:var(
        --ifm-color-info-darker
      );border-color:var(
        --ifm-color-info-darker
      )}.button--warning{--ifm-button-border-color:var(--ifm-color-warning)}.button--warning:not(.button--outline){--ifm-button-background-color:var(--ifm-color-warning)}.button--warning:not(.button--outline):hover{--ifm-button-background-color:var(--ifm-color-warning-dark);--ifm-button-border-color:var(--ifm-color-warning-dark)}.button--warning.button--active,.button--warning:active{--ifm-button-border-color:var(--ifm-color-warning-darker);--ifm-button-background-color:var(--ifm-color-warning-darker);background-color:var(
        --ifm-color-warning-darker
      );border-color:var(
        --ifm-color-warning-darker
      )}.button--danger{--ifm-button-border-color:var(--ifm-color-danger)}.button--danger:not(.button--outline){--ifm-button-background-color:var(--ifm-color-danger)}.button--danger:not(.button--outline):hover{--ifm-button-background-color:var(--ifm-color-danger-dark);--ifm-button-border-color:var(--ifm-color-danger-dark)}.button--danger.button--active,.button--danger:active{--ifm-button-border-color:var(--ifm-color-danger-darker);--ifm-button-background-color:var(--ifm-color-danger-darker);background-color:var(
        --ifm-color-danger-darker
      );border-color:var(
        --ifm-color-danger-darker
      )}.button-group{display:inline-flex}.button-group>.button:not(:first-child){border-bottom-left-radius:0;border-top-left-radius:0;margin-left:var(--ifm-button-group-margin)}.button-group>.button:not(:last-child){border-bottom-right-radius:0;border-top-right-radius:0}.button-group>.button--active{z-index:1}.button-group--block{display:flex;justify-content:stretch}.button-group--block>.button{flex-grow:1}.card{background-color:var(--ifm-card-background-color);border-radius:var(--ifm-card-border-radius);box-shadow:var(--ifm-global-shadow-lw);display:flex;flex-direction:column}.card--full-height{height:100%}.card__image{padding-top:var(--ifm-card-vertical-spacing)}.card__image:first-child{padding-top:0}.card__body,.card__footer,.card__header{padding:var(--ifm-card-vertical-spacing) var(--ifm-card-horizontal-spacing)}.card__body:not(:last-child),.card__footer:not(:last-child),.card__header:not(:last-child),.section-list>.section:last-child{padding-bottom:0}.alert>:last-child,.alert>ul:last-child>li:last-child,.card__body>:last-child,.card__footer>:last-child,.card__header>:last-child,.table-of-contents ul.contents>li>ul>li:last-child{margin-bottom:0}.card__footer{margin-top:auto}.table-of-contents{margin-bottom:0;padding:var(--ifm-toc-padding-vertical) 0}.table-of-contents,.table-of-contents ul{list-style-type:none;padding-left:var(--ifm-toc-padding-horizontal)}.table-of-contents li{margin:var(--ifm-toc-padding-vertical) var(--ifm-toc-padding-horizontal)}.table-of-contents__left-border{border-left:1px solid var(--ifm-toc-border-color)}.table-of-contents__link{color:var(--ifm-toc-link-color)}.table-of-contents__link--active,.table-of-contents__link--active code,.table-of-contents__link:hover,.table-of-contents__link:hover code{color:var(--ifm-color-primary);text-decoration:none}.close{background:none;border:none;color:var(--ifm-color-black);float:right;font-size:1.5rem;font-weight:var(--ifm-font-weight-bold);line-height:1;opacity:.5;padding:1rem;transition:opacity var(--ifm-transition-fast) var(--ifm-transition-timing-default)}.dropdown__menu,.menu__link,.menu__link:hover{transition-timing-function:var(--ifm-transition-timing-default)}.dropdown__menu,.menu__link,.menu__link:hover,input[type=checkbox]{transition-duration:var(--ifm-transition-fast)}.close:hover{opacity:.7}.close:focus{opacity:.8}.dropdown{display:inline-flex;font-weight:var(--ifm-dropdown-font-weight);position:relative;vertical-align:top}.dropdown--hoverable:hover .dropdown__menu,.dropdown--show .dropdown__menu{opacity:1;-webkit-transform:translateY(0);transform:translateY(0);visibility:visible}.awssld__next,.dropdown--right .dropdown__menu{right:0}.dropdown--nocaret .navbar__link:after{content:none!important}.dropdown__menu{background-color:var(--ifm-dropdown-background-color);border-radius:var(--ifm-global-radius);box-shadow:var(--ifm-global-shadow-md);list-style:none;max-height:calc(100vh - var(--ifm-navbar-height));min-width:10rem;opacity:0;overflow-y:auto;padding:.5rem;position:absolute;top:100%;-webkit-transform:translateY(-10px);transform:translateY(-10px);transition-property:opacity,transform,visibility,-webkit-transform;visibility:hidden;z-index:var(--ifm-z-index-dropdown)}.menu__list-item--collapsed .menu__list,.navbar__title{overflow:hidden}.dropdown__link{border-radius:.25rem;color:var(--ifm-dropdown-link-color);display:block;font-size:.875rem;margin-top:.2rem;padding:.25rem .5rem;white-space:nowrap}.dropdown__link--active,.dropdown__link:hover{background-color:var(--ifm-dropdown-hover-background-color);color:var(--ifm-dropdown-link-color);text-decoration:none}.dropdown__link--active,.dropdown__link--active:hover{--ifm-dropdown-link-color:var(--ifm-link-color)}.dropdown>.navbar__link:after{border-color:currentcolor transparent;border-style:solid;border-width:.4em .4em 0;content:"";margin-left:.3em;position:relative;top:2px;-webkit-transform:translateY(-50%);transform:translateY(-50%)}.footer{background-color:var(--ifm-footer-background-color);color:var(--ifm-footer-color);padding:var(--ifm-footer-padding-vertical) var(--ifm-footer-padding-horizontal)}.footer__items,.menu__list{padding-left:0;list-style-type:none}.footer--dark{--ifm-footer-background-color:#303846;--ifm-footer-color:var(--ifm-footer-link-color);--ifm-footer-link-color:var(--ifm-color-secondary);--ifm-footer-title-color:var(--ifm-color-white)}.footer__links{margin-bottom:1rem}.footer__link-item{color:var(--ifm-footer-link-color);line-height:2}.footer__link-item:hover{color:var(--ifm-footer-link-hover-color)}.footer__link-separator{margin:0 var(--ifm-footer-link-horizontal-spacing)}.footer__logo{margin-top:1rem;max-width:10rem}.docItemContainer_33ec header+*,.footer__item,.menu>ul.menu__list>li.menu__list-item:first-child div.title,.pills__item+.pills__item,li+li{margin-top:0}.footer__title{color:var(--ifm-footer-title-color);font:700 var(--ifm-h4-font-size)/var(--ifm-heading-line-height) var(--ifm-font-family-base);margin-bottom:var(--ifm-heading-margin-bottom)}.footer__items{margin-bottom:0}[type=checkbox]{padding:0}.hero{background-color:var(--ifm-hero-background-color);color:var(--ifm-hero-text-color)}.hero--primary{--ifm-hero-background-color:var(--ifm-color-primary);--ifm-hero-text-color:var(--ifm-font-color-base-inverse)}.hero--dark{--ifm-hero-background-color:#303846;--ifm-hero-text-color:var(--ifm-color-white)}.blogPostTitle_GeHD,.hero__title{font-size:3rem}.hero__subtitle{font-size:1.5rem}.menu{font-weight:var(--ifm-font-weight-semibold);overflow-x:hidden}.menu__list{margin:0}.menu__list .menu__list{margin-left:var(--ifm-menu-link-padding-horizontal)}.menu__list-item{margin-top:.25rem}.menu__list-item--collapsed .menu__link--sublist:after{-webkit-transform:rotate(90deg);transform:rotate(90deg)}.menu__link{border-radius:.25rem;display:flex;justify-content:space-between;line-height:1.25;padding:var(--ifm-menu-link-padding-vertical) var(--ifm-menu-link-padding-horizontal);position:relative}.menu__link,.menu__link:hover{color:var(--ifm-menu-color);transition-property:color,background}.navbar-sidebar,.navbar-sidebar__backdrop{bottom:0;opacity:0;transition-timing-function:ease-in-out;top:0;left:0}.menu__link:hover{background:var(--ifm-menu-color-background-hover);text-decoration:none}.menu__link--sublist:after{background:var(--ifm-menu-link-sublist-icon) 50%/2rem 2rem;content:" ";-webkit-filter:var(--ifm-menu-link-sublist-icon-filter);filter:var(--ifm-menu-link-sublist-icon-filter);height:1.25rem;min-width:1.25rem;-webkit-transform:rotate(180deg);transform:rotate(180deg);transition:-webkit-transform var(--ifm-transition-fast) linear;transition:transform var(--ifm-transition-fast) linear;transition:transform var(--ifm-transition-fast) linear,-webkit-transform var(--ifm-transition-fast) linear}.menu__link--active,.menu__link--active:hover{color:var(--ifm-menu-color-active)}.navbar__brand,.navbar__link{color:var(--ifm-navbar-link-color)}.menu__link--active:not(.menu__link--sublist){background:var(--ifm-menu-color-background-active)}.menu--responsive .menu__button{bottom:2rem;display:none;position:fixed;right:1rem;z-index:var(--ifm-z-index-fixed)}.menu--show{-ms-scroll-chaining:none;background:var(--ifm-background-surface-color);bottom:0;left:0;overscroll-behavior:contain;padding:1rem;position:fixed;right:0;top:0;z-index:var(--ifm-z-index-overlay)}.menu--show .menu__list{display:inherit;opacity:1;transition:opacity var(--ifm-transition-fast) linear}.navbar--dark,html[data-theme=dark]{--ifm-menu-link-sublist-icon-filter:invert(100%) sepia(94%) saturate(17%) hue-rotate(223deg) brightness(104%) contrast(98%)}.navbar{background-color:var(--ifm-navbar-background-color);box-shadow:var(--ifm-navbar-shadow);height:var(--ifm-navbar-height);padding:var(--ifm-navbar-padding-vertical) var(--ifm-navbar-padding-horizontal);width:100%}.navbar--fixed-top{position:-webkit-sticky;position:sticky;top:0;z-index:var(--ifm-z-index-fixed)}.navbar__inner{align-items:stretch;display:flex;flex-wrap:wrap;justify-content:space-between;width:100%}.navbar__brand{align-items:center;display:flex;font-weight:700;height:2rem;margin-right:1rem;min-width:0}.navbar__brand:hover{color:inherit;text-decoration:none}.navbar__title{flex:1 1 auto}.table-responsive,.tabs{overflow-x:auto}.navbar__toggle{display:none;margin-right:.5rem}.navbar__logo{height:100%;margin-right:.5rem}.navbar__items{align-items:center;display:flex;flex:1;min-width:0}.navbar__items--center{flex:0 0 auto}.navbar__items--center .navbar__brand{margin:0}.navbar__items--center+.navbar__items--right{flex:1}.navbar__items--right{flex:0 0 auto;justify-content:flex-end}.markdown table>tbody>tr>td:last-child,.markdown table>thead>tr>th:last-child,.navbar__items--right>:last-child{padding-right:0}.navbar__item{display:inline-block;padding:var(--ifm-navbar-item-padding-vertical) var(--ifm-navbar-item-padding-horizontal)}.codeBlock_23N8,.navbar__item.dropdown{padding:0}#nprogress,.navbar__item.dropdown .navbar__link:not([href]){pointer-events:none}.navbar__link{font-weight:var(--ifm-font-weight-semibold);padding:var(--ifm-navbar-item-padding-vertical) var(--ifm-navbar-item-padding-horizontal);position:relative;text-decoration:none}.navbar__link--active,.navbar__link:hover{color:var(--ifm-navbar-link-hover-color);text-decoration:none}.navbar--dark{--ifm-navbar-background-color:#242526;--ifm-navbar-link-color:var(--ifm-color-gray-100);--ifm-navbar-search-input-color:var(--ifm-color-white);--ifm-menu-color:var(--ifm-color-gray-300);--ifm-navbar-toggle-color:var(--ifm-color-white)}.navbar--dark .navbar__toggle{color:var(--ifm-color-white)}.navbar--primary{--ifm-navbar-background-color:var(--ifm-color-primary);--ifm-navbar-link-hover-color:var(--ifm-color-white);--ifm-navbar-search-input-color:var(--ifm-color-emphasis-500)}.navbar__search-input{-webkit-appearance:none;appearance:none;background:var(--ifm-navbar-search-input-background-color) var(--ifm-navbar-search-input-icon) no-repeat .75rem center/1rem 1rem;border:none;border-radius:2rem;color:var(--ifm-navbar-search-input-color);cursor:text;display:inline-block;font-size:.9rem;height:2rem;padding:0 .5rem 0 2.25rem;width:12.5rem}.navbar__search-input:-ms-input-placeholder{color:var(--ifm-navbar-search-input-placeholder-color)}.navbar__search-input::-webkit-input-placeholder{color:var(--ifm-navbar-search-input-placeholder-color)}.navbar__search-input::placeholder{color:var(--ifm-navbar-search-input-placeholder-color)}.navbar-sidebar{background-color:var(--ifm-navbar-background-color);box-shadow:var(--ifm-global-shadow-md);overflow:auto;position:fixed;-webkit-transform:translate3d(-100%,0,0);transform:translate3d(-100%,0,0);transition-duration:.25s;transition-property:opacity,visibility,transform,-webkit-transform;visibility:hidden;width:var(--ifm-navbar-sidebar-width)}.navbar-sidebar--show .navbar-sidebar,.navbar-sidebar--show .navbar-sidebar__backdrop{opacity:1;visibility:visible}.awssld--first .awssld__prev,.awssld--last .awssld__next,.awssld__box{visibility:hidden}.navbar-sidebar--show .navbar-sidebar{-webkit-transform:translateZ(0);transform:translateZ(0)}.navbar-sidebar__backdrop{background-color:rgba(0,0,0,.6);position:fixed;right:0;transition-duration:.1s;transition-property:opacity,visibility;visibility:hidden}.navbar-sidebar__brand{align-items:center;box-shadow:var(--ifm-navbar-shadow);display:flex;flex:1;height:var(--ifm-navbar-height);padding:var(--ifm-navbar-padding-vertical) var(--ifm-navbar-padding-horizontal)}.pagination__item,.pagination__link{display:inline-block}.navbar-sidebar__items{padding:.5rem}.pagination{font-size:var(--ifm-pagination-font-size);padding-left:0}.pagination--sm{--ifm-pagination-font-size:0.8rem;--ifm-pagination-padding-horizontal:0.8rem;--ifm-pagination-padding-vertical:0.2rem}.pagination--lg{--ifm-pagination-font-size:1.2rem;--ifm-pagination-padding-horizontal:1.2rem;--ifm-pagination-padding-vertical:0.3rem}.pagination__item:not(:first-child){margin-left:var(--ifm-pagination-page-spacing)}.pagination__item:not(:last-child){margin-right:var(--ifm-pagination-page-spacing)}.pagination__item>span{padding:var(--ifm-pagination-padding-vertical)}.pagination__item--active .pagination__link{color:var(--ifm-pagination-color-active)}.hero .hero--subtitle a:hover,.link:not(.badge){color:var(--ifm-link-color)}.pagination__item--active .pagination__link,.pagination__item:not(.pagination__item--active):hover .pagination__link{background:var(--ifm-pagination-item-active-background)}.pagination__item--disabled,.pagination__item[disabled]{opacity:.25;pointer-events:none}.pagination__link{border-radius:var(--ifm-pagination-border-radius);color:var(--ifm-font-color-base);padding:var(--ifm-pagination-padding-vertical) var(--ifm-pagination-padding-horizontal);transition:background var(--ifm-transition-fast) var(--ifm-transition-timing-default)}.pagination__link:hover{text-decoration:none}.pagination-nav{display:flex}.pagination-nav__item{display:flex;flex:1 50%;max-width:50%}.installationChecks_utNn>div:first-child,.pagination-nav__item--next{text-align:right}.empty,.hero,table.comparison tr td{text-align:center}.pagination-nav__item+.pagination-nav__item{margin-left:var(--ifm-spacing-horizontal)}.pagination-nav__link{border:1px solid var(--ifm-color-emphasis-300);border-radius:var(--ifm-pagination-nav-border-radius);flex-grow:1;line-height:var(--ifm-heading-line-height);padding:var(--ifm-global-spacing);transition:border-color var(--ifm-transition-fast) var(--ifm-transition-timing-default)}.pagination-nav__link:hover{border-color:var(--ifm-pagination-nav-color-hover);text-decoration:none}.hero .hero--subtitle a,.link:hover,table.comparison [title]{text-decoration:underline}.pagination-nav__label{font-size:var(--ifm-h4-font-size);font-weight:var(--ifm-heading-font-weight);word-break:break-word}.pagination-nav__sublabel{color:var(--ifm-color-content-secondary);font-size:var(--ifm-h5-font-size);font-weight:var(--ifm-font-weight-semibold);margin-bottom:.25rem}.pills,.tabs{font-weight:var(--ifm-font-weight-bold)}.pills{padding-left:0}.pills__item{border-radius:.5rem;cursor:pointer;display:inline-block;list-style-type:none;padding:.25rem 1rem;transition:background var(--ifm-transition-fast) var(--ifm-transition-timing-default)}.pills__item--active{background:var(--ifm-pills-color-background-active);color:var(--ifm-pills-color-active)}.pills__item:not(.pills__item--active):hover{background-color:var(--ifm-pills-color-background-active)}.react-select-container .react-select__option:hover,table.comparison tr td.result.passed.vector,ul.tabs.rounded li.tab-item.tab-item--active{background:var(--ifm-color-primary);color:var(--ifm-background-color)}.pills__item:not(:first-child){margin-left:var(--ifm-pills-spacing)}.pills__item:not(:last-child){margin-right:var(--ifm-pills-spacing)}.pills--block{display:flex;justify-content:stretch}.pills--block .pills__item{flex-grow:1;text-align:center}.tabs{color:var(--ifm-tabs-color);display:flex;margin-bottom:0;padding-left:0}.tabs__item{border-bottom:3px solid transparent;border-radius:var(--ifm-global-radius);cursor:pointer;display:inline-flex;margin:0;padding:var(--ifm-tabs-padding-vertical) var(--ifm-tabs-padding-horizontal);transition:background-color var(--ifm-transition-fast) var(--ifm-transition-timing-default)}.DocSearch-Container,.DocSearch-Container *,.badge,.container--narrow,input[type=email],input[type=text]{box-sizing:border-box}.tabs__item--active{border-bottom-color:var(--ifm-tabs-color-active);border-bottom-left-radius:0;border-bottom-right-radius:0;color:var(--ifm-tabs-color-active)}.tabs__item:hover{background-color:var(--ifm-hover-overlay)}.tabs--block{justify-content:stretch}.tabs--block .tabs__item{flex-grow:1;justify-content:center}html[data-theme=dark]{--ifm-color-emphasis-0:var(--ifm-color-gray-1000);--ifm-color-emphasis-100:var(--ifm-color-gray-900);--ifm-color-emphasis-200:var(--ifm-color-gray-800);--ifm-color-emphasis-300:var(--ifm-color-gray-700);--ifm-color-emphasis-400:var(--ifm-color-gray-600);--ifm-color-emphasis-600:var(--ifm-color-gray-400);--ifm-color-emphasis-700:var(--ifm-color-gray-300);--ifm-color-emphasis-800:var(--ifm-color-gray-200);--ifm-color-emphasis-900:var(--ifm-color-gray-100);--ifm-color-emphasis-1000:var(--ifm-color-gray-0);--ifm-background-color:#18191a;--ifm-background-surface-color:#242526;--ifm-hover-overlay:hsla(0,0%,100%,0.05);--ifm-color-content-secondary:#fff;--ifm-breadcrumb-separator-filter:invert(64%) sepia(11%) saturate(0%) hue-rotate(149deg) brightness(99%) contrast(95%);--ifm-code-background:hsla(0,0%,100%,0.1);--ifm-background-color:#191927;--ifm-background-color-rgb:25,25,39;--ifm-color-content-secondary:var(--ifm-color-emphasis-400);--ifm-color-emphasis-25:var(--ifm-color-gray-975);--ifm-color-emphasis-40:var(--ifm-color-gray-960);--ifm-color-emphasis-50:var(--ifm-color-gray-950);--ifm-color-emphasis-75:var(--ifm-color-gray-925);--ifm-color-gray-25:rgba(224,235,247,0.975);--ifm-color-gray-40:rgba(224,235,247,0.96);--ifm-color-gray-50:rgba(224,235,247,0.95);--ifm-color-gray-75:rgba(224,235,247,0.925);--ifm-color-gray-100:rgba(224,235,247,0.9);--ifm-color-gray-150:rgba(224,235,247,0.85);--ifm-color-gray-200:rgba(224,235,247,0.8);--ifm-color-gray-300:rgba(224,235,247,0.7);--ifm-color-gray-400:rgba(224,235,247,0.6);--ifm-color-gray-500:rgba(224,235,247,0.5);--ifm-color-gray-600:rgba(224,235,247,0.4);--ifm-color-gray-700:rgba(224,235,247,0.3);--ifm-color-gray-800:rgba(224,235,247,0.2);--ifm-color-gray-900:rgba(224,235,247,0.1);--ifm-color-gray-925:rgba(224,235,247,0.075);--ifm-color-gray-950:rgba(224,235,247,0.05);--ifm-color-gray-960:rgba(224,235,247,0.04);--ifm-color-gray-975:rgba(224,235,247,0.025);--ifm-color-gray-1000:#e0ebf7;--ifm-global-shadow-md:0 3px 8px 0px rgba(0,0,0,0.2);--ifm-heading-color:var(--ifm-color-gray-1000);--ifm-navbar-search-input-icon:url('data:image/svg+xml;utf8,<svg fill="rgb(224, 235, 247)" alt="Search" xmlns="http://www.w3.org/2000/svg" viewBox="0 0 16 16" height="16px" width="16px"><path d="M6.02945,10.20327a4.17382,4.17382,0,1,1,4.17382-4.17382A4.15609,4.15609,0,0,1,6.02945,10.20327Zm9.69195,4.2199L10.8989,9.59979A5.88021,5.88021,0,0,0,12.058,6.02856,6.00467,6.00467,0,1,0,9.59979,10.8989l4.82338,4.82338a.89729.89729,0,0,0,1.29912,0,.89749.89749,0,0,0-.00087-1.29909Z" /></svg>');--ifm-panel-background:var(--ifm-color-emphasis-50);--ifm-panel-background-rgb:37,37,50;--ifm-panel-background-solid:#252532;--ifm-panel-box-shadow:none;--ifm-panel-box-shadow-active:0 0px 10px 0px rgba(var(--ifm-color-primary-rgb),0.5);--docsearch-text-color:#f5f6f7;--docsearch-container-background:rgba(9,10,17,0.8);--docsearch-modal-background:#15172a;--docsearch-modal-shadow:inset 1px 1px 0 0 #2c2e40,0 3px 8px 0 #000309;--docsearch-searchbox-background:#090a11;--docsearch-searchbox-focus-background:#000;--docsearch-hit-color:#bec3c9;--docsearch-hit-shadow:none;--docsearch-hit-background:#090a11;--docsearch-key-gradient:linear-gradient(-26.5deg,#565872,#31355b);--docsearch-key-shadow:inset 0 -2px 0 0 #282d55,inset 0 0 1px 1px #51577d,0 2px 2px 0 rgba(3,4,9,0.3);--docsearch-footer-background:#1e2136;--docsearch-footer-shadow:inset 0 1px 0 0 rgba(73,76,106,0.5),0 -4px 8px 0 rgba(0,0,0,0.2);--docsearch-logo-color:#fff;--docsearch-muted-color:#7f8497}:root{--ifm-alert-color:var(--ifm-heading-color);--ifm-background-color:#fff;--ifm-background-color-rgb:255,255,255;--ifm-background-surface-color:var(--ifm-panel-background);--ifm-badge-border-radius:0.25em;--ifm-blockquote-color:var(--ifm-color-primary-lighter);--ifm-code-background:var(--ifm-color-emphasis-50);--ifm-code-font-size:85%;--ifm-color-black:#001b3d;--ifm-color-blue:#438fff;--ifm-color-blue-rgb:67,143,255;--ifm-color-content:var(--ifm-color-emphasis-800);--ifm-color-content-secondary:var(--ifm-color-emphasis-400);--ifm-color-danger:#ff1178;--ifm-color-danger-rgb:255,17,120;--ifm-color-gray-25:rgba(0,27,61,0.025);--ifm-color-gray-40:rgba(0,27,61,0.04);--ifm-color-gray-50:rgba(0,27,61,0.05);--ifm-color-gray-75:rgba(0,27,61,0.075);--ifm-color-gray-100:rgba(0,27,61,0.1);--ifm-color-gray-150:rgba(0,27,61,0.15);--ifm-color-gray-200:rgba(0,27,61,0.2);--ifm-color-gray-300:rgba(0,27,61,0.3);--ifm-color-gray-400:rgba(0,27,61,0.4);--ifm-color-gray-500:rgba(0,27,61,0.5);--ifm-color-gray-600:rgba(0,27,61,0.6);--ifm-color-gray-700:rgba(0,27,61,0.7);--ifm-color-gray-800:rgba(0,27,61,0.8);--ifm-color-gray-900:rgba(0,27,61,0.9);--ifm-color-emphasis-25:var(--ifm-color-gray-25);--ifm-color-emphasis-40:var(--ifm-color-gray-40);--ifm-color-emphasis-50:var(--ifm-color-gray-50);--ifm-color-emphasis-75:var(--ifm-color-gray-75);--ifm-color-pink:#f44af5;--ifm-color-pink-rgb:244,74,245;--ifm-color-primary:#5170a4;--ifm-color-primary-rgb:40,217,242;--ifm-color-primary-dark:#0fbce1;--ifm-color-primary-darker:#0395c7;--ifm-color-primary-darkest:#006ea6;--ifm-color-primary-light:#51ebfb;--ifm-color-primary-lighter:#6af0fd;--ifm-color-primary-lightest:#83f5ff;--ifm-color-secondary:var(--ifm-color-emphasis-100);--ifm-color-success:#00ff7f;--ifm-color-success-rgb:0,255,127;--ifm-color-warning-rgb:255,186,0;--ifm-contents-padding-left:var(--ifm-spacing-horizontal);--ifm-font-family-base:-apple-system,BlinkMacSystemFont,Roboto,sans-serif;--ifm-font-family-monospace:"Source Code Pro",Menlo,monospace;--ifm-font-size-base:16px;--ifm-footer-background-color:var(--ifm-background-color);--ifm-footer-padding-vertical:calc(var(--ifm-spacing-vertical)*4);--ifm-global-shadow-md:0 3px 8px 0px var(--ifm-hr-border-color);--ifm-h2-font-size:2em;--ifm-heading-color:#001b3d;--ifm-heading-font-family:Ubuntu,var(--ifm-font-family-base);--ifm-heading-margin-bottom:calc(var(--ifm-spacing-vertical)*3);--ifm-hero-background-color:var(--ifm-background-color);--ifm-hero-text-color:var(--ifm-color-content);--ifm-highlight-gradient:linear-gradient(150deg,var(--ifm-color-primary) 5%,var(--ifm-color-blue) 40%,var(--ifm-color-pink) 90%);--ifm-highlight-gradient-20:linear-gradient(150deg,var(--ifm-color-primary) 5%,var(--ifm-color-blue) 95%);--ifm-hr-border-color:var(--ifm-contents-border-color);--ifm-leading:calc(var(--ifm-leading-desktop)*1em);--ifm-line-height-base:1.7;--ifm-link-color:var(--ifm-color-primary-dark);--ifm-menu-color:var(--ifm-color-emphasis-600);--ifm-navbar-background-color:var(--ifm-background-color);--ifm-navbar-link-color:var(--ifm-heading-color);--ifm-panel-background:var(--ifm-background-color);--ifm-panel-background-rgb:249,249,250;--ifm-panel-background-solid:#f9f9fa;--ifm-panel-background-active:rgba(var(--ifm-color-primary-rgb),0.2);--ifm-panel-border-color:var(--ifm-hr-border-color);--ifm-panel-border-color-active:var(--ifm-color-primary);--ifm-panel-box-shadow:0 0px 10px 0px var(--ifm-color-emphasis-50);--ifm-panel-box-shadow-active:var(--ifm-panel-box-shadow);--ifm-panel-color:var(--ifm-color-emphasis-800);--ifm-panel-color-active:var(--ifm-link-color);--ifm-pre-line-height:var(--ifm-line-height-base);--ifm-sidebar-background:var(--ifm-background-color);--ifm-sidebar-border-color:var(--ifm-hr-border-color);--ifm-sidebar-width:250px;--ifm-table-stripe-background:var(--ifm-table-background);--docsearch-primary-color:#5468ff;--docsearch-text-color:#1c1e21;--docsearch-spacing:12px;--docsearch-icon-stroke-width:1.4;--docsearch-highlight-color:var(--docsearch-primary-color);--docsearch-muted-color:#969faf;--docsearch-container-background:rgba(101,108,133,0.8);--docsearch-logo-color:#5468ff;--docsearch-modal-width:560px;--docsearch-modal-height:600px;--docsearch-modal-background:#f5f6f7;--docsearch-modal-shadow:inset 1px 1px 0 0 hsla(0,0%,100%,0.5),0 3px 8px 0 #555a64;--docsearch-searchbox-height:56px;--docsearch-searchbox-background:#ebedf0;--docsearch-searchbox-focus-background:#fff;--docsearch-searchbox-shadow:inset 0 0 0 2px var(--docsearch-primary-color);--docsearch-hit-height:56px;--docsearch-hit-color:#444950;--docsearch-hit-active-color:#fff;--docsearch-hit-background:#fff;--docsearch-hit-shadow:0 1px 3px 0 #d4d9e1;--docsearch-key-gradient:linear-gradient(-225deg,#d5dbe4,#f8f8f8);--docsearch-key-shadow:inset 0 -2px 0 0 #cdcde6,inset 0 0 1px 1px #fff,0 1px 2px 1px rgba(30,35,90,0.4);--docsearch-footer-height:44px;--docsearch-footer-background:#fff;--docsearch-footer-shadow:0 -1px 0 0 #e0e3e8,0 -3px 6px 0 rgba(69,98,155,0.12);--docsearch-primary-color:var(--ifm-color-primary);--docsearch-text-color:var(--ifm-font-color-base);--docusaurus-announcement-bar-height:auto;--collapse-button-bg-color-dark:#2e333a;--doc-sidebar-width:300px;--doc-sidebar-hidden-width:30px}@-webkit-keyframes a{0%,to{background-position:0 0}50%{background-position:100% 100%}}@keyframes a{0%,to{background-position:0 0}50%{background-position:100% 100%}}body,html{font-smoothing:antialiased;-ms-text-size-adjust:100%;-webkit-font-smoothing:antialiased;-moz-osx-font-smoothing:grayscale;height:100%}.componentsCanvas_2sJk circle,.componentsCanvas_2sJk text,.link{cursor:pointer}.DocSearch-Container a,.panel.panel--link:hover,.sidebarItemLink_1RT6:hover{text-decoration:none}a.text--warning:hover,table.comparison tr td.result.warning{color:var(--ifm-color-warning)}article header h1{font-size:2em}.badge{background-clip:padding-box;border-color:transparent}.badge.badge--blue{--ifm-badge-background-color:rgba(var(--ifm-color-blue-rgb),0.25);--ifm-badge-color:var(--ifm-color-blue)}.badge.badge--danger{--ifm-badge-background-color:rgba(var(--ifm-color-danger-rgb),0.2);--ifm-badge-color:var(--ifm-color-danger)}.badge.badge--highlight{-webkit-animation:5s ease-in infinite a;animation:5s ease-in infinite a;background-image:var(--ifm-highlight-gradient);background-size:150% 150%;color:var(--ifm-background-color)}.button.button--highlight,.input--highlight-wrapper{-webkit-animation:5s ease-in infinite a;background-image:var(--ifm-highlight-gradient);background-size:150% 150%}.badge.badge--pink{--ifm-badge-background-color:rgba(var(--ifm-color-pink-rgb),0.2);--ifm-badge-color:var(--ifm-color-pink)}.badge.badge--primary{--ifm-badge-background-color:rgba(var(--ifm-color-primary-rgb),0.2);--ifm-badge-color:var(--ifm-color-primary)}.badge.badge--rounded{border-radius:1em}.badge.badge--secondary{color:var(--ifm-color-emphasis-800)}.badge.badge--success{--ifm-badge-background-color:rgba(var(--ifm-color-success-rgb),0.5);--ifm-badge-color:var(--ifm-color-success)}.badge.badge--warning{--ifm-badge-background-color:rgba(var(--ifm-color-warning-rgb),0.2);--ifm-badge-color:var(--ifm-color-warning)}.badge a,.table-of-contents ul.contents code{color:inherit}a.badge:hover{color:var(--ifm-badge-color)}blockquote{border-left:4px solid var(--ifm-hr-border-color);color:var(--ifm-color-emphasis-400);padding:0 0 0 1.5rem}.button.button--primary{--ifm-button-color:var(--ifm-background-color)}.button.button--highlight{animation:5s ease-in infinite a;color:var(--ifm-background-color)}ul.checks{list-style:none}ul.checks li>i.feather:first-child{margin-left:-1.8em;margin-right:.5em}table.comparison{width:100%}table.comparison [title]{-webkit-text-decoration-style:dotted;text-decoration-style:dotted}table.comparison td,table.comparison th,table.comparison tr{border:0;white-space:nowrap}.sidebarItemLinkActive_12pM,table.comparison tr td.bar.vector,table.comparison tr td.result.passed,table.comparison tr th.vector,ul.tabs.mini li.tab-item.tab-item--active{color:var(--ifm-color-primary)}.empty,ul.tabs li.tab-item{color:var(--ifm-color-emphasis-400)}table.comparison tr td{border-left:10px solid var(--ifm-background-color);min-width:90px}table.comparison tr td:first-child{font-weight:700;padding-left:0;text-align:left;white-space:nowrap;width:25%}table.comparison tr td.description{font-weight:400;min-width:250px;padding-top:0;vertical-align:top;white-space:normal}table.comparison tr td.description .label{color:var(--ifm-heading-color);font-weight:700}table.comparison tr td.description .text{color:var(--ifm-color-emphasis-600)}table.comparison tr td.description .links{font-size:.9em;margin-top:var(--ifm-spacing-vertical)}.markdown table>tbody>tr:hover,table.comparison tr:hover td.result,table.comparison tr:hover td.row-label{background:var(--ifm-color-emphasis-25)}.table-of-contents ul.contents li a.text--danger,table.comparison tr td.result.failed{color:var(--ifm-color-danger)}table.comparison tr td.result.lost{background:var(--ifm-color-emphasis-1000);color:var(--ifm-background-color)}table.comparison tr td.result.not-applicable{background:var(--ifm-color-emphasis-1000);color:rgba(var(--ifm-background-color-rgb),.5)}table.comparison tr:hover td.result.passed.vector{background:rgba(var(--ifm-color-primary-rgb),.8)}table.comparison tr td.bar{padding:0;vertical-align:bottom}table.comparison tr td.bar .place{font-size:.9em}.sidebar .menu,table.comparison tr td.bar .measurement{font-weight:700}table.comparison tr td.bar .bar{background:var(--ifm-color-emphasis-1000);margin:0 auto}.indexAnnouncement_3fuK:hover span,table.comparison tr td.bar.vector .bar{background:var(--ifm-color-primary)}.container--narrow{max-width:760px}.container--bleed>.bleed,.container--bleed>section>.code-header,.container--bleed>section>p>img,.container--bleed>section>pre{left:calc(var(--ifm-container-width)/2*-1 - -380px + var(--ifm-spacing-vertical)*-1);max-width:none;position:relative;width:var(--ifm-container-width)}.domain-bg--hover:not(:hover),.domain-bg.domain-bg--networking,.domain-bg.domain-bg--sinks,.domain-bg.domain-bg--sources{background-image:none!important}.empty{padding:calc(var(--ifm-spacing-vertical)*3)}.empty .icon{font-size:4rem;font-weight:700;line-height:1}.feather{font-size:inherit!important}.filters{color:var(--ifm-menu-color);margin-bottom:var(--ifm-spacing-vertical)}.filters .search{margin-bottom:calc(var(--ifm-spacing-vertical)/2)}.filters .search--result-count{float:right;font-size:.9em;line-height:1;margin-bottom:-1em;margin-right:var(--ifm-spacing-horizontal);position:relative;top:.75em}.hero .hero--buttons,.hero .hero--subtitle,.panel,.section-list.section-list--compact>.section:last-child>h4{margin-bottom:var(--ifm-spacing-vertical)}.filters .search input{width:100%}.filters .filter{display:flex;font-size:.9em;overflow:auto;white-space:nowrap;width:100%}.filters .filter--label{border-right:1px solid var(--ifm-hr-border-color);flex:0 0 150px;min-width:120px;padding-right:1.2em;text-align:right}.filters .filter--label a{border-bottom:1px solid var(--ifm-hr-border-color);color:inherit}.filters .filter--choices{white-space:nowrap}.filters .filter--choices label{margin-left:.75em;margin-top:calc(var(--ifm-spacing-vertical)/4);white-space:nowrap}.filters .filter--choices label input{margin-right:.5em}.footer{--ifm-heading-margin-bottom:var(--ifm-spacing-vertical);border-top:1px solid var(--ifm-hr-border-color)}h2>.hash-link,h3>.hash-link,h4>.hash-link,h5>.hash-link,h6>.hash-link{margin-right:.25em;padding-left:.25em}header{border-bottom:2px solid var(--ifm-hr-border-color)}header .badges{float:right;font-family:monospace;margin-top:.5rem}header .badges .badge{margin-left:2px}header h1{font-family:Ubuntu,var(--ifm-font-family-base);margin-bottom:.5rem}.hero{align-items:center;display:block;min-height:200px;padding:3em 0;position:relative}.hero .hero--subtitle{font-size:1.1rem;margin-top:.3rem}.hero .hero--subtitle a{color:var(--ifm-color-content)}.hero .hero--subsubtitle{color:var(--ifm-hero-text-color);font-size:.9rem;margin-top:.3rem}.hero .hero--buttons{--ifm-button-padding-vertical:0.5rem;--ifm-button-padding-horizontal:4rem}.hero .hero--buttons .button{border-radius:2rem;margin-right:1rem;min-width:240px}.hero .hero--buttons .button:last-child{margin-right:0}.hero.hero--full-height{display:flex;flex-direction:column;justify-content:center;min-height:calc(100vh - var(--ifm-navbar-height))}input[type=checkbox]{-webkit-appearance:none;-o-appearance:none;appearance:none;background:var(--ifm-background-color);background-clip:padding-box;border:1px solid var(--ifm-color-emphasis-200);border-radius:4px;cursor:pointer;height:1rem;margin-bottom:.5rem;outline:0;vertical-align:middle;width:1rem}input[type=checkbox]:checked{background-color:var(--ifm-color-primary);border:1px solid var(--ifm-color-primary)}input[type=email],input[type=text]{border:1px solid var(--ifm-panel-border-color);border-radius:var(--ifm-global-radius);box-shadow:var(--ifm-panel-box-shadow);color:var(--ifm-font-base-color);display:inline-block;font-size:calc(.8rem*var(--ifm-button-size-multiplier));line-height:1.5;padding:calc(var(--ifm-button-padding-vertical)*var(--ifm-button-size-multiplier)) .8em;transition:var(--ifm-transition-slow) ease;vertical-align:middle}input[type=email]:focus,input[type=text]:focus{background:var(--ifm-panel-background-active);border-color:var(--ifm-color-primary);box-shadow:var(--ifm-panel-box-shadow-active)}.input--highlight-wrapper{animation:5s ease-in infinite a;border:0;font-weight:600;padding:1px}.label.label--warning{border-bottom:1px solid var(--ifm-color-warning);color:var(--ifm-color-warning);font-size:.8rem;padding-bottom:5px}div.list--warnings>ul,ul.list--warnings{list-style:none;margin-left:1em;padding-left:1em}div.list--warnings>ul>li:before,ul.list--warnings>li:before{content:"⚠";display:block;float:left;font-size:1.25em;font-weight:700;margin-left:-1.6em;margin-top:-.2em}div.list--warnings>ul>li,ul.list--warnings>li{margin:0 0 1em;padding:0}.menu>ul.menu__list li{margin-bottom:0;margin-top:0}.menu>ul.menu__list li>a{padding-left:0;padding-right:0}#docusaurus-base-url-issue-banner-container,.menu .menu__list-item-hidden,.navbar .search-icon-hidden{display:none}.menu>ul.menu__list>li.menu__list-item div.title{color:var(--ifm-color-emphasis-300);cursor:text;display:flex;font-size:.9rem;font-weight:700;justify-content:space-between;line-height:calc(var(--ifm-spacing-vertical)*1.25);margin-top:calc(var(--ifm-spacing-vertical)*1.5);padding:var(--ifm-menu-link-padding-vertical) 0;text-transform:uppercase}.menu>ul.menu__list ul.menu__list{border-left:1px solid var(--ifm-hr-border-color);margin-left:0;padding-left:var(--ifm-menu-link-padding-horizontal)}.menu>ul.menu__list ul.menu__list .menu__link{border-radius:0;font-size:.85rem;margin-left:calc(var(--ifm-menu-link-padding-horizontal)*-1);padding-left:var(--ifm-menu-link-padding-horizontal)}.menu>ul.menu__list>li>ul.menu__list{border-left:0;padding-left:0}.menu .menu__list-title{color:var(--ifm-color-emphasis-300);font-size:.9em}.panel,.react-select-container .react-select__single-value{color:var(--ifm-font-base-color)}.menu .menu__link,.menu .menu__link.menu__link--active:not(.menu__link--sublist),.menu .menu__link:hover{background:none;line-height:calc(var(--ifm-spacing-vertical)*1.25)}.menu .menu__link small{font-weight:400;opacity:.75}.menu .menu__link.menu__link--sublist:after{background-image:url('data:image/svg+xml;utf8,<svg alt="Arrow" xmlns="http://www.w3.org/2000/svg" width="14px" height="14px" viewBox="-6 -6 38 38"><path fill="rgba(0,0,0,0.3)" d="M7.41 15.41L12 10.83l4.59 4.58L18 14l-6-6-6 6z"></path></svg>');-webkit-transform:rotate(180deg);transform:rotate(180deg);transition:var(--ifm-transition-fast) ease}.menu .menu__link.menu__link--sublist.menu__link--active:after,.menu .menu__link.menu__link--sublist:hover:after{background-image:url('data:image/svg+xml;utf8,<svg alt="Arrow" xmlns="http://www.w3.org/2000/svg" width="14px" height="14px" viewBox="-6 -6 38 38"><path fill="#28d9f2" d="M7.41 15.41L12 10.83l4.59 4.58L18 14l-6-6-6 6z"></path></svg>')}.menu .menu__list-item.menu__list-item--collapsed .menu__link--sublist:after{-webkit-transform:rotate(90deg);transform:rotate(90deg)}.menu .menu__link:hover{color:var(--ifm-menu-color-active)}.menu .menu__link .badges{margin-top:-1px;vertical-align:top}.menu .menu__link .badges .badge{background-clip:padding-box;border:1px solid var(--ifm-color-emphasis-50);border-radius:.25em;display:inline-block;font-family:monospace;font-size:.5rem;font-weight:700;height:1rem;line-height:1rem;margin-right:2px;padding:0 .25rem;vertical-align:middle}.pagination-nav .pagination-nav__link,.panel,.section-list.section-list--hover>.section:hover,section.shade{background:var(--ifm-panel-background)}.menu.menu--responsive .menu__button{background:var(--ifm-panel-background-solid);border-color:var(--ifm-color-content-secondary);bottom:1rem;right:1rem}.navbar .navbar__brand{min-width:100px}.navbar .navbar__logo{margin-right:0;max-width:155px}.navbar .navbar__items--right{flex:0 0 40%}.navbar .navbar__items--right .react-toggle{margin-left:var(--ifm-navbar-item-padding-horizontal)}.navbar .navbar__item .badge{border-color:var(--ifm-background-color)!important;border-radius:1em;display:block;float:right;font-size:.6em;line-height:1;margin-left:-.5em;margin-right:-1.5em;margin-top:-.7em;padding:.3em .5em;position:relative;z-index:1}.panel.panel--link:hover,.react-select-container:hover .react-select__control{background:var(--ifm-panel-background-active);border-color:var(--ifm-panel-border-color-active);box-shadow:var(--ifm-panel-box-shadow-active)}.section-list>.section,.section-list>.section .info,section.shade{padding-left:var(--ifm-spacing-horizontal)}.navbar-sidebar__brand .navbar__brand{flex:1 0}.navbar-sidebar__brand .react-toggle{flex:0;text-align:right}.navbar-sidebar__items .menu .menu__link{color:var(--ifm-heading-color);display:block}.navbar-sidebar__items .menu .menu__link .badge{border-color:var(--ifm-background-color);border-radius:1em;font-size:.6em;margin-left:.25em;margin-top:-1em}.pagination-nav .pagination-nav__link{border-color:var(--ifm-panel-border-color);box-shadow:var(--ifm-panel-box-shadow);transition:border .25s}.pagination-nav .pagination-nav__link:hover{background:var(--ifm-panel-background-active);box-shadow:var(--ifm-panel-box-shadow-active);color:var(--ifm-panel-color-active)}.pagination-nav .pagination-nav__link:hover *{color:var(--ifm-panel-color-active)}.panel{border:1px solid var(--ifm-panel-border-color);border-radius:var(--ifm-global-radius);box-shadow:var(--ifm-panel-box-shadow);display:block;padding:calc(var(--ifm-spacing-vertical)*1.5) calc(var(--ifm-spacing-horizontal)*2)}.panel.panel--link{transition:var(--ifm-transition-fast) ease}.panel .panel--icon{font-size:4em;line-height:1;margin:0 0 var(--ifm-spacing-vertical) 0}.panel .panel--title{font-size:1.2em;font-weight:600}.panel .panel--description{font-size:.95em;opacity:.5}.press--color{background:#10e7ff;color:#000;padding:var(--ifm-spacing-vertical) var(--ifm-spacing-horizontal)}.react-select-container .react-select__control{background:var(--ifm-panel-background);border-color:var(--ifm-panel-border-color);border-radius:var(--ifm-global-radius);box-shadow:var(--ifm-panel-box-shadow);box-sizing:border-box;color:var(--ifm-font-base-color)}.react-select-container .react-select__indicator-separator{background-color:var(--ifm-color-emphasis-200)}.section-list,.section-list>.section .info,.table-of-contents ul.contents>li ul{border-left:1px solid var(--ifm-hr-border-color)}.react-select-container .react-select__menu{background:var(--ifm-panel-background-solid);border-radius:var(--ifm-global-radius);color:var(--ifm-color-content)}.react-select-container .react-select__option--is-selected{background:var(--ifm-panel-background-active)}.react-select-container .react-select__option--is-focused{background:var(--ifm-panel-background-active);color:var(--ifm-color-content)}section{border-bottom:1px solid var(--ifm-hr-border-color);padding-bottom:calc(var(--ifm-leading)*2 - var(--ifm-spacing-vertical))}section .sub-title{color:var(--ifm-color-emphasis-600);margin-bottom:var(--ifm-heading-margin-bottom);margin-top:calc(var(--ifm-heading-margin-bottom)*-1)}section.shade{padding-right:var(--ifm-spacing-horizontal)}.table-of-contents .section:last-child,section:last-child{border-bottom:0;margin-bottom:0}.table-of-contents .section,ul.tabs{border-bottom:1px solid var(--ifm-hr-border-color)}header+section.shade{margin-top:calc(var(--ifm-spacing-vertical)*2*-1 - -5px);padding-top:var(--ifm-spacing-vertical)}.section-list{margin-left:.25em}.section-list>.section{border-radius:5px;font-size:.95em;padding-bottom:calc(var(--ifm-spacing-vertical)/1.5)}.section-list>.section>.badges{float:right;margin-top:-.25em;text-align:right}.section-list>.section>.badges .badge{font-size:.7em;margin-left:3px}.section-list>.section>.badges .badge:first-child{margin-left:0}.section-list>.section>h3 .hash-link,.section-list>.section>h4 .hash-link,.section-list>.section>h5 .hash-link,.section-list>.section>h6 .hash-link{margin-left:calc(var(--ifm-spacing-horizontal)*-1.75 - var(--ifm-spacing-horizontal))!important;padding-right:3em}.section-list:not(.section-list--no-bullet)>.section>h3:before,.section-list:not(.section-list--no-bullet)>.section>h4:before,.section-list:not(.section-list--no-bullet)>.section>h5:before,.section-list:not(.section-list--no-bullet)>.section>h6:before,.section-list>.section .info>div:before,.section-list>.section>.section--bullet{content:"• ";display:block;float:left;margin-left:calc(var(--ifm-spacing-horizontal)*-2);text-align:center;width:calc(var(--ifm-spacing-horizontal)*2)}.codeBlockContent_hGly:hover>.copyButton_Ue-o,.codeBlockTitle_eoMF:hover+.codeBlockContent_hGly .copyButton_Ue-o,.copyButton_Ue-o:focus,.footerLogoLink_qW4Z:hover,.hash-link:focus,.section-list>.section:hover>h3>.hash-link,.section-list>.section:hover>h4>.hash-link,.section-list>.section:hover>h5>.hash-link,.section-list>.section:hover>h6>.hash-link,:hover>.hash-link{opacity:1}.section-list>.section>.sub__title{margin-bottom:.25em;margin-top:-.4em}.section-list>.section .info{color:var(--ifm-color-content-secondary);font-size:.9em;margin-bottom:calc(var(--ifm-spacing-vertical)/2);margin-left:.25em;margin-top:calc(var(--ifm-spacing-horizontal)*-1)}.section-list>.section .info .show-more{color:var(--ifm-color-primary);cursor:pointer}.section-list>.section .info .examples{margin-top:.5em}.section-list.section-list--lg>.section{margin-top:calc(var(--ifm-spacing-vertical)*2)}.section-list.section-list--compact>.section{padding-bottom:calc(var(--ifm-spacing-vertical)/4);padding-top:calc(var(--ifm-spacing-vertical)/4)}.section-list.section-list--compact>.section>h4{font-weight:400;margin:0}.sidebar{border-right:1px solid var(--ifm-sidebar-border-color)}.sidebar .menu .menu__link{border-right:2px solid transparent}.sidebar .menu .menu__link--active{border-radius:0;border-right-color:var(--ifm-color-primary)}.sidebar.sidebar--right .menu__link,.sidebar.sidebar--right .menu__list-title{display:block;padding-right:var(--ifm-spacing-vertical);text-align:right}.container svg [fill="#000000"],.footer svg [fill="#000000"],.installationPlatforms_1UKi svg [fill="#10E7FF"],.markdown svg [fill="#000000"],.navbar__brand svg [fill="#000000"],.sidebar__logo svg [fill="#000000"],html[data-theme=dark] .container svg [fill="#000000"],html[data-theme=dark] .footer svg [fill="#000000"],html[data-theme=dark] .markdown svg [fill="#000000"],html[data-theme=dark] .navbar__brand svg [fill="#000000"],html[data-theme=dark] .sidebar__logo svg [fill="#000000"]{fill:var(--ifm-heading-color)}.container svg [fill="#FFFFFF"],.footer svg [fill="#FFFFFF"],.integrations g.item circle,.markdown svg [fill="#FFFFFF"],.navbar__brand svg [fill="#FFFFFF"],.sidebar__logo svg [fill="#FFFFFF"],html[data-theme=dark] .container svg [fill="#FFFFFF"],html[data-theme=dark] .footer svg [fill="#FFFFFF"],html[data-theme=dark] .markdown svg [fill="#FFFFFF"],html[data-theme=dark] .navbar__brand svg [fill="#FFFFFF"],html[data-theme=dark] .sidebar__logo svg [fill="#FFFFFF"]{fill:var(--ifm-background-color)}.container svg [stop-color="#000000"],.footer svg [stop-color="#000000"],.markdown svg [stop-color="#000000"],.navbar__brand svg [stop-color="#000000"],.sidebar__logo svg [stop-color="#000000"],html[data-theme=dark] .container svg [stop-color="#000000"],html[data-theme=dark] .footer svg [stop-color="#000000"],html[data-theme=dark] .markdown svg [stop-color="#000000"],html[data-theme=dark] .navbar__brand svg [stop-color="#000000"],html[data-theme=dark] .sidebar__logo svg [stop-color="#000000"]{stop-color:var(--ifm-heading-color)}.container svg [stroke="#FFFFFF"],.footer svg [stroke="#FFFFFF"],.markdown svg [stroke="#FFFFFF"],.navbar__brand svg [stroke="#FFFFFF"],.sidebar__logo svg [stroke="#FFFFFF"],html[data-theme=dark] .container svg [stroke="#FFFFFF"],html[data-theme=dark] .footer svg [stroke="#FFFFFF"],html[data-theme=dark] .markdown svg [stroke="#FFFFFF"],html[data-theme=dark] .navbar__brand svg [stroke="#FFFFFF"],html[data-theme=dark] .sidebar__logo svg [stroke="#FFFFFF"]{stroke:var(--ifm-background-color)}.integrations g.item.large circle,.integrations g.item:hover circle{stroke:var(--ifm-panel-border-color-active)}.table-of-contents{border-left:1px solid var(--ifm-contents-border-color);display:inherit;font-size:.8rem;max-height:calc(100vh - var(--ifm-navbar-height) - 2rem);overflow-y:auto;padding-left:var(--ifm-contents-padding-left);position:-webkit-sticky;position:sticky;top:calc(var(--ifm-navbar-height) + 2rem)}.markdown table>tbody>tr>td:first-child,.markdown table>thead>tr>th:first-child,.unstyled,div[class^=docPage_] main[class^=docMainContainer_] div.container div.row div.col.col--3{padding-left:0}.table-of-contents .section{margin-bottom:.5rem;padding:0 0 .5rem}.table-of-contents .status{font-weight:700;padding:0 0 var(--ifm-contents-padding-vertical) 0}.table-of-contents .title{color:var(--ifm-color-emphasis-300);font-size:.9rem;font-weight:700;margin-bottom:var(--ifm-contents-padding-vertical)}.table-of-contents ul.contents{font-size:.75rem;font-weight:700;padding:0}.table-of-contents ul.contents li{margin-left:0;margin-right:0;overflow:hidden}ul.tabs{background-color:var(--ifm-color-emphasis-50);font-size:.9em;font-weight:700}ul.tabs li.tab-item{border-left:1px solid transparent;border-radius:0;border-right:1px solid transparent;border-top:2px solid transparent;margin:0 0 -1px;padding:.4em 1.5em;text-align:center}ul.tabs li.tab-item:hover{background:0 0;color:var(--ifm-link-colorI)}ul.tabs li.tab-item.tab-item--active{background:var(--ifm-background-color);border-color:var(--ifm-tabs-color-active) var(--ifm-hr-border-color) var(--ifm-background-color);color:var(--ifm-font-base-color)}ul.tabs.mini{background:none;border:0}ul.tabs.mini li{border:0;margin-right:1em;padding:0}ul.tabs.rounded{border:0;border-radius:2em;font-size:1em;font-weight:400;margin:0 auto;padding:6px}ul.tabs.rounded li.tab-item{border:0;border-radius:2em;flex:1 1 0;padding:0 10px;white-space:nowrap}ul.tabs.rounded li.tab-item.tab-item--active{border:0}.tabs--centered,.topology_1kCh{text-align:center}.tabs--centered ul.tabs{display:inline-block}.text--highlight{-webkit-animation:5s ease-in infinite a;animation:5s ease-in infinite a;background-clip:text;-webkit-background-clip:text;background-image:var(--ifm-highlight-gradient);background-size:150% 150%;color:transparent}.unstyled{list-style:none}.markdown .diagram{max-height:250px;width:100%}.markdown>h1,.markdown>h2{border-top:1px solid var(--ifm-hr-border-color);font-size:1.5rem;margin-bottom:calc(var(--ifm-h1-h2-vertical-rhythm-bottom)*var(--ifm-leading));margin-top:calc(var(--ifm-h1-h2-vertical-rhythm-top)*var(--ifm-leading));padding-top:calc(var(--ifm-h1-h2-vertical-rhythm-top)*var(--ifm-leading))}.markdown>h3{--ifm-h3-font-size:1.5rem;margin-bottom:calc(var(--ifm-h3-vertical-rhythm-bottom)*var(--ifm-leading));margin-top:calc(var(--ifm-h3-vertical-rhythm-top)*var(--ifm-leading))}.markdown>h4{margin-bottom:calc(var(--ifm-h4-vertical-rhythm-bottom)*var(--ifm-leading));margin-top:calc(var(--ifm-h4-vertical-rhythm-top)*var(--ifm-leading))}.markdown>h5{margin-bottom:calc(var(--ifm-h5-vertical-rhythm-bottom)*var(--ifm-leading));margin-top:calc(var(--ifm-h5-vertical-rhythm-top)*var(--ifm-leading))}.markdown>h6{margin-bottom:calc(var(--ifm-h6-vertical-rhythm-bottom)*var(--ifm-leading));margin-top:calc(var(--ifm-h6-vertical-rhythm-top)*var(--ifm-leading))}.markdown>img,.markdown>p>img,.markdown>p>svg,.markdown>svg{display:block;height:auto;margin:0 auto}.markdown>img,.markdown>svg{margin-bottom:calc(var(--ifm-spacing-vertical)*2)}.markdown svg{height:100%;max-height:100%}.markdown pre{font-size:90%}.markdown table{display:table;page-break-inside:auto;width:100%}.markdown table>tbody>tr,.markdown table>thead>tr{border:none;border-bottom:1px solid var(--ifm-hr-border-color);page-break-after:auto;page-break-inside:avoid}.markdown table>thead>tr{border-bottom-width:2px}.markdown table>tbody>tr>td,.markdown table>thead>tr>th{-webkit-box-align:start;-ms-grid-row-align:start;align-items:start;align-self:start;border:none;padding:8px;width:auto}.DocSearch-Button,.DocSearch-Button-Container{align-items:center;display:flex}.markdown table>thead>tr{border-bottom-size:2px}div[class^=docPage_] div[class^=docItemContainer_]{max-width:none}div[class^=docPage_] h1[class^=docTitle_]{font-size:2em;margin-bottom:.5rem}div[class^=docPage_] div[class^=docSidebarContainer_]{border-right-color:var(--ifm-sidebar-border-color);max-width:var(--ifm-sidebar-width);min-width:var(--ifm-sidebar-width)}div[class^=docPage_] div[class^=sidebar_]{font-size:.85rem;font-weight:700}div[class^=docPage_] div[class^=sidebar_] .menu{background:var(--ifm-sidebar-background);font-weight:700;padding:var(--ifm-spacing-vertical) var(--ifm-navbar-padding-horizontal) 0 var(--ifm-navbar-padding-horizontal)}div[class^=docPage_] div[class^=sidebar_] .menu__link.menu__link--active:not(.menu__link--sublist){border-radius:0;border-right:2px solid var(--ifm-color-primary);margin-right:calc(var(--ifm-navbar-padding-horizontal)*-1);padding-right:calc(var(--ifm-navbar-padding-horizontal) - 2px)}div[class^=docPage_] div[class^=sidebar_] .menu__link.menu__link--active:not(.menu__link--sublist) .badge{background:rgba(var(--ifm-color-primary-rgb),.2);background-clip:padding-box;border:1px solid rgba(var(--ifm-color-primary-rgb),.2);color:var(--ifm-color-primary)}html[data-theme=dark] .domain-bg,html[data-theme=dark] .domain-bg.domain-bg--config,html[data-theme=dark] .domain-bg.domain-bg--networking,html[data-theme=dark] .domain-bg.domain-bg--platforms,html[data-theme=dark] .domain-bg.domain-bg--sinks,html[data-theme=dark] .domain-bg.domain-bg--sources,html[data-theme=dark] .domain-bg.domain-bg--transforms{background-image:url(/assets/images/logo-4a65787ee541d20adfdf62e4bb5ad67b.svg)}html[data-theme=dark] .navbar{border-bottom:1px solid var(--ifm-sidebar-border-color);box-shadow:none}html[data-theme=dark] .navbar__sidebar__backdrop{background:var(--ifm-color-emphasis-100)}html[data-theme=dark] .navbar .navbar__item .badge--default{background:var(--ifm-color-emphasis-100);color:var(--ifm-panel-color)}html[data-theme=dark] .button.button--secondary{--ifm-button-background-color:var(--ifm-panel-background);--ifm-button-border-color:var(--ifm-panel-border-color);--ifm-button-color:var(--ifm-panel-color);color:var(--ifm-button-color)}html[data-theme=dark] .button.button--secondary:hover{--ifm-button-background-color:var(--ifm-panel-background-active);--ifm-button-border-color:var(--ifm-panel-border-color-active);--ifm-button-color:var(--ifm-panel-color-active);box-shadow:var(--ifm-panel-box-shadow-active)}html[data-theme=dark] .menu .menu__link.menu__link--sublist:after{background-image:url('data:image/svg+xml;utf8,<svg alt="Arrow" xmlns="http://www.w3.org/2000/svg" width="14px" height="14px" viewBox="-6 -6 38 38"><path fill="rgba(255,255,255,0.3)" d="M7.41 15.41L12 10.83l4.59 4.58L18 14l-6-6-6 6z"></path></svg>')}html[data-theme=dark] input[type=checkbox]{background:var(--ifm-color-emphasis-200)}html[data-theme=dark] input[type=checkbox]:checked{background-color:var(--ifm-color-primary)}#nprogress .bar{background:#29d;height:2px;left:0;position:fixed;top:0;width:100%;z-index:11}#nprogress .peg{box-shadow:0 0 10px #29d,0 0 5px #29d;height:100%;opacity:1;position:absolute;right:0;-webkit-transform:rotate(3deg) translateY(-4px);transform:rotate(3deg) translateY(-4px);width:100px}.DocSearch-Button{background:var(--docsearch-searchbox-background);border:0;border-radius:40px;color:var(--docsearch-muted-color);cursor:pointer;font-weight:500;height:36px;justify-content:space-between;padding:0 8px;user-select:none}.DocSearch-Button:active,.DocSearch-Button:focus,.DocSearch-Button:hover{background:var(--docsearch-searchbox-focus-background);box-shadow:var(--docsearch-searchbox-shadow);color:var(--docsearch-text-color);outline:0}.DocSearch-Search-Icon{stroke-width:1.6}.DocSearch-Hit-Tree,.DocSearch-Hit-action,.DocSearch-Hit-icon,.DocSearch-Reset{stroke-width:var(--docsearch-icon-stroke-width)}.DocSearch-Button .DocSearch-Search-Icon{color:var(--docsearch-text-color)}.DocSearch-Button-Placeholder{font-size:1rem;padding:0 12px 0 6px}.DocSearch-Input,.DocSearch-Link{-webkit-appearance:none;font:inherit}.DocSearch-Button-Keys{display:flex;min-width:calc(40px + .8em)}.DocSearch-Button-Key{align-items:center;background:var(--docsearch-key-gradient);border-radius:3px;box-shadow:var(--docsearch-key-shadow);color:var(--docsearch-muted-color);display:flex;height:18px;justify-content:center;margin-right:.4em;padding-bottom:2px;position:relative;top:-1px;width:20px}.DocSearch--active{overflow:hidden!important}.DocSearch-Container{background-color:var(--docsearch-container-background);height:100vh;left:0;position:fixed;top:0;width:100vw;z-index:7}.DocSearch-Link{appearance:none;background:none;border:0;color:var(--docsearch-highlight-color);cursor:pointer;margin:0;padding:0}.DocSearch-Modal{background:var(--docsearch-modal-background);border-radius:6px;box-shadow:var(--docsearch-modal-shadow);flex-direction:column;margin:60px auto auto;max-width:var(--docsearch-modal-width);position:relative}.DocSearch-SearchBar{display:flex;padding:var(--docsearch-spacing) var(--docsearch-spacing) 0}.DocSearch-Form{align-items:center;background:var(--docsearch-searchbox-focus-background);border-radius:4px;box-shadow:var(--docsearch-searchbox-shadow);display:flex;height:var(--docsearch-searchbox-height);margin:0;padding:0 var(--docsearch-spacing);position:relative;width:100%}.DocSearch-Input{appearance:none;background:0 0;border:0;color:var(--docsearch-text-color);flex:1;font-size:1.2em;height:100%;outline:0;padding:0 0 0 8px;width:80%}.DocSearch-Hit-action-button,.DocSearch-Reset{-webkit-appearance:none;border:0;cursor:pointer}.DocSearch-Input::-webkit-input-placeholder{color:var(--docsearch-muted-color);opacity:1}.DocSearch-Input:-ms-input-placeholder{color:var(--docsearch-muted-color);opacity:1}.DocSearch-Input::placeholder{color:var(--docsearch-muted-color);opacity:1}.DocSearch-Input::-webkit-search-cancel-button,.DocSearch-Input::-webkit-search-decoration,.DocSearch-Input::-webkit-search-results-button,.DocSearch-Input::-webkit-search-results-decoration{display:none}.DocSearch-LoadingIndicator,.DocSearch-MagnifierLabel,.DocSearch-Reset{margin:0;padding:0}.DocSearch-Container--Stalled .DocSearch-LoadingIndicator,.DocSearch-MagnifierLabel,.DocSearch-Reset{align-items:center;color:var(--docsearch-highlight-color);display:flex;justify-content:center}.DocSearch-Cancel,.DocSearch-Container--Stalled .DocSearch-MagnifierLabel,.DocSearch-LoadingIndicator,.DocSearch-Reset[hidden]{display:none}.DocSearch-Reset{-webkit-animation:.1s ease-in forwards b;animation:.1s ease-in forwards b;appearance:none;background:none;border-radius:50%;color:var(--docsearch-icon-color);padding:2px;right:0}.DocSearch-Help,.DocSearch-HitsFooter,.DocSearch-Label{color:var(--docsearch-muted-color)}.DocSearch-Reset:focus,body:not(.navigation-with-keyboard) :not(input):focus{outline:0}.DocSearch-Reset:hover{color:var(--docsearch-highlight-color)}.DocSearch-LoadingIndicator svg,.DocSearch-MagnifierLabel svg{height:24px;width:24px}.DocSearch-Dropdown{max-height:calc(var(--docsearch-modal-height) - var(--docsearch-searchbox-height) - var(--docsearch-spacing) - var(--docsearch-footer-height));min-height:var(--docsearch-spacing);overflow-y:auto;overflow-y:overlay;padding:0 var(--docsearch-spacing);scrollbar-color:var(--docsearch-muted-color) var(--docsearch-modal-background);scrollbar-width:thin}.DocSearch-Dropdown::-webkit-scrollbar{width:12px}.DocSearch-Dropdown::-webkit-scrollbar-track{background:0 0}.DocSearch-Dropdown::-webkit-scrollbar-thumb{background-color:var(--docsearch-muted-color);border:3px solid var(--docsearch-modal-background);border-radius:20px}.DocSearch-Dropdown ul{list-style:none;margin:0;padding:0}.DocSearch-Label{font-size:.75em;line-height:1.6em}.DocSearch-Help{font-size:.9em;margin:0;user-select:none}.DocSearch-Footer,.react-toggle{-webkit-user-select:none;-ms-user-select:none}.DocSearch-Title{font-size:1.2em}.DocSearch-Logo a,.docs-wrapper{display:flex}.DocSearch-Logo svg{color:var(--docsearch-logo-color);margin-left:8px}.DocSearch-Hits:last-of-type{margin-bottom:24px}.DocSearch-Hits mark{background:none;color:var(--docsearch-highlight-color)}.DocSearch-HitsFooter{display:flex;font-size:.85em;justify-content:center;margin-bottom:var(--docsearch-spacing);padding:var(--docsearch-spacing)}.DocSearch-HitsFooter a{border-bottom:1px solid;color:inherit}.DocSearch-Hit{border-radius:4px;display:flex;padding-bottom:4px;position:relative}.DocSearch-Hit--deleting{opacity:0;transition:.25s linear}.DocSearch-Hit--favoriting{-webkit-transform:scale(0);transform:scale(0);-webkit-transform-origin:top center;transform-origin:top center;transition:.25s linear .25s}.DocSearch-Hit a{background:var(--docsearch-hit-background);border-radius:4px;box-shadow:var(--docsearch-hit-shadow);display:block;padding-left:var(--docsearch-spacing);width:100%}.DocSearch-Hit-source{background:var(--docsearch-modal-background);color:var(--docsearch-highlight-color);font-size:.85em;font-weight:600;line-height:32px;margin:0 -4px;padding:8px 4px 0;position:-webkit-sticky;position:sticky;top:0;z-index:3}.DocSearch-Hit-Tree{color:var(--docsearch-muted-color);height:var(--docsearch-hit-height);opacity:.5;width:24px}.DocSearch-Hit[aria-selected=true] a{background-color:var(--docsearch-highlight-color)}.DocSearch-Hit[aria-selected=true] mark{text-decoration:underline}.DocSearch-Hit-Container{align-items:center;color:var(--docsearch-hit-color);display:flex;flex-direction:row;height:var(--docsearch-hit-height);padding:0 var(--docsearch-spacing) 0 0}.DocSearch-Hit-icon{height:20px;width:20px}.DocSearch-Hit-action,.DocSearch-Hit-icon{color:var(--docsearch-muted-color)}.DocSearch-Hit-action{align-items:center;display:flex;height:22px;width:22px}.DocSearch-Hit-action svg{display:block;height:18px;width:18px}.DocSearch-Hit-action+.DocSearch-Hit-action{margin-left:6px}.DocSearch-Hit-action-button{appearance:none;background:none;border-radius:50%;color:inherit;padding:2px}.collapseSidebarButton_1CGd,.components_1ZGx ul,.sidebarLogo_3h0W,.themedImage_1VuW,html[data-announcement-bar-initially-dismissed=true] .announcementBar_3WsW,svg.DocSearch-Hit-Select-Icon{display:none}.DocSearch-Hit[aria-selected=true] .DocSearch-Hit-Select-Icon,.components_1ZGx h3 span{display:block}.DocSearch-Hit-action-button:focus,.DocSearch-Hit-action-button:hover{background:rgba(0,0,0,.2);transition:background-color .1s ease-in}.DocSearch-Hit-action-button:focus path,.DocSearch-Hit-action-button:hover path{fill:#fff}.DocSearch-Hit-content-wrapper{display:flex;flex:1 1 auto;flex-direction:column;font-weight:500;justify-content:center;line-height:1.2em;margin:0 8px;overflow-x:hidden;position:relative;width:80%}.DocSearch-Hit-title{font-size:.9em}.DocSearch-Hit-path{color:var(--docsearch-muted-color);font-size:.75em}.DocSearch-Hit[aria-selected=true] .DocSearch-Hit-Tree,.DocSearch-Hit[aria-selected=true] .DocSearch-Hit-action,.DocSearch-Hit[aria-selected=true] .DocSearch-Hit-icon,.DocSearch-Hit[aria-selected=true] .DocSearch-Hit-path,.DocSearch-Hit[aria-selected=true] .DocSearch-Hit-text,.DocSearch-Hit[aria-selected=true] .DocSearch-Hit-title,.DocSearch-Hit[aria-selected=true] mark{color:var(--docsearch-hit-active-color)!important}.DocSearch-ErrorScreen,.DocSearch-NoResults,.DocSearch-StartScreen{font-size:.9em;margin:0 auto;padding:36px 0;text-align:center;width:80%}.DocSearch-Screen-Icon{color:var(--docsearch-muted-color);padding-bottom:12px}.DocSearch-NoResults-Prefill-List{display:inline-block;padding-bottom:24px;text-align:left}.DocSearch-NoResults-Prefill-List ul{display:inline-block;padding:8px 0 0}.DocSearch-NoResults-Prefill-List li{list-style-position:inside;list-style-type:"» "}.DocSearch-Prefill{-webkit-appearance:none;appearance:none;background:none;border:0;border-radius:1em;color:var(--docsearch-highlight-color);cursor:pointer;display:inline-block;font-size:1em;font-weight:700;padding:0}.DocSearch-Prefill:focus,.DocSearch-Prefill:hover{outline:0;text-decoration:underline}.DocSearch-Footer{align-items:center;background:var(--docsearch-footer-background);border-radius:0 0 8px 8px;box-shadow:var(--docsearch-footer-shadow);display:flex;flex-direction:row-reverse;flex-shrink:0;height:var(--docsearch-footer-height);justify-content:space-between;padding:0 var(--docsearch-spacing);position:relative;user-select:none;width:100%;z-index:8}.DocSearch-Commands li,.DocSearch-Commands-Key{align-items:center;display:flex}.DocSearch-Container,.skipToContent_1oUP{z-index:calc(var(--ifm-z-index-fixed) + 1)}.DocSearch-Commands{color:var(--docsearch-muted-color);display:flex;list-style:none;margin:0;padding:0}.DocSearch-Commands li:not(:last-of-type){margin-right:.8em}.DocSearch-Commands-Key{background:var(--docsearch-key-gradient);border-radius:2px;box-shadow:var(--docsearch-key-shadow);height:18px;justify-content:center;margin-right:.4em;padding-bottom:1px;width:20px}@-webkit-keyframes b{0%{opacity:0}to{opacity:1}}@keyframes b{0%{opacity:0}to{opacity:1}}.DocSearch-Button{margin:0;transition:all var(--ifm-transition-fast) var(--ifm-transition-timing-default)}.alert{background:var(--ifm-panel-background)!important;border:0;border-left:6px solid var(--ifm-alert-background-color);border-radius:0;font-size:95%;font-weight:500;margin-bottom:calc(var(--ifm-spacing-vertical)*2)}.alert>i.feather{float:left;font-size:2em!important;margin-left:-1.65em;position:relative;top:-2px}.alert a,.alert code{color:var(--ifm-alert-background-color)}.alert.alert--icon{padding-left:5em}.alert.alert--fill.alert--danger{background:rgba(var(--ifm-color-danger-rgb),.15)!important;border:1px solid var(--ifm-color-danger);color:var(--ifm-color-danger)!important}.alert.alert--fill.alert--primary{background:rgba(var(--ifm-color-primary-rgb),.15)!important;border:1px solid var(--ifm-color-primary);color:var(--ifm-color-primary)!important}.alert.alert--fill.alert--warning{background:rgba(var(--ifm-color-warning-rgb),.15)!important;border:1px solid var(--ifm-color-warning);color:var(--ifm-color-warning)!important}.alert.alert--fill a,.announcementBarContent_3EUC a{color:inherit;text-decoration:underline}.indexAnnouncement_3fuK span,.jump-to.jump-to--highlight:hover .jump-to--inner-2{color:var(--ifm-background-color)}.alert.alert--fill a code,.alert.alert--fill code{color:inherit}.skipToContent_1oUP{background-color:var(--ifm-background-surface-color);color:var(--ifm-color-emphasis-900);left:100%;padding:calc(var(--ifm-global-spacing)/2) var(--ifm-global-spacing);position:fixed;top:1rem}.skipToContent_1oUP:focus{box-shadow:var(--ifm-global-shadow-md);left:1rem}.announcementBar_3WsW{background-color:var(--ifm-color-white);border-bottom:1px solid var(--ifm-color-emphasis-100);color:var(--ifm-color-black);height:var(--docusaurus-announcement-bar-height);position:relative;width:100%}.announcementBarClose_38nx{font-size:1.25rem;height:100%;position:absolute;right:0;top:0;width:55px}.announcementBarContent_3EUC{font-size:85%;padding:5px 0;text-align:center;width:100%}.announcementBarCloseable_3myR{margin-right:55px}.react-toggle{cursor:pointer;position:relative;touch-action:pan-x;user-select:none}.react-toggle-screenreader-only{clip:rect(0 0 0 0);border:0;height:1px;margin:-1px;overflow:hidden;position:absolute;width:1px}.react-toggle--disabled{cursor:not-allowed}.react-toggle-track{background-color:#4d4d4d;border-radius:30px;height:24px;transition:.2s;width:50px}.react-toggle-track-check,.react-toggle-track-x{height:10px;margin:auto 0;top:0;position:absolute;bottom:0}.react-toggle-track-check{left:8px;opacity:0;transition:opacity .25s;width:14px}.react-toggle--checked .react-toggle-track-check,.react-toggle-track-x,[data-theme=dark] .react-toggle .react-toggle-track-check{opacity:1;transition:opacity .25s}.react-toggle-track-x{right:10px;width:10px}.react-toggle--checked .react-toggle-track-x,[data-theme=dark] .react-toggle .react-toggle-track-x{opacity:0}.react-toggle-thumb{background-color:#fafafa;border:1px solid #4d4d4d;border-radius:50%;height:22px;left:1px;position:absolute;top:1px;transition:.25s;width:22px}.react-toggle--checked .react-toggle-thumb,[data-theme=dark] .react-toggle .react-toggle-thumb{left:27px}.react-toggle--focus .react-toggle-thumb,.react-toggle:hover .react-toggle-thumb{box-shadow:0 0 2px 3px var(--ifm-color-primary)}.react-toggle:active:not(.react-toggle--disabled) .react-toggle-thumb{box-shadow:0 0 5px 5px var(--ifm-color-primary)}.toggle_71bT{align-items:center;display:flex;height:10px;justify-content:center;width:10px}.toggle_71bT:before{position:absolute}.iconExternalLink_3J9K{margin-left:.3rem;position:relative;top:1px}html[data-theme=dark] .themedImage--dark_hz6m,html[data-theme=light] .themedImage--light_3UqQ{display:initial}.navbarHideable_2qcr{transition:-webkit-transform var(--ifm-transition-fast) ease;transition:transform var(--ifm-transition-fast) ease;transition:transform var(--ifm-transition-fast) ease,-webkit-transform var(--ifm-transition-fast) ease}.navbarHidden_3yey{-webkit-transform:translate3d(0,calc(-100% - 2px),0);transform:translate3d(0,calc(-100% - 2px),0)}.footerLogoLink_qW4Z{opacity:.5;transition:opacity var(--ifm-transition-fast) var(--ifm-transition-timing-default)}.footerCopyright_2yvt{font-size:12px}.codeBlockContent_hGly{direction:ltr;position:relative}.codeBlockTitle_eoMF{border-bottom:1px solid var(--ifm-color-emphasis-300);border-top-left-radius:var(--ifm-global-radius);border-top-right-radius:var(--ifm-global-radius);font-size:var(--ifm-code-font-size);font-weight:500;padding:.75rem var(--ifm-pre-padding)}.codeBlockWithTitle_2JqI{border-top-left-radius:0;border-top-right-radius:0}.copyButton_Ue-o{background:rgba(0,0,0,.3);border-radius:var(--ifm-global-radius);color:var(--ifm-color-white);opacity:0;padding:.4rem .5rem;position:absolute;right:calc(var(--ifm-pre-padding)/2);top:calc(var(--ifm-pre-padding)/2);transition:opacity .2s ease-in-out;-webkit-user-select:none;-ms-user-select:none;user-select:none}.codeBlockLines_39YC{display:flex;flex-direction:column;float:left;font:inherit;min-width:100%;padding:var(--ifm-pre-padding)}#__docusaurus{display:flex;flex-direction:column;min-height:100%}.main-wrapper{flex:1 0 auto}.docusaurus-mt-lg{margin-top:3rem}.sidebarMenuIcon_fgN0{vertical-align:middle}.sidebarMenuCloseIcon_1lpH{align-items:center;display:inline-flex;font-size:1.5rem;font-weight:var(--ifm-font-weight-bold);height:24px;justify-content:center;line-height:.9;width:24px}.menu__list .menu__list{overflow-y:hidden;transition:height var(--ifm-transition-fast) linear;will-change:height}.menu__list-item--collapsed .menu__list{height:0!important}.searchQueryInput_35WP,.searchVersionInput_3Dkp{background:var(--docsearch-searchbox-focus-background);border:2px solid var(--ifm-toc-border-color);border-radius:var(--ifm-global-radius);color:var(--docsearch-text-color);font:var(--ifm-font-size-base) var(--ifm-font-family-base);margin-bottom:.5rem;padding:.8rem;transition:border var(--ifm-transition-fast) ease;width:100%}.searchQueryInput_35WP:focus,.searchVersionInput_3Dkp:focus{border-color:var(--docsearch-primary-color);outline:0}.searchQueryInput_35WP::-webkit-input-placeholder{color:var(--docsearch-muted-color)}.searchQueryInput_35WP:-ms-input-placeholder{color:var(--docsearch-muted-color)}.searchQueryInput_35WP::placeholder{color:var(--docsearch-muted-color)}.searchResultsColumn_3okB{font-size:.9rem;font-weight:700}.algoliaLogo_hvIi{max-width:150px}.algoliaLogoPathFill_wnAy{fill:var(--ifm-font-color-base)}.searchResultItem_3EK0{border-bottom:1px solid var(--ifm-toc-border-color);padding:1rem 0}.searchResultItemHeading_3ioS{font-weight:400;margin-bottom:0}.searchResultItemPath_1-7G{--ifm-breadcrumb-separator-size-multiplier:1;color:var(--ifm-color-content-secondary);font-size:.8rem}.searchResultItemSummary_17EU{font-style:italic;margin:.5rem 0 0}.loadingSpinner_EGxz{-webkit-animation:1s linear infinite c;animation:1s linear infinite c;border:.4em solid #eee;border-radius:50%;border-top:.4em solid var(--ifm-color-primary);height:3rem;margin:0 auto;width:3rem}@-webkit-keyframes c{to{-webkit-transform:rotate(1turn);transform:rotate(1turn)}}@keyframes c{to{-webkit-transform:rotate(1turn);transform:rotate(1turn)}}.loader_1VUO{margin-top:2rem}.search-result-match{background:rgba(255,215,142,.25);color:var(--docsearch-hit-color);padding:.09em 0}.componentsHero{margin:0;overflow:hidden;padding:0}.componentsHeroOverlay{margin-bottom:2em;margin-top:-15.25em}.anchor{display:block;position:relative;top:-.5rem}.hash-link{opacity:0;padding-left:.5rem;transition:opacity var(--ifm-transition-fast)}.jump-to{background:var(--ifm-panel-background);border:1px solid var(--ifm-panel-border-color);box-shadow:var(--ifm-panel-box-shadow);color:var(--ifm-font-base-color);display:block;font-weight:500;margin-bottom:var(--ifm-spacing-vertical);text-align:left}.jump-to,.jump-to--inner,.jump-to--inner-2{border-radius:var(--ifm-global-radius);transition:var(--ifm-transition-fast) ease}.jump-to--inner-2{display:flex;padding:1em var(--ifm-spacing-horizontal)}.jump-to--main{flex:1 1;vertical-align:center}.jump-to--main .badge--right{float:right;margin-top:3px}.jump-to--right{font-size:1.8em!important;line-height:1;margin:0 10px;transition:var(--ifm-transition-fast) ease;width:30px}.jump-to:hover{background:var(--ifm-panel-background-active);border-color:var(--ifm-color-primary);box-shadow:var(--ifm-panel-box-shadow-active);text-decoration:none}.jump-to:hover .jump-to--right{margin-right:0}.jump-to.jump-to--sm{font-size:.8em}.jump-to.jump-to--primary{background:rgba(var(--ifm-color-primary-rgb),.2)}.jump-to.jump-to--highlight{-webkit-animation:5s ease-in infinite a;animation:5s ease-in infinite a;background-image:var(--ifm-highlight-gradient);background-size:150% 150%;border:0;font-weight:600;padding:1px}.jump-to.jump-to--highlight .jump-to--inner{background:rgba(var(--ifm-background-color-rgb),.85);color:var(--ifm-background-color)}.jump-to.jump-to--highlight .jump-to--inner-2{-webkit-animation:5s ease-in infinite a;animation:5s ease-in infinite a;-webkit-background-clip:text;background-clip:text;background-image:var(--ifm-highlight-gradient);background-size:150% 150%;color:var(--ifm-color-emphasis-700)}.jump-to.jump-to--highlight:hover{box-shadow:none}.jump-to.jump-to--highlight:hover .jump-to--inner{background:none}.jump-to.jump-to--highlight:hover span.badge{background:var(--ifm-background-color);color:var(--ifm-color-primary)}.jump-to small{opacity:.75}.jump-to span.badge.badge--category{font-size:.8em;line-height:1em}.tabItemActive_2DSg{-webkit-animation:.5s ease-in-out 5 d;animation:.5s ease-in-out 5 d}@-webkit-keyframes d{0%{background-color:var(--ifm-hover-overlay)}to{background-color:transparent}}@keyframes d{0%{background-color:var(--ifm-hover-overlay)}to{background-color:transparent}}.enhancedAnchor_2LWZ{top:calc(var(--ifm-navbar-height)*-1 - .5rem)}.h1Heading_27L5{font-size:3rem;margin-bottom:calc(var(--ifm-leading-desktop)*var(--ifm-leading))}.features_N601 h3,.indexAnnouncement_3fuK{margin-bottom:var(--ifm-spacing-vertical)}.docMainContainer_3ufF,.docPage_31aa{display:flex;width:100%}@-webkit-keyframes e{0%{background-size:100% 100%}90%{background-size:250% 250%}to{background-size:200% 200%}}@keyframes e{0%{background-size:100% 100%}90%{background-size:250% 250%}to{background-size:200% 200%}}@-webkit-keyframes f{0%,to{background-size:200% 200%}50%{background-size:150% 150%}}@keyframes f{0%,to{background-size:200% 200%}50%{background-size:150% 150%}}.indexAnnouncement_3fuK{background:var(--ifm-color-emphasis-50);border-radius:1em;color:var(--ifm-color-content);display:inline-block;font-size:.9em;padding:3px 10px 5px}.indexAnnouncement_3fuK span{background:var(--ifm-color-content);border:0;border-radius:1em;margin-right:.5em}.indexAnnouncement_3fuK:hover{background:var(--ifm-panel-background-active);text-decoration:none}.indexHeroBanner_1rfj{-webkit-animation:.7s cubic-bezier(0,1.5,.32,1.5) e,2.5s linear infinite f;animation:.7s cubic-bezier(0,1.5,.32,1.5) e,2.5s linear infinite f;-webkit-animation-delay:.65s,1.35s;animation-delay:.65s,1.35s;-webkit-animation-fill-mode:forwards;animation-fill-mode:forwards;background-image:radial-gradient(ellipse at center calc(50% + 6em),rgba(var(--ifm-color-primary-rgb),.25),transparent 20%);background-position:50%;font-size:1.05em}.indexHeroDiagram_3nNK{height:auto;margin:calc(var(--ifm-spacing-vertical)*2) 0;max-height:21em;width:100%}html[data-theme=dark] .hero_39XR{background-image:radial-gradient(ellipse at center calc(50% + 125px),rgba(var(--ifm-color-primary-rgb),.2),transparent 30%)}.features_N601{align-items:center;display:flex;width:100%}.features_N601 h3{text-align:center}.feature_2oFu p{margin-bottom:calc(var(--ifm-spacing-vertical)*3)}.featureIcon_5IMF{border-top:1px solid var(--ifm-color-primary);color:var(--ifm-color-primary);font-size:1.5em;margin-bottom:-.5em;margin-top:1em;text-align:center}.featureIcon_5IMF i{background:var(--ifm-background-color);padding:0 var(--ifm-spacing-horizontal);position:relative;top:-1em}.components_1ZGx{height:1000px;margin-top:calc(var(--ifm-spacing-vertical)*-8);position:relative;width:100%}.components_1ZGx h3{align-items:center;display:flex;font-size:3.5rem;height:100%;justify-content:center;position:relative;text-align:center;z-index:1}.componentsCanvas_2sJk{height:100%;left:0;position:absolute;top:0;width:100%;z-index:2}.hover14 figure,.slide-show img{position:relative}.topologyDiagram_39AT{display:block;height:100%;margin:var(--ifm-heading-margin-bottom) auto;max-height:300px;max-width:900px;width:100%}.awssld,.svg{max-width:100%}.installSubTitle_1qZ7{margin-top:var(--ifm-heading-margin-bottom)}.youtubePlayer_3RA3{height:400px;margin:15px 10px 15px 15px;position:relative;width:600px}.installationPlatforms_1UKi{grid-column-gap:100px;display:grid;grid-template-areas:"a a a a" "b b . c" "d d d d";grid-template-rows:auto;margin:calc(var(--ifm-spacing-vertical)*4) 0 calc(var(--ifm-spacing-vertical)*1) 0;text-align:center}.installationPlatforms_1UKi a svg{grid-column-gap:100px;margin:15px var(--ifm-spacing-horizontal);max-height:100px;max-width:150px}.installationPlatforms_1UKi a:hover svg [fill="#10E7FF"]{fill:#10e7ff}.installationChecks_utNn{display:flex;font-weight:700;justify-content:center;margin-bottom:calc(var(--ifm-spacing-vertical)*4);vertical-align:center}.installationChecks_utNn>div{flex-basis:0;flex-grow:1;margin:0 var(--ifm-spacing-horizontal);text-align:center}.integrations g.item text{fill:var(--ifm-color-content)}.integrations g.item.large text,.integrations g.item:hover text{fill:var(--ifm-color-primary)}.integrations g.item:hover circle{fill:var(--ifm-panel-background-active)}.configuration__diagram svg{height:100%;margin-bottom:var(--ifm-spacing-vertical);margin-left:-4%;width:104%}.configuration__diagram svg #config-file-bg{fill:var(--ifm-panel-background);stroke:var(--ifm-panel-border-color)}.image-overview{flex:1.3;height:null;margin:15px 10px 15px 15px;padding:0;width:null}.hover14 figure:before{background:linear-gradient(90deg,hsla(0,0%,100%,0) 0,hsla(0,0%,100%,.3));content:"";display:block;height:100%;left:-75%;position:absolute;top:0;-webkit-transform:skewX(-25deg);transform:skewX(-25deg);width:50%;z-index:2}.hover14 figure:hover:before{-webkit-animation:.75s g;animation:.75s g}@-webkit-keyframes g{to{left:125%}}@keyframes g{to{left:125%}}.svg{display:block;height:auto;justify-content:center;margin:var(--ifm-heading-margin-bottom) auto;max-height:100%;width:auto}@font-face{font-family:Material Icons;font-style:normal;font-weight:400;src:url(https://fonts.gstatic.com/s/materialicons/v50/flUhRq6tzZclQEJ-Vdg-IuiaDsNcIhQ8tQ.woff2) format("woff2")}.material-icons{word-wrap:normal;-webkit-font-feature-settings:"liga";-webkit-font-smoothing:antialiased;direction:ltr;display:inline-block;font-family:Material Icons;font-size:24px;font-style:normal;font-weight:400;letter-spacing:normal;line-height:1;text-transform:none;white-space:nowrap}.container1{background:#419be0;color:#333;margin:0 auto;padding:40px;width:80%}.awssld__wrapper,.slide-show img{max-height:600px;min-height:500px}.slide-img:before{background:rgba(0,0,0,.505);bottom:0;content:"";left:0;position:absolute;right:0;top:0;z-index:4}.slide-caption{background:rgba(34,34,34,.61);color:#ddd;left:20px;padding:20px;position:absolute;width:50%;z-index:10}.slide-caption>h1{-webkit-animation:2s ease-in fadeIn;animation:2s ease-in fadeIn;margin-bottom:10px}.slide-caption>p{-webkit-animation:3s ease-in fadeIn;animation:3s ease-in fadeIn;font-size:.95rem;line-height:2em;margin-top:10px}.player-wrapper{padding-top:56.25%;position:relative}.react-player{left:0;position:absolute;top:0}.awssld__box,.awssld__container figure,.awssld__content{display:block;height:100%;left:0;position:absolute;top:0;width:100%}.awssld__bullets button,.awssld__controls button{outline-color:0;outline-style:none;outline-width:0}.awssld{--organic-arrow-thickness:4px;--organic-arrow-height:40px;--slider-height-percentage:60%;--loader-bar-color:#851515;--loader-bar-height:6px;--control-button-width:10%;--control-button-height:25%;--control-button-opacity:0.5;--control-button-hover-opacity:0.75;--control-button-background:transparent;--transition-bezier:cubic-bezier(0.5,0.075,0.25,0.95);--slider-transition-duration:575ms;--organic-arrow-color:#6a6a6a;--organic-arrow-border-radius:0;--control-bullet-color:#6a6a6a;--control-bullet-active-color:#6a6a6a;--content-background-color:#2f2f2f}.awssld,.awssld__wrapper{display:block;position:relative;width:100%}.awssld__wrapper{height:100%;overflow:hidden}.awssld__container{display:block;height:0;padding-bottom:var(--slider-height-percentage);width:100%}.awssld__startUp{background-color:red;height:100%;width:100%}.awssld__startUp>div{align-items:center;display:flex;height:100%;justify-content:center;width:100%}.awssld__startUp img{height:auto;width:35%}.awssld__content{align-items:center;background-color:var(--content-background-color);display:flex;justify-content:center;overflow:hidden}.sidebar_2ahu,.tableOfContents_35-E{max-height:calc(100vh - var(--ifm-navbar-height) - 2rem);overflow-y:auto}.awssld__content>img,.awssld__content>video{height:100%;left:0;object-fit:cover;position:absolute;top:0;width:100%}.awssld__controls button{align-items:center;background-color:var(--control-button-background);border:none;color:#fff;cursor:pointer;display:flex;height:var(--control-button-height);justify-content:center;position:absolute;top:calc(50% - var(--control-button-height)*.5);width:var(--control-button-width);z-index:3}.awssld__controls button .awssld__controls__arrow-left,.awssld__controls button .awssld__controls__arrow-right{opacity:var(--control-button-opacity)}.awssld__controls button:hover .awssld__controls__arrow-left,.awssld__controls button:hover .awssld__controls__arrow-right{opacity:var(--control-button-opacity-hover)}.awssld__controls--active .awssld__controls__arrow-left{opacity:var(--control-button-opacity-hover);-webkit-transform:translate3d(-100%,0,0);transform:translate3d(-100%,0,0)}.awssld__controls--active .awssld__controls__arrow-right{opacity:var(--control-button-opacity-hover);-webkit-transform:translate3d(100%,0,0);transform:translate3d(100%,0,0)}.awssld__controls--hidden{display:none}.awssld__bar{background-color:var(--loader-bar-color);display:block;height:var(--loader-bar-height);left:0;position:absolute;top:0;-webkit-transform:translate3d(-100%,0,0);transform:translate3d(-100%,0,0);transition:-webkit-transform 3s var(--transition-bezier);transition:transform 3s var(--transition-bezier);transition:transform 3s var(--transition-bezier),-webkit-transform 3s var(--transition-bezier);width:100%;z-index:6}.awssld__bar--active{-webkit-transform:translate3d(-20%,0,0);transform:translate3d(-20%,0,0)}.awssld__bar--end{-webkit-transform:translateZ(0);transform:translateZ(0);transition-duration:.3s}.awssld__prev{left:0}.awssld__box{z-index:1}.awssld--animated{visibility:visible;will-change:transform}.awssld--animated-mobile{transition:transform 325ms cubic-bezier(.15,.65,.1,1);transition:transform 325ms cubic-bezier(.15,.65,.1,1),-webkit-transform 325ms cubic-bezier(.15,.65,.1,1);will-change:transform}.awssld--active{-webkit-transform:translateZ(0);transform:translateZ(0);visibility:visible;z-index:2}.awssld--moveLeft,.awssld--moveRight{-webkit-backface-visibility:hidden;backface-visibility:hidden}.awssld--moveRight{-webkit-animation:i var(--slider-transition-duration) both var(--transition-bezier);animation:i var(--slider-transition-duration) both var(--transition-bezier)}.awssld--moveLeft{-webkit-animation:h var(--slider-transition-duration) both var(--transition-bezier);animation:h var(--slider-transition-duration) both var(--transition-bezier)}.awssld--exit{z-index:0}.awssld--exit.awssld--moveLeft{-webkit-animation:j var(--slider-transition-duration) both var(--transition-bezier);animation:j var(--slider-transition-duration) both var(--transition-bezier)}.awssld--exit.awssld--moveRight{-webkit-animation:k var(--slider-transition-duration) both var(--transition-bezier);animation:k var(--slider-transition-duration) both var(--transition-bezier)}.awssld--fill-parent{height:100%!important;left:0;position:absolute!important;top:0;width:100%!important}.awssld--fill-parent .awssld__container{height:100%;padding:0}.awssld__bullets{align-items:center;bottom:-40px;display:flex;justify-content:center;position:absolute;width:100%}.awssld__bullets button{background:var(--control-bullet-color);border:none;border-radius:50%;cursor:pointer;display:block;height:16px;margin:5px;overflow:hidden;padding:0;text-indent:-9999px;transition:transform .225s cubic-bezier(.8,1.35,.75,1.45),background-color .175s ease-out,-webkit-transform .225s cubic-bezier(.8,1.35,.75,1.45);width:16px}.awssld__bullets .awssld__bullets--loading,.awssld__bullets button:hover{-webkit-transform:scale(1.2);transform:scale(1.2)}.awssld__bullets .awssld__bullets--active{background:var(--control-bullet-active-color)}.awssld__bullets .awssld__bullets--active,.awssld__bullets .awssld__bullets--active:hover{-webkit-transform:scale(1.5);transform:scale(1.5)}.awssld__controls__arrow-left,.awssld__controls__arrow-right{display:block;height:var(--organic-arrow-height);position:relative;transition:transform .2s ease-out .125s,opacity .2s ease-out,-webkit-transform .2s ease-out .125s;width:100%}.awssld__controls__arrow-left:after,.awssld__controls__arrow-left:before,.awssld__controls__arrow-right:after,.awssld__controls__arrow-right:before{background-color:var(--organic-arrow-color);border-radius:var(--organic-arrow-border-radius);content:" ";height:100%;position:absolute;right:calc(50% - var(--organic-arrow-height)*.7071/2 - var(--organic-arrow-thickness)*.7071/2);transition:transform .15s ease-out,background-color .15s ease-out,-webkit-transform .15s ease-out;width:var(--organic-arrow-thickness)}.awssld__controls__arrow-left:before,.awssld__controls__arrow-right:before{top:-50%;-webkit-transform:rotate(-45deg);transform:rotate(-45deg);-webkit-transform-origin:100% 100% 0;transform-origin:100% 100% 0}.awssld__controls__arrow-left:after,.awssld__controls__arrow-right:after{top:50%;-webkit-transform:rotate(45deg);transform:rotate(45deg);-webkit-transform-origin:100% 0 0;transform-origin:100% 0 0}.awssld__controls__arrow-right--active{-webkit-transform:translate3d(100%,0,0);transform:translate3d(100%,0,0)}.awssld__controls__arrow-right--active:after{-webkit-transform:rotate(90deg) translate3d(50%,0,0)!important;transform:rotate(90deg) translate3d(50%,0,0)!important}.awssld__controls__arrow-right--active:before{-webkit-transform:rotate(-90deg) translate3d(50%,0,0)!important;transform:rotate(-90deg) translate3d(50%,0,0)!important}.awssld__controls__arrow-left:after,.awssld__controls__arrow-left:before{left:calc(50% - var(--organic-arrow-height)*.7071/2 - var(--organic-arrow-thickness)*.7071/2);right:auto}.awssld__controls__arrow-left:before{top:-50%;-webkit-transform:rotate(45deg);transform:rotate(45deg);-webkit-transform-origin:0 100% 0;transform-origin:0 100% 0}.awssld__controls__arrow-left:after{top:50%;-webkit-transform:rotate(-45deg);transform:rotate(-45deg);-webkit-transform-origin:0 0 0;transform-origin:0 0 0}.awssld__controls__arrow-left--active{-webkit-transform:translate3d(-100%,0,0);transform:translate3d(-100%,0,0)}.awssld__controls__arrow-left--active:after{-webkit-transform:rotate(-90deg) translate3d(-50%,0,0)!important;transform:rotate(-90deg) translate3d(-50%,0,0)!important}.awssld__controls__arrow-left--active:before{-webkit-transform:rotate(90deg) translate3d(-50%,0,0)!important;transform:rotate(90deg) translate3d(-50%,0,0)!important}.awssld__controls button:hover .awssld__controls__arrow-left:before,.awssld__controls button:hover .awssld__controls__arrow-right:after{opacity:1;-webkit-transform:rotate(30deg);transform:rotate(30deg)}.awssld__controls button:hover .awssld__controls__arrow-left:after,.awssld__controls button:hover .awssld__controls__arrow-right:before{opacity:1;-webkit-transform:rotate(-30deg);transform:rotate(-30deg)}.awssld__timer{--timer-delay:2000ms;--timer-release:200ms;--timer-height:4px;--timer-background-color:rgba(0,0,0,0.15);background-color:var(--timer-background-color);height:var(--timer-height);left:0;position:absolute;top:0;-webkit-transform:translateX(-100%);transform:translateX(-100%);width:100%;z-index:5}.awssld__timer--animated{transition:-webkit-transform var(--timer-delay) linear;transition:transform var(--timer-delay) linear;transition:transform var(--timer-delay) linear,-webkit-transform var(--timer-delay) linear;will-change:transform}.awssld__timer--run{-webkit-transform:translateX(0);transform:translateX(0)}.awssld__timer--fast{-webkit-transform:translateX(-.00001px);transform:translateX(-.00001px);transition:-webkit-transform calc(var(--timer-release)/2) linear;transition:transform calc(var(--timer-release)/2) linear;transition:transform calc(var(--timer-release)/2) linear,-webkit-transform calc(var(--timer-release)/2) linear}.awssld__timer--end{-webkit-transform:translateX(-.0001px);transform:translateX(-.0001px);transition:-webkit-transform var(--timer-release) linear;transition:transform var(--timer-release) linear;transition:transform var(--timer-release) linear,-webkit-transform var(--timer-release) linear}.awssld__timer--hidden{display:none}@-webkit-keyframes h{0%{-webkit-transform:translate3d(-100%,0,0);transform:translate3d(-100%,0,0)}to{-webkit-transform:translateZ(0);transform:translateZ(0)}}@keyframes h{0%{-webkit-transform:translate3d(-100%,0,0);transform:translate3d(-100%,0,0)}to{-webkit-transform:translateZ(0);transform:translateZ(0)}}@-webkit-keyframes i{0%{-webkit-transform:translate3d(100%,0,0);transform:translate3d(100%,0,0)}to{-webkit-transform:translateZ(0);transform:translateZ(0)}}@keyframes i{0%{-webkit-transform:translate3d(100%,0,0);transform:translate3d(100%,0,0)}to{-webkit-transform:translateZ(0);transform:translateZ(0)}}@-webkit-keyframes j{0%{-webkit-transform:translateZ(0);transform:translateZ(0)}to{-webkit-transform:translate3d(-100%,0,0);transform:translate3d(-100%,0,0)}}@keyframes j{0%{-webkit-transform:translateZ(0);transform:translateZ(0)}to{-webkit-transform:translate3d(-100%,0,0);transform:translate3d(-100%,0,0)}}@-webkit-keyframes k{0%{-webkit-transform:translateZ(0);transform:translateZ(0)}to{-webkit-transform:translate3d(100%,0,0);transform:translate3d(100%,0,0)}}@keyframes k{0%{-webkit-transform:translateZ(0);transform:translateZ(0)}to{-webkit-transform:translate3d(100%,0,0);transform:translate3d(100%,0,0)}}.awssld--cubeAnimation{--cube-animation-duration:675ms;--cube-animation-perspective:1800px;--cube-animation-ease-in:cubic-bezier(0.8,0,1,0.8);--cube-animation-ease-out:cubic-bezier(0,0.2,0.2,1);--cube-translateZ-distance:-225px}.awssld--cubeAnimation .awssld__container{-webkit-perspective:var(--cube-animation-perspective);perspective:var(--cube-animation-perspective)}.awssld--cubeAnimation .awssld--moveRight{-webkit-animation:n var(--cube-animation-duration) both var(--cube-animation-ease-in);animation:n var(--cube-animation-duration) both var(--cube-animation-ease-in);-webkit-transform-origin:0 50%;transform-origin:0 50%}.awssld--cubeAnimation .awssld--moveLeft{-webkit-animation:o var(--cube-animation-duration) both var(--cube-animation-ease-in);animation:o var(--cube-animation-duration) both var(--cube-animation-ease-in);-webkit-transform-origin:100% 50%;transform-origin:100% 50%}.awssld--cubeAnimation .awssld--exit.awssld--moveLeft{-webkit-animation:l var(--cube-animation-duration) both var(--cube-animation-ease-in);animation:l var(--cube-animation-duration) both var(--cube-animation-ease-in);-webkit-transform-origin:100% 50%;transform-origin:100% 50%}.awssld--cubeAnimation .awssld--exit.awssld--moveRight{-webkit-animation:m var(--cube-animation-duration) both var(--cube-animation-ease-in);animation:m var(--cube-animation-duration) both var(--cube-animation-ease-in);-webkit-transform-origin:0 50%;transform-origin:0 50%}@-webkit-keyframes l{50%{-webkit-animation-timing-function:var(--cube-animation-ease-out);animation-timing-function:var(--cube-animation-ease-out);-webkit-transform:translateX(-50%) translateZ(var(--cube-translateZ-distance)) rotateY(-45deg);transform:translateX(-50%) translateZ(var(--cube-translateZ-distance)) rotateY(-45deg)}to{-webkit-transform:translateX(-100%) rotateY(-90deg);transform:translateX(-100%) rotateY(-90deg)}}@keyframes l{50%{-webkit-animation-timing-function:var(--cube-animation-ease-out);animation-timing-function:var(--cube-animation-ease-out);-webkit-transform:translateX(-50%) translateZ(var(--cube-translateZ-distance)) rotateY(-45deg);transform:translateX(-50%) translateZ(var(--cube-translateZ-distance)) rotateY(-45deg)}to{-webkit-transform:translateX(-100%) rotateY(-90deg);transform:translateX(-100%) rotateY(-90deg)}}@-webkit-keyframes m{50%{-webkit-animation-timing-function:var(--cube-animation-ease-out);animation-timing-function:var(--cube-animation-ease-out);-webkit-transform:translateX(50%) translateZ(var(--cube-translateZ-distance)) rotateY(45deg);transform:translateX(50%) translateZ(var(--cube-translateZ-distance)) rotateY(45deg)}to{-webkit-transform:translateX(100%) rotateY(90deg);transform:translateX(100%) rotateY(90deg)}}@keyframes m{50%{-webkit-animation-timing-function:var(--cube-animation-ease-out);animation-timing-function:var(--cube-animation-ease-out);-webkit-transform:translateX(50%) translateZ(var(--cube-translateZ-distance)) rotateY(45deg);transform:translateX(50%) translateZ(var(--cube-translateZ-distance)) rotateY(45deg)}to{-webkit-transform:translateX(100%) rotateY(90deg);transform:translateX(100%) rotateY(90deg)}}@-webkit-keyframes n{0%{-webkit-transform:translateX(100%) rotateY(90deg);transform:translateX(100%) rotateY(90deg)}50%{-webkit-animation-timing-function:var(--cube-animation-ease-out);animation-timing-function:var(--cube-animation-ease-out);-webkit-transform:translateX(50%) translateZ(var(--cube-translateZ-distance)) rotateY(45deg);transform:translateX(50%) translateZ(var(--cube-translateZ-distance)) rotateY(45deg)}}@keyframes n{0%{-webkit-transform:translateX(100%) rotateY(90deg);transform:translateX(100%) rotateY(90deg)}50%{-webkit-animation-timing-function:var(--cube-animation-ease-out);animation-timing-function:var(--cube-animation-ease-out);-webkit-transform:translateX(50%) translateZ(var(--cube-translateZ-distance)) rotateY(45deg);transform:translateX(50%) translateZ(var(--cube-translateZ-distance)) rotateY(45deg)}}@-webkit-keyframes o{0%{-webkit-transform:translateX(-100%) rotateY(-90deg);transform:translateX(-100%) rotateY(-90deg)}50%{-webkit-animation-timing-function:var(--cube-animation-ease-out);animation-timing-function:var(--cube-animation-ease-out);-webkit-transform:translateX(-50%) translateZ(var(--cube-translateZ-distance)) rotateY(-45deg);transform:translateX(-50%) translateZ(var(--cube-translateZ-distance)) rotateY(-45deg)}}@keyframes o{0%{-webkit-transform:translateX(-100%) rotateY(-90deg);transform:translateX(-100%) rotateY(-90deg)}50%{-webkit-animation-timing-function:var(--cube-animation-ease-out);animation-timing-function:var(--cube-animation-ease-out);-webkit-transform:translateX(-50%) translateZ(var(--cube-translateZ-distance)) rotateY(-45deg);transform:translateX(-50%) translateZ(var(--cube-translateZ-distance)) rotateY(-45deg)}}.iconEdit_2_ui{margin-right:.3em;vertical-align:sub}.blogPostData_291c{font-size:.9rem}.blogPostDetailsFull_3kfx{flex-direction:column}.sidebar_2ahu{position:-webkit-sticky;position:sticky;top:calc(var(--ifm-navbar-height) + 2rem)}.sidebarItemTitle_2hhb{font-size:var(--ifm-h3-font-size);font-weight:var(--ifm-font-weight-bold)}.sidebarItemList_2xAf{font-size:.9rem;list-style:none;padding-left:0}.sidebarItem_2UVv{margin-top:.7rem}.tableOfContents_35-E{position:-webkit-sticky;position:sticky;top:calc(var(--ifm-navbar-height) + 1rem)}.lastUpdated_3DPF{font-size:smaller;font-style:italic;margin-top:.2rem}@media screen and (min-width:996px){body,html{text-rendering:optimizeLegibility}}@media (min-width:997px){.sidebar{height:calc(100vh - var(--ifm-navbar-height));overflow-y:auto;position:-webkit-sticky;position:sticky;top:var(--ifm-navbar-height)}.sidebar::-webkit-scrollbar{width:7px}.sidebar::-webkit-scrollbar-track{background:#f1f1f1;border-radius:10px}.sidebar::-webkit-scrollbar-thumb{background:#888;border-radius:10px}.sidebar::-webkit-scrollbar-thumb:hover{background:#555}div[class^=docPage_] div[class^=docItemContainer_]{max-width:none;padding:0 calc(var(--ifm-spacing-horizontal)*2)}.searchBox_1Doo{padding:var(--ifm-navbar-item-padding-vertical) var(--ifm-navbar-item-padding-horizontal)}.sidebar_15mo{display:flex;flex-direction:column;height:100%;max-height:100vh;padding-top:var(--ifm-navbar-height);position:-webkit-sticky;position:sticky;top:0;transition:opacity 50ms;width:var(--doc-sidebar-width)}.sidebarWithHideableNavbar_267A{padding-top:0}.sidebarHidden_2kNb{height:0;opacity:0;overflow:hidden;visibility:hidden}.sidebarLogo_3h0W{align-items:center;color:inherit!important;display:flex!important;margin:0 var(--ifm-navbar-padding-horizontal);max-height:var(--ifm-navbar-height);min-height:var(--ifm-navbar-height);text-decoration:none!important}.sidebarLogo_3h0W img{height:2rem;margin-right:.5rem}.menu_Bmed{flex-grow:1;padding:.5rem}.menuLinkText_2aKo{cursor:auto}.menuLinkText_2aKo:hover{background:none}.menuWithAnnouncementBar_2WvA{margin-bottom:var(--docusaurus-announcement-bar-height)}.collapseSidebarButton_1CGd{background-color:var(--ifm-button-background-color);border:1px solid var(--ifm-toc-border-color);border-radius:0;bottom:0;display:block!important;height:40px;position:-webkit-sticky;position:sticky}.collapseSidebarButtonIcon_3E-R{margin-top:4px;-webkit-transform:rotate(180deg);transform:rotate(180deg)}.expandSidebarButtonIcon_1naQ,html[dir=rtl] .collapseSidebarButtonIcon_3E-R{-webkit-transform:rotate(0);transform:rotate(0)}html[data-theme=dark] .collapseSidebarButton_1CGd,html[data-theme=dark] .collapsedDocSidebar_2JMH:focus,html[data-theme=dark] .collapsedDocSidebar_2JMH:hover{background-color:var(--collapse-button-bg-color-dark)}.collapsedDocSidebar_2JMH:focus,.collapsedDocSidebar_2JMH:hover,html[data-theme=dark] .collapseSidebarButton_1CGd:focus,html[data-theme=dark] .collapseSidebarButton_1CGd:hover{background-color:var(--ifm-color-emphasis-200)}.docMainContainer_3ufF{flex-grow:1;max-width:calc(100% - var(--doc-sidebar-width))}.docMainContainerEnhanced_3NYZ{max-width:calc(100% - var(--doc-sidebar-hidden-width))}.docSidebarContainer_3Kbt{border-right:1px solid var(--ifm-toc-border-color);-webkit-clip-path:inset(0);clip-path:inset(0);margin-top:calc(var(--ifm-navbar-height)*-1);transition:width var(--ifm-transition-fast) ease;width:var(--doc-sidebar-width);will-change:width}.docSidebarContainerHidden_3pA8{cursor:pointer;width:var(--doc-sidebar-hidden-width)}.collapsedDocSidebar_2JMH{align-items:center;display:flex;height:100%;justify-content:center;max-height:100vh;position:-webkit-sticky;position:sticky;top:0;transition:background-color var(--ifm-transition-fast) ease}html[dir=rtl] .expandSidebarButtonIcon_1naQ{-webkit-transform:rotate(180deg);transform:rotate(180deg)}.docItemWrapperEnhanced_2vyJ{max-width:calc(var(--ifm-container-width) + var(--doc-sidebar-width))!important}}@media only screen and (min-width:997px){.docItemCol_3FnS{max-width:75%!important}.lastUpdated_3DPF{text-align:right}}@media screen and (min-width:1024px){:root{--docusaurus-announcement-bar-height:30px}}@media (min-width:1440px){.container{max-width:var(--ifm-container-width-xl)}}@media (max-width:1200px){h1{--ifm-h1-font-size:calc(1.375rem + 1.5vw)}}@media screen and (max-width:999px){.components_1ZGx{height:900px}.components_1ZGx h3{font-size:2.5rem}}@media screen and (max-width:997px){.displayOnlyInLargeViewport_GrZ2{display:none!important}}@media (max-width:996px){.configuration__diagram svg #Line-6,.configuration__diagram svg .config-section-description,.footer__link-separator,.navbar__item,.table-of-contents,table.comparison td.description{display:none}.row .col.col.col{--ifm-col-width:100%;flex-basis:var(--ifm-col-width);margin-left:0;max-width:var(--ifm-col-width)}.footer{--ifm-footer-padding-horizontal:0}.footer__col{margin-bottom:calc(var(--ifm-spacing-vertical)*3)}.footer__link-item{display:block}.menu--responsive .menu__button,.navbar__toggle{display:inherit}.menu--responsive:not(.menu--show) .menu__list{display:none;opacity:0}.navbar>.container,.navbar>.container-fluid{padding:0}.navbar__search-input{width:9rem}.pills--block,.tabs--block{flex-direction:column}.pills--block .pills__item:not(:first-child){margin-top:var(--ifm-pills-spacing)}.pills--block .pills__item:not(:last-child){margin-bottom:var(--ifm-pills-spacing)}.tabs--block .tabs__item:not(:first-child){margin-top:var(--ifm-tabs-spacing)}.tabs--block .tabs__item:not(:last-child){margin-bottom:var(--ifm-tabs-spacing)}.container--bleed>.bleed,.container--bleed>section>.code-header,.container--bleed>section>p>img,.container--bleed>section>pre{max-width:100%;position:static;width:auto}.hero{min-height:100px;padding:2em 0}.hero .hero--buttons .button{--ifm-button-padding-horizontal:2rem;min-width:180px}.navbar .navbar__search{flex-grow:1;text-align:right}.navbar .navbar__search .navbar__search-input{width:12.5rem}.navbar .navbar-sidebar__items .navbar__item{display:inline-block}.searchBox_1Doo{position:absolute;right:var(--ifm-navbar-padding-horizontal)}.configuration__diagram{margin:0 auto;max-width:500px;overflow:hidden}.configuration__diagram svg{padding-left:20px;width:235%}}@media only screen and (max-width:996px){.searchQueryColumn_22lI,.searchResultsColumn_3okB{max-width:60%!important}.searchLogoColumn_21YU,.searchVersionColumn_1eqi{max-width:40%!important}.searchLogoColumn_21YU{padding-left:0!important}.sidebar_2ahu,.tableOfContents_35-E{display:none}.docItemContainer_gpai{padding:0 .3rem}}@media (max-width:750px){.DocSearch-Button-Keys,.DocSearch-Button-Placeholder,.DocSearch-Commands,.DocSearch-Hit-Tree{display:none}:root{--docsearch-spacing:10px;--docsearch-footer-height:40px}.DocSearch-Dropdown{height:100%;max-height:calc(var(--docsearch-vh, 1vh)*100 - var(--docsearch-searchbox-height) - var(--docsearch-spacing) - var(--docsearch-footer-height))}.DocSearch-Container{height:100vh;height:-webkit-fill-available;height:calc(var(--docsearch-vh, 1vh)*100);position:absolute}.DocSearch-Footer{border-radius:0;bottom:0;position:absolute}.DocSearch-Hit-content-wrapper{display:flex;position:relative;width:80%}.DocSearch-Modal{border-radius:0;box-shadow:none;height:100vh;height:-webkit-fill-available;height:calc(var(--docsearch-vh, 1vh)*100);margin:0;max-width:100%;width:100%}.DocSearch-Cancel{-webkit-appearance:none;appearance:none;background:none;border:0;color:var(--docsearch-highlight-color);cursor:pointer;display:inline-block;flex:none;font:inherit;font-size:1em;font-weight:500;margin-left:var(--docsearch-spacing);outline:0;overflow:hidden;padding:0;-webkit-user-select:none;-ms-user-select:none;user-select:none;white-space:nowrap}}@media screen and (max-width:576px){.announcementBarClose_38nx{width:35px}.announcementBarContent_3EUC{width:auto}.announcementBarCloseable_3myR{margin-right:35px}.searchQueryColumn_22lI{max-width:100%!important}.searchVersionColumn_1eqi{max-width:100%!important;padding-left:var(--ifm-spacing-horizontal)!important}}@media (max-width:520px){.awssld__controls{visibility:hidden}}@media (max-width:500px){.awssld__container{padding-bottom:calc(var(--slider-height-percentage)*1.25)}}@media (max-width:480px){.hero.hero--full-height{min-height:auto}.hero h1{font-size:2em}.hero .hero--subtitle{font-size:1em}.hero .hero--buttons .button{border-radius:.5rem;display:block;margin:0 0 1rem;min-width:auto;width:100%}.navbar .navbar__brand{margin-right:0}.navbar .navbar__brand .navbar__logo{max-width:130px}.navbar .navbar__search{margin-left:0}.navbar .navbar__search .navbar__search-input{width:100%}.navbar .navbar__search .search-bar-expanded{width:100%!important}.indexHeroBanner_1rfj,html[data-theme=dark] .indexHeroBanner_1rfj{-webkit-animation:none;animation:none;background-image:none;min-height:auto}.indexHeroDiagram_3nNK{margin:var(--ifm-spacing-vertical) 0 0 0}.componentsCanvas_2sJk,.components_1ZGx h3{display:none}.components_1ZGx{height:auto;margin-top:0;position:static}.components_1ZGx ul{grid-gap:1rem;display:grid;grid-template-columns:repeat(auto-fit,minmax(150px,1fr));margin:0;padding:0}.components_1ZGx ul li{display:grid}.components_1ZGx ul li a{background:var(--ifm-panel-background);border:1px solid var(--ifm-panel-border-color);border-radius:.25em;box-shadow:var(--ifm-panel-box-shadow);color:var(--ifm-panel-color);display:block;font-size:1em;margin:0;overflow:hidden;padding:.2em;text-align:center;text-overflow:ellipsis;white-space:nowrap}.components_1ZGx ul li a:hover{background:var(--ifm-panel-background-active);border-color:var(--ifm-panel-border-color-active);box-shadow:var(--ifm-panel-box-shadow-active);color:var(--ifm-panel-color-active);text-decoration:none}}@media (max-width:100px){.installationChecks_utNn{display:block}.installationChecks_utNn>div{text-align:center!important}}@media (pointer:fine){.thin-scrollbar::-webkit-scrollbar{height:var(--ifm-scrollbar-size);width:var(--ifm-scrollbar-size)}.thin-scrollbar::-webkit-scrollbar-track{background:var(--ifm-scrollbar-track-background-color);border-radius:10px}.thin-scrollbar::-webkit-scrollbar-thumb{background:var(--ifm-scrollbar-thumb-background-color);border-radius:10px}.thin-scrollbar::-webkit-scrollbar-thumb:hover{background:var(--ifm-scrollbar-thumb-hover-background-color)}}@media screen and (prefers-reduced-motion:reduce){.DocSearch-Reset{stroke-width:var(--docsearch-icon-stroke-width);-webkit-animation:none;animation:none;-webkit-appearance:none;appearance:none;background:none;border:0;border-radius:50%;color:var(--docsearch-icon-color);cursor:pointer;right:0}.DocSearch-Hit--deleting,.DocSearch-Hit--favoriting{transition:none}.DocSearch-Hit-action-button:focus,.DocSearch-Hit-action-button:hover{background:rgba(0,0,0,.2);transition:none}}@media print{.announcementBar_3WsW,.footer,.menu,.navbar,.pagination-nav,.table-of-contents{display:none}.tabs{page-break-inside:avoid}.codeBlockLines_39YC{white-space:pre-wrap}}