@rxdi/lit-html 0.7.156 → 0.7.158

package/dist/lit-html/polyfill-support.d.ts

@@ -1,67 +0,0 @@
-/**
- * @license
- * Copyright 2017 Google LLC
- * SPDX-License-Identifier: BSD-3-Clause
- */
-/**
- * lit-html patch to support browsers without native web components.
- *
- * This module should be used in addition to loading the web components
- * polyfills via @webcomponents/webcomponentjs. When using those polyfills
- * support for polyfilled Shadow DOM is automatic via the ShadyDOM polyfill.
- * Scoping classes are added to DOM nodes to facilitate CSS scoping that
- * simulates the style scoping Shadow DOM provides. ShadyDOM does this scoping
- * to all elements added to the DOM. This module provides an important
- * optimization for this process by pre-scoping lit-html template
- * DOM. This means ShadyDOM does not have to scope each instance of the
- * template DOM. Instead, each template is scoped only once.
- *
- * Creating scoped CSS is not covered by this module. It is, however, integrated
- * into the lit-element and @lit/reactive-element packages. See the ShadyCSS docs
- * for how to apply scoping to CSS:
- * https://github.com/webcomponents/polyfills/tree/master/packages/shadycss#usage.
- *
- * @packageDocumentation
- */
-interface RenderOptions {
-    readonly renderBefore?: ChildNode | null;
-    scope?: string;
-}
-interface ShadyTemplateResult {
-    strings: TemplateStringsArray;
-    ['_$litType$']?: string;
-}
-interface Directive {
-    __directive?: Directive;
-}
-interface DirectiveParent {
-    _$parent?: DirectiveParent;
-    __directive?: Directive;
-    __directives?: Array<Directive | undefined>;
-}
-interface PatchableChildPartConstructor {
-    new (...args: any[]): PatchableChildPart;
-}
-interface PatchableChildPart {
-    __directive?: Directive;
-    _$committedValue: unknown;
-    _$startNode: ChildNode;
-    _$endNode: ChildNode | null;
-    options: RenderOptions;
-    _$setValue(value: unknown, directiveParent: DirectiveParent): void;
-    _$getTemplate(result: ShadyTemplateResult): HTMLTemplateElement;
-}
-interface PatchableTemplate {
-    el: HTMLTemplateElement;
-}
-interface PatchableTemplateConstructor {
-    new (...args: any[]): PatchableTemplate;
-    createElement(html: string, options?: RenderOptions): HTMLTemplateElement;
-}
-interface PatchableTemplateInstance {
-    _$template: PatchableTemplate;
-}
-declare const styledScopes: Set<string>;
-declare const scopeCssStore: Map<string, string[]>;
-declare const ENABLE_SHADYDOM_NOPATCH = true;
-declare var DEV_MODE: boolean;

package/dist/lit-html/polyfill-support.js

@@ -1,185 +0,0 @@
-/**
- * @license
- * Copyright 2017 Google LLC
- * SPDX-License-Identifier: BSD-3-Clause
- */
-var _a;
-var _b;
-// Scopes that have had styling prepared. Note, must only be done once per
-// scope.
-const styledScopes = new Set();
-// Map of css per scope. This is collected during first scope render, used when
-// styling is prepared, and then discarded.
-const scopeCssStore = new Map();
-const ENABLE_SHADYDOM_NOPATCH = true;
-// Note, explicitly use `var` here so that this can be re-defined when
-// bundled.
-// eslint-disable-next-line no-var
-var DEV_MODE = true;
-/**
- * lit-html patches. These properties cannot be renamed.
- * * ChildPart.prototype._$getTemplate
- * * ChildPart.prototype._$setValue
- */
-(_a = globalThis[_b = `litHtmlPolyfillSupport${DEV_MODE ? `DevMode` : ``}`]) !== null && _a !== void 0 ? _a : (globalThis[_b] = (Template, ChildPart) => {
-    var _a, _b;
-    // polyfill-support is only needed if ShadyCSS or the ApplyShim is in use
-    // We test at the point of patching, which makes it safe to load
-    // webcomponentsjs and polyfill-support in either order
-    if (window.ShadyCSS === undefined ||
-        (window.ShadyCSS.nativeShadow && !window.ShadyCSS.ApplyShim)) {
-        return;
-    }
-    // console.log(
-    //   '%c Making lit-html compatible with ShadyDOM/CSS.',
-    //   'color: lightgreen; font-style: italic'
-    // );
-    const wrap = ENABLE_SHADYDOM_NOPATCH &&
-        ((_a = window.ShadyDOM) === null || _a === void 0 ? void 0 : _a.inUse) &&
-        ((_b = window.ShadyDOM) === null || _b === void 0 ? void 0 : _b.noPatch) === true
-        ? window.ShadyDOM.wrap
-        : (node) => node;
-    const needsPrepareStyles = (name) => name !== undefined && !styledScopes.has(name);
-    const cssForScope = (name) => {
-        let scopeCss = scopeCssStore.get(name);
-        if (scopeCss === undefined) {
-            scopeCssStore.set(name, (scopeCss = []));
-        }
-        return scopeCss;
-    };
-    const prepareStyles = (name, template) => {
-        // Get styles
-        const scopeCss = cssForScope(name);
-        const hasScopeCss = scopeCss.length !== 0;
-        if (hasScopeCss) {
-            const style = document.createElement('style');
-            style.textContent = scopeCss.join('\n');
-            // Note, it's important to add the style to the *end* of the template so
-            // it doesn't mess up part indices.
-            template.content.appendChild(style);
-        }
-        // Mark this scope as styled.
-        styledScopes.add(name);
-        // Remove stored data since it's no longer needed.
-        scopeCssStore.delete(name);
-        // ShadyCSS removes scopes and removes the style under ShadyDOM and leaves
-        // it under native Shadow DOM
-        window.ShadyCSS.prepareTemplateStyles(template, name);
-        // Note, under native Shadow DOM, the style is added to the beginning of the
-        // template. It must be moved to the *end* of the template so it doesn't
-        // mess up part indices.
-        if (hasScopeCss && window.ShadyCSS.nativeShadow) {
-            // If there were styles but the CSS text was empty, ShadyCSS will
-            // eliminate the style altogether, so the style here could be null
-            const style = template.content.querySelector('style');
-            if (style !== null) {
-                template.content.appendChild(style);
-            }
-        }
-    };
-    const scopedTemplateCache = new Map();
-    /**
-     * Override to extract style elements from the template
-     * and store all style.textContent in the shady scope data.
-     * Note, it's ok to patch Template since it's only used via ChildPart.
-     */
-    const originalCreateElement = Template.createElement;
-    Template.createElement = function (html, options) {
-        const element = originalCreateElement.call(Template, html, options);
-        const scope = options === null || options === void 0 ? void 0 : options.scope;
-        if (scope !== undefined) {
-            if (!window.ShadyCSS.nativeShadow) {
-                window.ShadyCSS.prepareTemplateDom(element, scope);
-            }
-            // Process styles only if this scope is being prepared. Otherwise,
-            // leave styles as is for back compat with Lit1.
-            if (needsPrepareStyles(scope)) {
-                const scopeCss = cssForScope(scope);
-                // Remove styles and store textContent.
-                const styles = element.content.querySelectorAll('style');
-                // Store the css in this template in the scope css and remove the <style>
-                // from the template _before_ the node-walk captures part indices
-                scopeCss.push(...Array.from(styles).map((style) => {
-                    var _a;
-                    (_a = style.parentNode) === null || _a === void 0 ? void 0 : _a.removeChild(style);
-                    return style.textContent;
-                }));
-            }
-        }
-        return element;
-    };
-    const renderContainer = document.createDocumentFragment();
-    const renderContainerMarker = document.createComment('');
-    const childPartProto = ChildPart.prototype;
-    /**
-     * Patch to apply gathered css via ShadyCSS. This is done only once per scope.
-     */
-    const setValue = childPartProto._$setValue;
-    childPartProto._$setValue = function (value, directiveParent = this) {
-        var _a, _b, _c;
-        const container = wrap(this._$startNode).parentNode;
-        const scope = (_a = this.options) === null || _a === void 0 ? void 0 : _a.scope;
-        if (container instanceof ShadowRoot && needsPrepareStyles(scope)) {
-            // Note, @apply requires outer => inner scope rendering on initial
-            // scope renders to apply property values correctly. Style preparation
-            // is tied to rendering into `shadowRoot`'s and this is typically done by
-            // custom elements. If this is done in `connectedCallback`, as is typical,
-            // the code below ensures the right order since content is rendered
-            // into a fragment first so the hosting element can prepare styles first.
-            // If rendering is done in the constructor, this won't work, but that's
-            // not supported in ShadyDOM anyway.
-            const startNode = this._$startNode;
-            const endNode = this._$endNode;
-            // Temporarily move this part into the renderContainer.
-            renderContainer.appendChild(renderContainerMarker);
-            this._$startNode = renderContainerMarker;
-            this._$endNode = null;
-            // Note, any nested template results render here and their styles will
-            // be extracted and collected.
-            setValue.call(this, value, directiveParent);
-            // Get the template for this result or create a dummy one if a result
-            // is not being rendered.
-            // This property needs to remain unminified.
-            const template = ((_b = value) === null || _b === void 0 ? void 0 : _b['_$litType$'])
-                ? this._$committedValue._$template.el
-                : document.createElement('template');
-            prepareStyles(scope, template);
-            // Note, this is the temporary startNode.
-            renderContainer.removeChild(renderContainerMarker);
-            // When using native Shadow DOM, include prepared style in shadowRoot.
-            if ((_c = window.ShadyCSS) === null || _c === void 0 ? void 0 : _c.nativeShadow) {
-                const style = template.content.querySelector('style');
-                if (style !== null) {
-                    renderContainer.appendChild(style.cloneNode(true));
-                }
-            }
-            container.insertBefore(renderContainer, endNode);
-            // Move part back to original container.
-            this._$startNode = startNode;
-            this._$endNode = endNode;
-        }
-        else {
-            setValue.call(this, value, directiveParent);
-        }
-    };
-    /**
-     * Patch ChildPart._$getTemplate to look up templates in a cache bucketed
-     * by element name.
-     */
-    childPartProto._$getTemplate = function (result) {
-        var _a;
-        const scope = (_a = this.options) === null || _a === void 0 ? void 0 : _a.scope;
-        let templateCache = scopedTemplateCache.get(scope);
-        if (templateCache === undefined) {
-            scopedTemplateCache.set(scope, (templateCache = new Map()));
-        }
-        let template = templateCache.get(result.strings);
-        if (template === undefined) {
-            templateCache.set(result.strings, (template = new Template(result, this.options)));
-        }
-        return template;
-    };
-});
-if (ENABLE_SHADYDOM_NOPATCH) {
-    globalThis[`litHtmlPolyfillSupport${DEV_MODE ? `DevMode` : ``}`].noPatchSupported = ENABLE_SHADYDOM_NOPATCH;
-}

package/dist/lit-html/private-ssr-support.d.ts

@@ -1,52 +0,0 @@
-/**
- * @license
- * Copyright 2019 Google LLC
- * SPDX-License-Identifier: BSD-3-Clause
- */
-import { Directive, PartInfo, DirectiveClass, DirectiveResult } from './directive';
-import { AttributePart, Part, Disconnectable } from './lit-html';
-export type { Template } from './lit-html';
-/**
- * END USERS SHOULD NOT RELY ON THIS OBJECT.
- *
- * We currently do not make a mangled rollup build of the lit-ssr code. In order
- * to keep a number of (otherwise private) top-level exports mangled in the
- * client side code, we export a _$LH object containing those members (or
- * helper methods for accessing private fields of those members), and then
- * re-export them for use in lit-ssr. This keeps lit-ssr agnostic to whether the
- * client-side code is being used in `dev` mode or `prod` mode.
- * @private
- */
-export declare const _$LH: {
-    boundAttributeSuffix: string;
-    marker: string;
-    markerMatch: string;
-    HTML_RESULT: number;
-    getTemplateHtml: (strings: TemplateStringsArray, type: 1 | 2) => [any, string[]];
-    overrideDirectiveResolve: (directiveClass: new (part: PartInfo) => Directive & {
-        render(): unknown;
-    }, resolveOverrideFn: (directive: Directive, values: unknown[]) => unknown) => {
-        new (part: PartInfo): {
-            _$resolve(this: Directive, _part: Part, values: unknown[]): unknown;
-            __part: Part;
-            __attributeIndex: number;
-            __directive?: Directive;
-            _$parent: Disconnectable;
-            _$disconnectableChildren?: Set<Disconnectable>;
-            _$notifyDirectiveConnectionChanged?(isConnected: boolean): void;
-            readonly _$isConnected: boolean;
-            _$initialize(part: Part, parent: Disconnectable, attributeIndex: number): void;
-            render: ((...props: unknown[]) => unknown) & (() => unknown);
-            update(_part: Part, props: unknown[]): unknown;
-        };
-    };
-    setDirectiveClass(value: DirectiveResult, directiveClass: DirectiveClass): void;
-    getAttributePartCommittedValue: (part: AttributePart, value: unknown, index: number | undefined) => unknown;
-    connectedDisconnectable: (props?: object) => Disconnectable;
-    resolveDirective: (part: import("./lit-html").ChildPart | AttributePart | import("./lit-html").ElementPart, value: unknown, parent?: import("./lit-html").DirectiveParent, attributeIndex?: number) => unknown;
-    AttributePart: typeof AttributePart;
-    PropertyPart: typeof import("./lit-html").PropertyPart;
-    BooleanAttributePart: typeof import("./lit-html").BooleanAttributePart;
-    EventPart: typeof import("./lit-html").EventPart;
-    ElementPart: typeof import("./lit-html").ElementPart;
-};

package/dist/lit-html/private-ssr-support.js

@@ -1,54 +0,0 @@
-"use strict";
-/**
- * @license
- * Copyright 2019 Google LLC
- * SPDX-License-Identifier: BSD-3-Clause
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports._$LH = void 0;
-const lit_html_1 = require("./lit-html");
-/**
- * END USERS SHOULD NOT RELY ON THIS OBJECT.
- *
- * We currently do not make a mangled rollup build of the lit-ssr code. In order
- * to keep a number of (otherwise private) top-level exports mangled in the
- * client side code, we export a _$LH object containing those members (or
- * helper methods for accessing private fields of those members), and then
- * re-export them for use in lit-ssr. This keeps lit-ssr agnostic to whether the
- * client-side code is being used in `dev` mode or `prod` mode.
- * @private
- */
-exports._$LH = {
-    boundAttributeSuffix: lit_html_1._$LH._boundAttributeSuffix,
-    marker: lit_html_1._$LH._marker,
-    markerMatch: lit_html_1._$LH._markerMatch,
-    HTML_RESULT: lit_html_1._$LH._HTML_RESULT,
-    getTemplateHtml: lit_html_1._$LH._getTemplateHtml,
-    overrideDirectiveResolve: (directiveClass, resolveOverrideFn) => class extends directiveClass {
-        _$resolve(_part, values) {
-            return resolveOverrideFn(this, values);
-        }
-    },
-    setDirectiveClass(value, directiveClass) {
-        // This property needs to remain unminified.
-        value['_$litDirective$'] = directiveClass;
-    },
-    getAttributePartCommittedValue: (part, value, index) => {
-        // Use the part setter to resolve directives/concatenate multiple parts
-        // into a final value (captured by passing in a commitValue override)
-        let committedValue = lit_html_1.noChange;
-        // Note that _commitValue need not be in `stableProperties` because this
-        // method is only run on `AttributePart`s created by lit-ssr using the same
-        // version of the library as this file
-        part._commitValue = (value) => (committedValue = value);
-        part._$setValue(value, part, index);
-        return committedValue;
-    },
-    connectedDisconnectable: (props) => (Object.assign(Object.assign({}, props), { _$isConnected: true })),
-    resolveDirective: lit_html_1._$LH._resolveDirective,
-    AttributePart: lit_html_1._$LH._AttributePart,
-    PropertyPart: lit_html_1._$LH._PropertyPart,
-    BooleanAttributePart: lit_html_1._$LH._BooleanAttributePart,
-    EventPart: lit_html_1._$LH._EventPart,
-    ElementPart: lit_html_1._$LH._ElementPart,
-};

package/dist/lit-html/static.d.ts

@@ -1,58 +0,0 @@
-/**
- * @license
- * Copyright 2020 Google LLC
- * SPDX-License-Identifier: BSD-3-Clause
- */
-import { html as coreHtml, svg as coreSvg, TemplateResult } from './lit-html';
-/**
- * Wraps a string so that it behaves like part of the static template
- * strings instead of a dynamic value.
- *
- * Users must take care to ensure that adding the static string to the template
- * results in well-formed HTML, or else templates may break unexpectedly.
- *
- * Note that this function is unsafe to use on untrusted content, as it will be
- * directly parsed into HTML. Do not pass user input to this function
- * without sanitizing it.
- *
- * Static values can be changed, but they will cause a complete re-render
- * since they effectively create a new template.
- */
-export declare const unsafeStatic: (value: string) => {
-    _$litStatic$: string;
-};
-/**
- * Tags a string literal so that it behaves like part of the static template
- * strings instead of a dynamic value.
- *
- * The only values that may be used in template expressions are other tagged
- * `literal` results or `unsafeStatic` values (note that untrusted content
- * should never be passed to `unsafeStatic`).
- *
- * Users must take care to ensure that adding the static string to the template
- * results in well-formed HTML, or else templates may break unexpectedly.
- *
- * Static values can be changed, but they will cause a complete re-render since
- * they effectively create a new template.
- */
-export declare const literal: (strings: TemplateStringsArray, ...values: unknown[]) => {
-    _$litStatic$: unknown;
-};
-/**
- * Wraps a lit-html template tag (`html` or `svg`) to add static value support.
- */
-export declare const withStatic: (coreTag: typeof coreHtml | typeof coreSvg) => (strings: TemplateStringsArray, ...values: unknown[]) => TemplateResult;
-/**
- * Interprets a template literal as an HTML template that can efficiently
- * render to and update a container.
- *
- * Includes static value support from `lit-html/static`.
- */
-export declare const html: (strings: TemplateStringsArray, ...values: unknown[]) => TemplateResult;
-/**
- * Interprets a template literal as an SVG template that can efficiently
- * render to and update a container.
- *
- * Includes static value support from `lit-html/static`.
- */
-export declare const svg: (strings: TemplateStringsArray, ...values: unknown[]) => TemplateResult;

package/dist/lit-html/static.js

@@ -1,114 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.svg = exports.html = exports.withStatic = exports.literal = exports.unsafeStatic = void 0;
-/**
- * @license
- * Copyright 2020 Google LLC
- * SPDX-License-Identifier: BSD-3-Clause
- */
-const lit_html_1 = require("./lit-html");
-/**
- * Wraps a string so that it behaves like part of the static template
- * strings instead of a dynamic value.
- *
- * Users must take care to ensure that adding the static string to the template
- * results in well-formed HTML, or else templates may break unexpectedly.
- *
- * Note that this function is unsafe to use on untrusted content, as it will be
- * directly parsed into HTML. Do not pass user input to this function
- * without sanitizing it.
- *
- * Static values can be changed, but they will cause a complete re-render
- * since they effectively create a new template.
- */
-const unsafeStatic = (value) => ({
-    ['_$litStatic$']: value,
-});
-exports.unsafeStatic = unsafeStatic;
-const textFromStatic = (value) => {
-    if (value['_$litStatic$'] !== undefined) {
-        return value['_$litStatic$'];
-    }
-    else {
-        throw new Error(`Value passed to 'literal' function must be a 'literal' result: ${value}. Use 'unsafeStatic' to pass non-literal values, but
-            take care to ensure page security.`);
-    }
-};
-/**
- * Tags a string literal so that it behaves like part of the static template
- * strings instead of a dynamic value.
- *
- * The only values that may be used in template expressions are other tagged
- * `literal` results or `unsafeStatic` values (note that untrusted content
- * should never be passed to `unsafeStatic`).
- *
- * Users must take care to ensure that adding the static string to the template
- * results in well-formed HTML, or else templates may break unexpectedly.
- *
- * Static values can be changed, but they will cause a complete re-render since
- * they effectively create a new template.
- */
-const literal = (strings, ...values) => ({
-    ['_$litStatic$']: values.reduce((acc, v, idx) => acc + textFromStatic(v) + strings[idx + 1], strings[0]),
-});
-exports.literal = literal;
-const stringsCache = new Map();
-/**
- * Wraps a lit-html template tag (`html` or `svg`) to add static value support.
- */
-const withStatic = (coreTag) => (strings, ...values) => {
-    var _a;
-    const l = values.length;
-    let staticValue;
-    let dynamicValue;
-    const staticStrings = [];
-    const dynamicValues = [];
-    let i = 0;
-    let hasStatics = false;
-    let s;
-    while (i < l) {
-        s = strings[i];
-        // Collect any unsafeStatic values, and their following template strings
-        // so that we treat a run of template strings and unsafe static values as
-        // a single template string.
-        while (i < l &&
-            ((dynamicValue = values[i]),
-                (staticValue = (_a = dynamicValue) === null || _a === void 0 ? void 0 : _a['_$litStatic$'])) !==
-                undefined) {
-            s += staticValue + strings[++i];
-            hasStatics = true;
-        }
-        dynamicValues.push(dynamicValue);
-        staticStrings.push(s);
-        i++;
-    }
-    // If the last value isn't static (which would have consumed the last
-    // string), then we need to add the last string.
-    if (i === l) {
-        staticStrings.push(strings[l]);
-    }
-    if (hasStatics) {
-        const key = staticStrings.join('$$lit$$');
-        strings = stringsCache.get(key);
-        if (strings === undefined) {
-            stringsCache.set(key, (strings = staticStrings));
-        }
-        values = dynamicValues;
-    }
-    return coreTag(strings, ...values);
-};
-exports.withStatic = withStatic;
-/**
- * Interprets a template literal as an HTML template that can efficiently
- * render to and update a container.
- *
- * Includes static value support from `lit-html/static`.
- */
-exports.html = (0, exports.withStatic)(lit_html_1.html);
-/**
- * Interprets a template literal as an SVG template that can efficiently
- * render to and update a container.
- *
- * Includes static value support from `lit-html/static`.
- */
-exports.svg = (0, exports.withStatic)(lit_html_1.svg);

package/dist/reactive-element/css-tag.d.ts

@@ -1,64 +0,0 @@
-/**
- * @license
- * Copyright 2019 Google LLC
- * SPDX-License-Identifier: BSD-3-Clause
- */
-/**
- * Whether the current browser supports `adoptedStyleSheets`.
- */
-export declare const supportsAdoptingStyleSheets: boolean;
-/**
- * A CSSResult or native CSSStyleSheet.
- *
- * In browsers that support constructible CSS style sheets, CSSStyleSheet
- * object can be used for styling along side CSSResult from the `css`
- * template tag.
- */
-export declare type CSSResultOrNative = CSSResult | CSSStyleSheet;
-export declare type CSSResultArray = Array<CSSResultOrNative | CSSResultArray>;
-/**
- * A single CSSResult, CSSStyleSheet, or an array or nested arrays of those.
- */
-export declare type CSSResultGroup = CSSResultOrNative | CSSResultArray;
-/**
- * A container for a string of CSS text, that may be used to create a CSSStyleSheet.
- *
- * CSSResult is the return value of `css`-tagged template literals and
- * `unsafeCSS()`. In order to ensure that CSSResults are only created via the
- * `css` tag and `unsafeCSS()`, CSSResult cannot be constructed directly.
- */
-export declare class CSSResult {
-    ['_$cssResult$']: boolean;
-    readonly cssText: string;
-    private constructor();
-    get styleSheet(): CSSStyleSheet | undefined;
-    toString(): string;
-}
-/**
- * Wrap a value for interpolation in a [[`css`]] tagged template literal.
- *
- * This is unsafe because untrusted CSS text can be used to phone home
- * or exfiltrate data to an attacker controlled site. Take care to only use
- * this with trusted input.
- */
-export declare const unsafeCSS: (value: unknown) => CSSResult;
-/**
- * A template literal tag which can be used with LitElement's
- * [[LitElement.styles | `styles`]] property to set element styles.
- *
- * For security reasons, only literal string values and number may be used in
- * embedded expressions. To incorporate non-literal values [[`unsafeCSS`]] may
- * be used inside an expression.
- */
-export declare const css: (strings: TemplateStringsArray, ...values: (CSSResultGroup | number)[]) => CSSResult;
-/**
- * Applies the given styles to a `shadowRoot`. When Shadow DOM is
- * available but `adoptedStyleSheets` is not, styles are appended to the
- * `shadowRoot` to [mimic spec behavior](https://wicg.github.io/construct-stylesheets/#using-constructed-stylesheets).
- * Note, when shimming is used, any styles that are subsequently placed into
- * the shadowRoot should be placed *before* any shimmed adopted styles. This
- * will match spec behavior that gives adopted sheets precedence over styles in
- * shadowRoot.
- */
-export declare const adoptStyles: (renderRoot: ShadowRoot, styles: Array<CSSResultOrNative>) => void;
-export declare const getCompatibleStyle: (s: CSSResultOrNative) => CSSResultOrNative;