diff options
author | Michal Klocek <michal.klocek@qt.io> | 2024-05-06 12:49:24 +0200 |
---|---|---|
committer | Michal Klocek <michal.klocek@qt.io> | 2024-05-07 09:51:27 +0000 |
commit | 6c04301ecbe57a84d6cc82776b9de9d27fd10076 (patch) | |
tree | ed50ecf908d5dec121b5646c69f9da2e6415965f | |
parent | bdd23a0120a16de636b411a50c92cd273c4e80fa (diff) |
Missing node module sourcesupstream-master
* lit-html
* lit-element
* lit-reactive-element
* lit-directive
Change-Id: Idb8413411ad45acd9350e5f155c39c9789f15b95
Reviewed-on: https://codereview.qt-project.org/c/qt/qtwebengine-chromium/+/558486
Reviewed-by: Allan Sandfeld Jensen <allan.jensen@qt.io>
68 files changed, 3233 insertions, 0 deletions
diff --git a/chromium/third_party/node/node_modules/@lit/reactive-element/LICENSE b/chromium/third_party/node/node_modules/@lit/reactive-element/LICENSE new file mode 100644 index 00000000000..be7a97b60d7 --- /dev/null +++ b/chromium/third_party/node/node_modules/@lit/reactive-element/LICENSE @@ -0,0 +1,28 @@ +BSD 3-Clause License + +Copyright (c) 2017 Google LLC. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + +1. Redistributions of source code must retain the above copyright notice, this + list of conditions and the following disclaimer. + +2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions and the following disclaimer in the documentation + and/or other materials provided with the distribution. + +3. Neither the name of the copyright holder nor the names of its + contributors may be used to endorse or promote products derived from + this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE +FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR +SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, +OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
\ No newline at end of file diff --git a/chromium/third_party/node/node_modules/@lit/reactive-element/css-tag.d.ts b/chromium/third_party/node/node_modules/@lit/reactive-element/css-tag.d.ts new file mode 100644 index 00000000000..b94d2d090bc --- /dev/null +++ b/chromium/third_party/node/node_modules/@lit/reactive-element/css-tag.d.ts @@ -0,0 +1,67 @@ +/** + * @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 type CSSResultOrNative = CSSResult | CSSStyleSheet; +export type CSSResultArray = Array<CSSResultOrNative | CSSResultArray>; +/** + * A single CSSResult, CSSStyleSheet, or an array or nested arrays of those. + */ +export 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 _styleSheet?; + private _strings; + private constructor(); + get styleSheet(): CSSStyleSheet | undefined; + toString(): string; +} +/** + * Wrap a value for interpolation in a {@linkcode 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 + * {@linkcode LitElement.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 {@linkcode 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; +//# sourceMappingURL=css-tag.d.ts.map
\ No newline at end of file diff --git a/chromium/third_party/node/node_modules/@lit/reactive-element/css-tag.js b/chromium/third_party/node/node_modules/@lit/reactive-element/css-tag.js new file mode 100644 index 00000000000..20aee2a2ac6 --- /dev/null +++ b/chromium/third_party/node/node_modules/@lit/reactive-element/css-tag.js @@ -0,0 +1,7 @@ +/** + * @license + * Copyright 2019 Google LLC + * SPDX-License-Identifier: BSD-3-Clause + */ +const t=globalThis,e=t.ShadowRoot&&(void 0===t.ShadyCSS||t.ShadyCSS.nativeShadow)&&"adoptedStyleSheets"in Document.prototype&&"replace"in CSSStyleSheet.prototype,s=Symbol(),o=new WeakMap;class n{constructor(t,e,o){if(this._$cssResult$=!0,o!==s)throw Error("CSSResult is not constructable. Use `unsafeCSS` or `css` instead.");this.cssText=t,this.t=e}get styleSheet(){let t=this.o;const s=this.t;if(e&&void 0===t){const e=void 0!==s&&1===s.length;e&&(t=o.get(s)),void 0===t&&((this.o=t=new CSSStyleSheet).replaceSync(this.cssText),e&&o.set(s,t))}return t}toString(){return this.cssText}}const r=t=>new n("string"==typeof t?t:t+"",void 0,s),i=(t,...e)=>{const o=1===t.length?t[0]:e.reduce(((e,s,o)=>e+(t=>{if(!0===t._$cssResult$)return t.cssText;if("number"==typeof t)return t;throw Error("Value passed to 'css' function must be a 'css' function result: "+t+". Use 'unsafeCSS' to pass non-literal values, but take care to ensure page security.")})(s)+t[o+1]),t[0]);return new n(o,t,s)},S=(s,o)=>{if(e)s.adoptedStyleSheets=o.map((t=>t instanceof CSSStyleSheet?t:t.styleSheet));else for(const e of o){const o=document.createElement("style"),n=t.litNonce;void 0!==n&&o.setAttribute("nonce",n),o.textContent=e.cssText,s.appendChild(o)}},c=e?t=>t:t=>t instanceof CSSStyleSheet?(t=>{let e="";for(const s of t.cssRules)e+=s.cssText;return r(e)})(t):t;export{n as CSSResult,S as adoptStyles,i as css,c as getCompatibleStyle,e as supportsAdoptingStyleSheets,r as unsafeCSS}; +//# sourceMappingURL=css-tag.js.map diff --git a/chromium/third_party/node/node_modules/@lit/reactive-element/reactive-controller.d.ts b/chromium/third_party/node/node_modules/@lit/reactive-element/reactive-controller.d.ts new file mode 100644 index 00000000000..3a35f108c40 --- /dev/null +++ b/chromium/third_party/node/node_modules/@lit/reactive-element/reactive-controller.d.ts @@ -0,0 +1,77 @@ +/** + * @license + * Copyright 2021 Google LLC + * SPDX-License-Identifier: BSD-3-Clause + */ +/** + * An object that can host Reactive Controllers and call their lifecycle + * callbacks. + */ +export interface ReactiveControllerHost { + /** + * Adds a controller to the host, which sets up the controller's lifecycle + * methods to be called with the host's lifecycle. + */ + addController(controller: ReactiveController): void; + /** + * Removes a controller from the host. + */ + removeController(controller: ReactiveController): void; + /** + * Requests a host update which is processed asynchronously. The update can + * be waited on via the `updateComplete` property. + */ + requestUpdate(): void; + /** + * Returns a Promise that resolves when the host has completed updating. + * The Promise value is a boolean that is `true` if the element completed the + * update without triggering another update. The Promise result is `false` if + * a property was set inside `updated()`. If the Promise is rejected, an + * exception was thrown during the update. + * + * @return A promise of a boolean that indicates if the update resolved + * without triggering another update. + */ + readonly updateComplete: Promise<boolean>; +} +/** + * A Reactive Controller is an object that enables sub-component code + * organization and reuse by aggregating the state, behavior, and lifecycle + * hooks related to a single feature. + * + * Controllers are added to a host component, or other object that implements + * the `ReactiveControllerHost` interface, via the `addController()` method. + * They can hook their host components's lifecycle by implementing one or more + * of the lifecycle callbacks, or initiate an update of the host component by + * calling `requestUpdate()` on the host. + */ +export interface ReactiveController { + /** + * Called when the host is connected to the component tree. For custom + * element hosts, this corresponds to the `connectedCallback()` lifecycle, + * which is only called when the component is connected to the document. + */ + hostConnected?(): void; + /** + * Called when the host is disconnected from the component tree. For custom + * element hosts, this corresponds to the `disconnectedCallback()` lifecycle, + * which is called the host or an ancestor component is disconnected from the + * document. + */ + hostDisconnected?(): void; + /** + * Called during the client-side host update, just before the host calls + * its own update. + * + * Code in `update()` can depend on the DOM as it is not called in + * server-side rendering. + */ + hostUpdate?(): void; + /** + * Called after a host update, just before the host calls firstUpdated and + * updated. It is not called in server-side rendering. + * + */ + hostUpdated?(): void; +} +//# sourceMappingURL=reactive-controller.d.ts.map
\ No newline at end of file diff --git a/chromium/third_party/node/node_modules/@lit/reactive-element/reactive-element.d.ts b/chromium/third_party/node/node_modules/@lit/reactive-element/reactive-element.d.ts new file mode 100644 index 00000000000..654e5d21dea --- /dev/null +++ b/chromium/third_party/node/node_modules/@lit/reactive-element/reactive-element.d.ts @@ -0,0 +1,744 @@ +/** + * @license + * Copyright 2017 Google LLC + * SPDX-License-Identifier: BSD-3-Clause + */ +/** + * Use this module if you want to create your own base class extending + * {@link ReactiveElement}. + * @packageDocumentation + */ +import { CSSResultGroup, CSSResultOrNative } from './css-tag.js'; +import type { ReactiveController, ReactiveControllerHost } from './reactive-controller.js'; +export * from './css-tag.js'; +export type { ReactiveController, ReactiveControllerHost, } from './reactive-controller.js'; +/** + * Contains types that are part of the unstable debug API. + * + * Everything in this API is not stable and may change or be removed in the future, + * even on patch releases. + */ +export declare namespace ReactiveUnstable { + /** + * When Lit is running in dev mode and `window.emitLitDebugLogEvents` is true, + * we will emit 'lit-debug' events to window, with live details about the update and render + * lifecycle. These can be useful for writing debug tooling and visualizations. + * + * Please be aware that running with window.emitLitDebugLogEvents has performance overhead, + * making certain operations that are normally very cheap (like a no-op render) much slower, + * because we must copy data and dispatch events. + */ + namespace DebugLog { + type Entry = Update; + interface Update { + kind: 'update'; + } + } +} +/** + * Converts property values to and from attribute values. + */ +export interface ComplexAttributeConverter<Type = unknown, TypeHint = unknown> { + /** + * Called to convert an attribute value to a property + * value. + */ + fromAttribute?(value: string | null, type?: TypeHint): Type; + /** + * Called to convert a property value to an attribute + * value. + * + * It returns unknown instead of string, to be compatible with + * https://github.com/WICG/trusted-types (and similar efforts). + */ + toAttribute?(value: Type, type?: TypeHint): unknown; +} +type AttributeConverter<Type = unknown, TypeHint = unknown> = ComplexAttributeConverter<Type> | ((value: string | null, type?: TypeHint) => Type); +/** + * Defines options for a property accessor. + */ +export interface PropertyDeclaration<Type = unknown, TypeHint = unknown> { + /** + * When set to `true`, indicates the property is internal private state. The + * property should not be set by users. When using TypeScript, this property + * should be marked as `private` or `protected`, and it is also a common + * practice to use a leading `_` in the name. The property is not added to + * `observedAttributes`. + */ + readonly state?: boolean; + /** + * Indicates how and whether the property becomes an observed attribute. + * If the value is `false`, the property is not added to `observedAttributes`. + * If true or absent, the lowercased property name is observed (e.g. `fooBar` + * becomes `foobar`). If a string, the string value is observed (e.g + * `attribute: 'foo-bar'`). + */ + readonly attribute?: boolean | string; + /** + * Indicates the type of the property. This is used only as a hint for the + * `converter` to determine how to convert the attribute + * to/from a property. + */ + readonly type?: TypeHint; + /** + * Indicates how to convert the attribute to/from a property. If this value + * is a function, it is used to convert the attribute value a the property + * value. If it's an object, it can have keys for `fromAttribute` and + * `toAttribute`. If no `toAttribute` function is provided and + * `reflect` is set to `true`, the property value is set directly to the + * attribute. A default `converter` is used if none is provided; it supports + * `Boolean`, `String`, `Number`, `Object`, and `Array`. Note, + * when a property changes and the converter is used to update the attribute, + * the property is never updated again as a result of the attribute changing, + * and vice versa. + */ + readonly converter?: AttributeConverter<Type, TypeHint>; + /** + * Indicates if the property should reflect to an attribute. + * If `true`, when the property is set, the attribute is set using the + * attribute name determined according to the rules for the `attribute` + * property option and the value of the property converted using the rules + * from the `converter` property option. + */ + readonly reflect?: boolean; + /** + * A function that indicates if a property should be considered changed when + * it is set. The function should take the `newValue` and `oldValue` and + * return `true` if an update should be requested. + */ + hasChanged?(value: Type, oldValue: Type): boolean; + /** + * Indicates whether an accessor will be created for this property. By + * default, an accessor will be generated for this property that requests an + * update when set. If this flag is `true`, no accessor will be created, and + * it will be the user's responsibility to call + * `this.requestUpdate(propertyName, oldValue)` to request an update when + * the property changes. + */ + readonly noAccessor?: boolean; +} +/** + * Map of properties to PropertyDeclaration options. For each property an + * accessor is made, and the property is processed according to the + * PropertyDeclaration options. + */ +export interface PropertyDeclarations { + readonly [key: string]: PropertyDeclaration; +} +type PropertyDeclarationMap = Map<PropertyKey, PropertyDeclaration>; +/** + * A Map of property keys to values. + * + * Takes an optional type parameter T, which when specified as a non-any, + * non-unknown type, will make the Map more strongly-typed, associating the map + * keys with their corresponding value type on T. + * + * Use `PropertyValues<this>` when overriding ReactiveElement.update() and + * other lifecycle methods in order to get stronger type-checking on keys + * and values. + */ +export type PropertyValues<T = any> = T extends object ? PropertyValueMap<T> : Map<PropertyKey, unknown>; +/** + * Do not use, instead prefer {@linkcode PropertyValues}. + */ +export interface PropertyValueMap<T> extends Map<PropertyKey, unknown> { + get<K extends keyof T>(k: K): T[K] | undefined; + set<K extends keyof T>(key: K, value: T[K]): this; + has<K extends keyof T>(k: K): boolean; + delete<K extends keyof T>(k: K): boolean; +} +export declare const defaultConverter: ComplexAttributeConverter; +export interface HasChanged { + (value: unknown, old: unknown): boolean; +} +/** + * Change function that returns true if `value` is different from `oldValue`. + * This method is used as the default for a property's `hasChanged` function. + */ +export declare const notEqual: HasChanged; +/** + * A string representing one of the supported dev mode warning categories. + */ +export type WarningKind = 'change-in-update' | 'migration' | 'async-perform-update'; +export type Initializer = (element: ReactiveElement) => void; +declare global { + interface SymbolConstructor { + readonly metadata: unique symbol; + } +} +declare global { + var litPropertyMetadata: WeakMap<object, Map<PropertyKey, PropertyDeclaration>>; +} +/** + * Base element class which manages element properties and attributes. When + * properties change, the `update` method is asynchronously called. This method + * should be supplied by subclasses to render updates as desired. + * @noInheritDoc + */ +export declare abstract class ReactiveElement extends HTMLElement implements ReactiveControllerHost { + /** + * Read or set all the enabled warning categories for this class. + * + * This property is only used in development builds. + * + * @nocollapse + * @category dev-mode + */ + static enabledWarnings?: WarningKind[]; + /** + * Enable the given warning category for this class. + * + * This method only exists in development builds, so it should be accessed + * with a guard like: + * + * ```ts + * // Enable for all ReactiveElement subclasses + * ReactiveElement.enableWarning?.('migration'); + * + * // Enable for only MyElement and subclasses + * MyElement.enableWarning?.('migration'); + * ``` + * + * @nocollapse + * @category dev-mode + */ + static enableWarning?: (warningKind: WarningKind) => void; + /** + * Disable the given warning category for this class. + * + * This method only exists in development builds, so it should be accessed + * with a guard like: + * + * ```ts + * // Disable for all ReactiveElement subclasses + * ReactiveElement.disableWarning?.('migration'); + * + * // Disable for only MyElement and subclasses + * MyElement.disableWarning?.('migration'); + * ``` + * + * @nocollapse + * @category dev-mode + */ + static disableWarning?: (warningKind: WarningKind) => void; + /** + * Adds an initializer function to the class that is called during instance + * construction. + * + * This is useful for code that runs against a `ReactiveElement` + * subclass, such as a decorator, that needs to do work for each + * instance, such as setting up a `ReactiveController`. + * + * ```ts + * const myDecorator = (target: typeof ReactiveElement, key: string) => { + * target.addInitializer((instance: ReactiveElement) => { + * // This is run during construction of the element + * new MyController(instance); + * }); + * } + * ``` + * + * Decorating a field will then cause each instance to run an initializer + * that adds a controller: + * + * ```ts + * class MyElement extends LitElement { + * @myDecorator foo; + * } + * ``` + * + * Initializers are stored per-constructor. Adding an initializer to a + * subclass does not add it to a superclass. Since initializers are run in + * constructors, initializers will run in order of the class hierarchy, + * starting with superclasses and progressing to the instance's class. + * + * @nocollapse + */ + static addInitializer(initializer: Initializer): void; + static _initializers?: Initializer[]; + /** + * Maps attribute names to properties; for example `foobar` attribute to + * `fooBar` property. Created lazily on user subclasses when finalizing the + * class. + * @nocollapse + */ + private static __attributeToPropertyMap; + /** + * Marks class as having been finalized, which includes creating properties + * from `static properties`, but does *not* include all properties created + * from decorators. + * @nocollapse + */ + protected static finalized: true | undefined; + /** + * Memoized list of all element properties, including any superclass + * properties. Created lazily on user subclasses when finalizing the class. + * + * @nocollapse + * @category properties + */ + static elementProperties: PropertyDeclarationMap; + /** + * User-supplied object that maps property names to `PropertyDeclaration` + * objects containing options for configuring reactive properties. When + * a reactive property is set the element will update and render. + * + * By default properties are public fields, and as such, they should be + * considered as primarily settable by element users, either via attribute or + * the property itself. + * + * Generally, properties that are changed by the element should be private or + * protected fields and should use the `state: true` option. Properties + * marked as `state` do not reflect from the corresponding attribute + * + * However, sometimes element code does need to set a public property. This + * should typically only be done in response to user interaction, and an event + * should be fired informing the user; for example, a checkbox sets its + * `checked` property when clicked and fires a `changed` event. Mutating + * public properties should typically not be done for non-primitive (object or + * array) properties. In other cases when an element needs to manage state, a + * private property set with the `state: true` option should be used. When + * needed, state properties can be initialized via public properties to + * facilitate complex interactions. + * @nocollapse + * @category properties + */ + static properties: PropertyDeclarations; + /** + * Memoized list of all element styles. + * Created lazily on user subclasses when finalizing the class. + * @nocollapse + * @category styles + */ + static elementStyles: Array<CSSResultOrNative>; + /** + * Array of styles to apply to the element. The styles should be defined + * using the {@linkcode css} tag function, via constructible stylesheets, or + * imported from native CSS module scripts. + * + * Note on Content Security Policy: + * + * Element styles are implemented with `<style>` tags when the browser doesn't + * support adopted StyleSheets. To use such `<style>` tags with the style-src + * CSP directive, the style-src value must either include 'unsafe-inline' or + * `nonce-<base64-value>` with `<base64-value>` replaced be a server-generated + * nonce. + * + * To provide a nonce to use on generated `<style>` elements, set + * `window.litNonce` to a server-generated nonce in your page's HTML, before + * loading application code: + * + * ```html + * <script> + * // Generated and unique per request: + * window.litNonce = 'a1b2c3d4'; + * </script> + * ``` + * @nocollapse + * @category styles + */ + static styles?: CSSResultGroup; + /** + * Returns a list of attributes corresponding to the registered properties. + * @nocollapse + * @category attributes + */ + static get observedAttributes(): string[]; + private __instanceProperties?; + /** + * Creates a property accessor on the element prototype if one does not exist + * and stores a {@linkcode PropertyDeclaration} for the property with the + * given options. The property setter calls the property's `hasChanged` + * property option or uses a strict identity check to determine whether or not + * to request an update. + * + * This method may be overridden to customize properties; however, + * when doing so, it's important to call `super.createProperty` to ensure + * the property is setup correctly. This method calls + * `getPropertyDescriptor` internally to get a descriptor to install. + * To customize what properties do when they are get or set, override + * `getPropertyDescriptor`. To customize the options for a property, + * implement `createProperty` like this: + * + * ```ts + * static createProperty(name, options) { + * options = Object.assign(options, {myOption: true}); + * super.createProperty(name, options); + * } + * ``` + * + * @nocollapse + * @category properties + */ + static createProperty(name: PropertyKey, options?: PropertyDeclaration): void; + /** + * Returns a property descriptor to be defined on the given named property. + * If no descriptor is returned, the property will not become an accessor. + * For example, + * + * ```ts + * class MyElement extends LitElement { + * static getPropertyDescriptor(name, key, options) { + * const defaultDescriptor = + * super.getPropertyDescriptor(name, key, options); + * const setter = defaultDescriptor.set; + * return { + * get: defaultDescriptor.get, + * set(value) { + * setter.call(this, value); + * // custom action. + * }, + * configurable: true, + * enumerable: true + * } + * } + * } + * ``` + * + * @nocollapse + * @category properties + */ + protected static getPropertyDescriptor(name: PropertyKey, key: string | symbol, options: PropertyDeclaration): PropertyDescriptor | undefined; + /** + * Returns the property options associated with the given property. + * These options are defined with a `PropertyDeclaration` via the `properties` + * object or the `@property` decorator and are registered in + * `createProperty(...)`. + * + * Note, this method should be considered "final" and not overridden. To + * customize the options for a given property, override + * {@linkcode createProperty}. + * + * @nocollapse + * @final + * @category properties + */ + static getPropertyOptions(name: PropertyKey): PropertyDeclaration<unknown, unknown>; + static [Symbol.metadata]: object & Record<PropertyKey, unknown>; + /** + * Initializes static own properties of the class used in bookkeeping + * for element properties, initializers, etc. + * + * Can be called multiple times by code that needs to ensure these + * properties exist before using them. + * + * This method ensures the superclass is finalized so that inherited + * property metadata can be copied down. + * @nocollapse + */ + private static __prepare; + /** + * Finishes setting up the class so that it's ready to be registered + * as a custom element and instantiated. + * + * This method is called by the ReactiveElement.observedAttributes getter. + * If you override the observedAttributes getter, you must either call + * super.observedAttributes to trigger finalization, or call finalize() + * yourself. + * + * @nocollapse + */ + protected static finalize(): void; + /** + * Options used when calling `attachShadow`. Set this property to customize + * the options for the shadowRoot; for example, to create a closed + * shadowRoot: `{mode: 'closed'}`. + * + * Note, these options are used in `createRenderRoot`. If this method + * is customized, options should be respected if possible. + * @nocollapse + * @category rendering + */ + static shadowRootOptions: ShadowRootInit; + /** + * Takes the styles the user supplied via the `static styles` property and + * returns the array of styles to apply to the element. + * Override this method to integrate into a style management system. + * + * Styles are deduplicated preserving the _last_ instance in the list. This + * is a performance optimization to avoid duplicated styles that can occur + * especially when composing via subclassing. The last item is kept to try + * to preserve the cascade order with the assumption that it's most important + * that last added styles override previous styles. + * + * @nocollapse + * @category styles + */ + protected static finalizeStyles(styles?: CSSResultGroup): Array<CSSResultOrNative>; + /** + * Node or ShadowRoot into which element DOM should be rendered. Defaults + * to an open shadowRoot. + * @category rendering + */ + readonly renderRoot: HTMLElement | DocumentFragment; + /** + * Returns the property name for the given attribute `name`. + * @nocollapse + */ + private static __attributeNameForProperty; + private __updatePromise; + /** + * True if there is a pending update as a result of calling `requestUpdate()`. + * Should only be read. + * @category updates + */ + isUpdatePending: boolean; + /** + * Is set to `true` after the first update. The element code cannot assume + * that `renderRoot` exists before the element `hasUpdated`. + * @category updates + */ + hasUpdated: boolean; + /** + * Properties that should be reflected when updated. + */ + private __reflectingProperties?; + /** + * Name of currently reflecting property + */ + private __reflectingProperty; + /** + * Set of controllers. + */ + private __controllers?; + constructor(); + /** + * Internal only override point for customizing work done when elements + * are constructed. + */ + private __initialize; + /** + * Registers a `ReactiveController` to participate in the element's reactive + * update cycle. The element automatically calls into any registered + * controllers during its lifecycle callbacks. + * + * If the element is connected when `addController()` is called, the + * controller's `hostConnected()` callback will be immediately called. + * @category controllers + */ + addController(controller: ReactiveController): void; + /** + * Removes a `ReactiveController` from the element. + * @category controllers + */ + removeController(controller: ReactiveController): void; + /** + * Fixes any properties set on the instance before upgrade time. + * Otherwise these would shadow the accessor and break these properties. + * The properties are stored in a Map which is played back after the + * constructor runs. Note, on very old versions of Safari (<=9) or Chrome + * (<=41), properties created for native platform properties like (`id` or + * `name`) may not have default values set in the element constructor. On + * these browsers native properties appear on instances and therefore their + * default value will overwrite any element default (e.g. if the element sets + * this.id = 'id' in the constructor, the 'id' will become '' since this is + * the native platform default). + */ + private __saveInstanceProperties; + /** + * Returns the node into which the element should render and by default + * creates and returns an open shadowRoot. Implement to customize where the + * element's DOM is rendered. For example, to render into the element's + * childNodes, return `this`. + * + * @return Returns a node into which to render. + * @category rendering + */ + protected createRenderRoot(): HTMLElement | DocumentFragment; + /** + * On first connection, creates the element's renderRoot, sets up + * element styling, and enables updating. + * @category lifecycle + */ + connectedCallback(): void; + /** + * Note, this method should be considered final and not overridden. It is + * overridden on the element instance with a function that triggers the first + * update. + * @category updates + */ + protected enableUpdating(_requestedUpdate: boolean): void; + /** + * Allows for `super.disconnectedCallback()` in extensions while + * reserving the possibility of making non-breaking feature additions + * when disconnecting at some point in the future. + * @category lifecycle + */ + disconnectedCallback(): void; + /** + * Synchronizes property values when attributes change. + * + * Specifically, when an attribute is set, the corresponding property is set. + * You should rarely need to implement this callback. If this method is + * overridden, `super.attributeChangedCallback(name, _old, value)` must be + * called. + * + * See [using the lifecycle callbacks](https://developer.mozilla.org/en-US/docs/Web/Web_Components/Using_custom_elements#using_the_lifecycle_callbacks) + * on MDN for more information about the `attributeChangedCallback`. + * @category attributes + */ + attributeChangedCallback(name: string, _old: string | null, value: string | null): void; + private __propertyToAttribute; + /** + * Requests an update which is processed asynchronously. This should be called + * when an element should update based on some state not triggered by setting + * a reactive property. In this case, pass no arguments. It should also be + * called when manually implementing a property setter. In this case, pass the + * property `name` and `oldValue` to ensure that any configured property + * options are honored. + * + * @param name name of requesting property + * @param oldValue old value of requesting property + * @param options property options to use instead of the previously + * configured options + * @param initial whether this call is for the initial value of the property. + * Initial values do not reflect to an attribute. + * @category updates + */ + requestUpdate(name?: PropertyKey, oldValue?: unknown, options?: PropertyDeclaration): void; + /** + * Sets up the element to asynchronously update. + */ + private __enqueueUpdate; + /** + * Schedules an element update. You can override this method to change the + * timing of updates by returning a Promise. The update will await the + * returned Promise, and you should resolve the Promise to allow the update + * to proceed. If this method is overridden, `super.scheduleUpdate()` + * must be called. + * + * For instance, to schedule updates to occur just before the next frame: + * + * ```ts + * override protected async scheduleUpdate(): Promise<unknown> { + * await new Promise((resolve) => requestAnimationFrame(() => resolve())); + * super.scheduleUpdate(); + * } + * ``` + * @category updates + */ + protected scheduleUpdate(): void | Promise<unknown>; + /** + * Performs an element update. Note, if an exception is thrown during the + * update, `firstUpdated` and `updated` will not be called. + * + * Call `performUpdate()` to immediately process a pending update. This should + * generally not be needed, but it can be done in rare cases when you need to + * update synchronously. + * + * @category updates + */ + protected performUpdate(): void; + /** + * Invoked before `update()` to compute values needed during the update. + * + * Implement `willUpdate` to compute property values that depend on other + * properties and are used in the rest of the update process. + * + * ```ts + * willUpdate(changedProperties) { + * // only need to check changed properties for an expensive computation. + * if (changedProperties.has('firstName') || changedProperties.has('lastName')) { + * this.sha = computeSHA(`${this.firstName} ${this.lastName}`); + * } + * } + * + * render() { + * return html`SHA: ${this.sha}`; + * } + * ``` + * + * @category updates + */ + protected willUpdate(_changedProperties: PropertyValues): void; + private __markUpdated; + /** + * Returns a Promise that resolves when the element has completed updating. + * The Promise value is a boolean that is `true` if the element completed the + * update without triggering another update. The Promise result is `false` if + * a property was set inside `updated()`. If the Promise is rejected, an + * exception was thrown during the update. + * + * To await additional asynchronous work, override the `getUpdateComplete` + * method. For example, it is sometimes useful to await a rendered element + * before fulfilling this Promise. To do this, first await + * `super.getUpdateComplete()`, then any subsequent state. + * + * @return A promise of a boolean that resolves to true if the update completed + * without triggering another update. + * @category updates + */ + get updateComplete(): Promise<boolean>; + /** + * Override point for the `updateComplete` promise. + * + * It is not safe to override the `updateComplete` getter directly due to a + * limitation in TypeScript which means it is not possible to call a + * superclass getter (e.g. `super.updateComplete.then(...)`) when the target + * language is ES5 (https://github.com/microsoft/TypeScript/issues/338). + * This method should be overridden instead. For example: + * + * ```ts + * class MyElement extends LitElement { + * override async getUpdateComplete() { + * const result = await super.getUpdateComplete(); + * await this._myChild.updateComplete; + * return result; + * } + * } + * ``` + * + * @return A promise of a boolean that resolves to true if the update completed + * without triggering another update. + * @category updates + */ + protected getUpdateComplete(): Promise<boolean>; + /** + * Controls whether or not `update()` should be called when the element requests + * an update. By default, this method always returns `true`, but this can be + * customized to control when to update. + * + * @param _changedProperties Map of changed properties with old values + * @category updates + */ + protected shouldUpdate(_changedProperties: PropertyValues): boolean; + /** + * Updates the element. This method reflects property values to attributes. + * It can be overridden to render and keep updated element DOM. + * Setting properties inside this method will *not* trigger + * another update. + * + * @param _changedProperties Map of changed properties with old values + * @category updates + */ + protected update(_changedProperties: PropertyValues): void; + /** + * Invoked whenever the element is updated. Implement to perform + * post-updating tasks via DOM APIs, for example, focusing an element. + * + * Setting properties inside this method will trigger the element to update + * again after this update cycle completes. + * + * @param _changedProperties Map of changed properties with old values + * @category updates + */ + protected updated(_changedProperties: PropertyValues): void; + /** + * Invoked when the element is first updated. Implement to perform one time + * work on the element after update. + * + * ```ts + * firstUpdated() { + * this.renderRoot.getElementById('my-text-area').focus(); + * } + * ``` + * + * Setting properties inside this method will trigger the element to update + * again after this update cycle completes. + * + * @param _changedProperties Map of changed properties with old values + * @category updates + */ + protected firstUpdated(_changedProperties: PropertyValues): void; +} +//# sourceMappingURL=reactive-element.d.ts.map
\ No newline at end of file diff --git a/chromium/third_party/node/node_modules/@lit/reactive-element/reactive-element.js b/chromium/third_party/node/node_modules/@lit/reactive-element/reactive-element.js new file mode 100644 index 00000000000..41540ff3726 --- /dev/null +++ b/chromium/third_party/node/node_modules/@lit/reactive-element/reactive-element.js @@ -0,0 +1,7 @@ +import{getCompatibleStyle as t,adoptStyles as s}from"./css-tag.js";export{CSSResult,adoptStyles,css,getCompatibleStyle,supportsAdoptingStyleSheets,unsafeCSS}from"./css-tag.js"; +/** + * @license + * Copyright 2017 Google LLC + * SPDX-License-Identifier: BSD-3-Clause + */const{is:i,defineProperty:e,getOwnPropertyDescriptor:r,getOwnPropertyNames:h,getOwnPropertySymbols:o,getPrototypeOf:n}=Object,a=globalThis,c=a.trustedTypes,l=c?c.emptyScript:"",p=a.reactiveElementPolyfillSupport,d=(t,s)=>t,u={toAttribute(t,s){switch(s){case Boolean:t=t?l:null;break;case Object:case Array:t=null==t?t:JSON.stringify(t)}return t},fromAttribute(t,s){let i=t;switch(s){case Boolean:i=null!==t;break;case Number:i=null===t?null:Number(t);break;case Object:case Array:try{i=JSON.parse(t)}catch(t){i=null}}return i}},f=(t,s)=>!i(t,s),y={attribute:!0,type:String,converter:u,reflect:!1,hasChanged:f};Symbol.metadata??=Symbol("metadata"),a.litPropertyMetadata??=new WeakMap;class b extends HTMLElement{static addInitializer(t){this._$Ei(),(this.l??=[]).push(t)}static get observedAttributes(){return this.finalize(),this._$Eh&&[...this._$Eh.keys()]}static createProperty(t,s=y){if(s.state&&(s.attribute=!1),this._$Ei(),this.elementProperties.set(t,s),!s.noAccessor){const i=Symbol(),r=this.getPropertyDescriptor(t,i,s);void 0!==r&&e(this.prototype,t,r)}}static getPropertyDescriptor(t,s,i){const{get:e,set:h}=r(this.prototype,t)??{get(){return this[s]},set(t){this[s]=t}};return{get(){return e?.call(this)},set(s){const r=e?.call(this);h.call(this,s),this.requestUpdate(t,r,i)},configurable:!0,enumerable:!0}}static getPropertyOptions(t){return this.elementProperties.get(t)??y}static _$Ei(){if(this.hasOwnProperty(d("elementProperties")))return;const t=n(this);t.finalize(),void 0!==t.l&&(this.l=[...t.l]),this.elementProperties=new Map(t.elementProperties)}static finalize(){if(this.hasOwnProperty(d("finalized")))return;if(this.finalized=!0,this._$Ei(),this.hasOwnProperty(d("properties"))){const t=this.properties,s=[...h(t),...o(t)];for(const i of s)this.createProperty(i,t[i])}const t=this[Symbol.metadata];if(null!==t){const s=litPropertyMetadata.get(t);if(void 0!==s)for(const[t,i]of s)this.elementProperties.set(t,i)}this._$Eh=new Map;for(const[t,s]of this.elementProperties){const i=this._$Eu(t,s);void 0!==i&&this._$Eh.set(i,t)}this.elementStyles=this.finalizeStyles(this.styles)}static finalizeStyles(s){const i=[];if(Array.isArray(s)){const e=new Set(s.flat(1/0).reverse());for(const s of e)i.unshift(t(s))}else void 0!==s&&i.push(t(s));return i}static _$Eu(t,s){const i=s.attribute;return!1===i?void 0:"string"==typeof i?i:"string"==typeof t?t.toLowerCase():void 0}constructor(){super(),this._$Ep=void 0,this.isUpdatePending=!1,this.hasUpdated=!1,this._$Em=null,this._$Ev()}_$Ev(){this._$Eg=new Promise((t=>this.enableUpdating=t)),this._$AL=new Map,this._$ES(),this.requestUpdate(),this.constructor.l?.forEach((t=>t(this)))}addController(t){(this._$E_??=new Set).add(t),void 0!==this.renderRoot&&this.isConnected&&t.hostConnected?.()}removeController(t){this._$E_?.delete(t)}_$ES(){const t=new Map,s=this.constructor.elementProperties;for(const i of s.keys())this.hasOwnProperty(i)&&(t.set(i,this[i]),delete this[i]);t.size>0&&(this._$Ep=t)}createRenderRoot(){const t=this.shadowRoot??this.attachShadow(this.constructor.shadowRootOptions);return s(t,this.constructor.elementStyles),t}connectedCallback(){this.renderRoot??=this.createRenderRoot(),this.enableUpdating(!0),this._$E_?.forEach((t=>t.hostConnected?.()))}enableUpdating(t){}disconnectedCallback(){this._$E_?.forEach((t=>t.hostDisconnected?.()))}attributeChangedCallback(t,s,i){this._$AK(t,i)}_$EO(t,s){const i=this.constructor.elementProperties.get(t),e=this.constructor._$Eu(t,i);if(void 0!==e&&!0===i.reflect){const r=(void 0!==i.converter?.toAttribute?i.converter:u).toAttribute(s,i.type);this._$Em=t,null==r?this.removeAttribute(e):this.setAttribute(e,r),this._$Em=null}}_$AK(t,s){const i=this.constructor,e=i._$Eh.get(t);if(void 0!==e&&this._$Em!==e){const t=i.getPropertyOptions(e),r="function"==typeof t.converter?{fromAttribute:t.converter}:void 0!==t.converter?.fromAttribute?t.converter:u;this._$Em=e,this[e]=r.fromAttribute(s,t.type),this._$Em=null}}requestUpdate(t,s,i,e=!1,r){if(void 0!==t){if(i??=this.constructor.getPropertyOptions(t),!(i.hasChanged??f)(e?r:this[t],s))return;this.C(t,s,i)}!1===this.isUpdatePending&&(this._$Eg=this._$EP())}C(t,s,i){this._$AL.has(t)||this._$AL.set(t,s),!0===i.reflect&&this._$Em!==t&&(this._$Ej??=new Set).add(t)}async _$EP(){this.isUpdatePending=!0;try{await this._$Eg}catch(t){Promise.reject(t)}const t=this.scheduleUpdate();return null!=t&&await t,!this.isUpdatePending}scheduleUpdate(){return this.performUpdate()}performUpdate(){if(!this.isUpdatePending)return;if(!this.hasUpdated){if(this.renderRoot??=this.createRenderRoot(),this._$Ep){for(const[t,s]of this._$Ep)this[t]=s;this._$Ep=void 0}const t=this.constructor.elementProperties;if(t.size>0)for(const[s,i]of t)!0!==i.wrapped||this._$AL.has(s)||void 0===this[s]||this.C(s,this[s],i)}let t=!1;const s=this._$AL;try{t=this.shouldUpdate(s),t?(this.willUpdate(s),this._$E_?.forEach((t=>t.hostUpdate?.())),this.update(s)):this._$ET()}catch(s){throw t=!1,this._$ET(),s}t&&this._$AE(s)}willUpdate(t){}_$AE(t){this._$E_?.forEach((t=>t.hostUpdated?.())),this.hasUpdated||(this.hasUpdated=!0,this.firstUpdated(t)),this.updated(t)}_$ET(){this._$AL=new Map,this.isUpdatePending=!1}get updateComplete(){return this.getUpdateComplete()}getUpdateComplete(){return this._$Eg}shouldUpdate(t){return!0}update(t){this._$Ej&&=this._$Ej.forEach((t=>this._$EO(t,this[t]))),this._$ET()}updated(t){}firstUpdated(t){}}b.elementStyles=[],b.shadowRootOptions={mode:"open"},b[d("elementProperties")]=new Map,b[d("finalized")]=new Map,p?.({ReactiveElement:b}),(a.reactiveElementVersions??=[]).push("2.0.2");export{b as ReactiveElement,u as defaultConverter,f as notEqual}; +//# sourceMappingURL=reactive-element.js.map diff --git a/chromium/third_party/node/node_modules/lit-element/LICENSE b/chromium/third_party/node/node_modules/lit-element/LICENSE new file mode 100644 index 00000000000..be7a97b60d7 --- /dev/null +++ b/chromium/third_party/node/node_modules/lit-element/LICENSE @@ -0,0 +1,28 @@ +BSD 3-Clause License + +Copyright (c) 2017 Google LLC. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + +1. Redistributions of source code must retain the above copyright notice, this + list of conditions and the following disclaimer. + +2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions and the following disclaimer in the documentation + and/or other materials provided with the distribution. + +3. Neither the name of the copyright holder nor the names of its + contributors may be used to endorse or promote products derived from + this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE +FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR +SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, +OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
\ No newline at end of file diff --git a/chromium/third_party/node/node_modules/lit-element/index.d.ts b/chromium/third_party/node/node_modules/lit-element/index.d.ts new file mode 100644 index 00000000000..d65d8f954be --- /dev/null +++ b/chromium/third_party/node/node_modules/lit-element/index.d.ts @@ -0,0 +1,9 @@ +/** + * @license + * Copyright 2017 Google LLC + * SPDX-License-Identifier: BSD-3-Clause + */ +export * from '@lit/reactive-element'; +export * from 'lit-html'; +export * from './lit-element.js'; +//# sourceMappingURL=index.d.ts.map
\ No newline at end of file diff --git a/chromium/third_party/node/node_modules/lit-element/lit-element.d.ts b/chromium/third_party/node/node_modules/lit-element/lit-element.d.ts new file mode 100644 index 00000000000..f88e91ecacc --- /dev/null +++ b/chromium/third_party/node/node_modules/lit-element/lit-element.d.ts @@ -0,0 +1,174 @@ +/** + * @license + * Copyright 2017 Google LLC + * SPDX-License-Identifier: BSD-3-Clause + */ +/** + * The main LitElement module, which defines the {@linkcode LitElement} base + * class and related APIs. + * + * LitElement components can define a template and a set of observed + * properties. Changing an observed property triggers a re-render of the + * element. + * + * Import {@linkcode LitElement} and {@linkcode html} from this module to + * create a component: + * + * ```js + * import {LitElement, html} from 'lit-element'; + * + * class MyElement extends LitElement { + * + * // Declare observed properties + * static get properties() { + * return { + * adjective: {} + * } + * } + * + * constructor() { + * this.adjective = 'awesome'; + * } + * + * // Define the element's template + * render() { + * return html`<p>your ${adjective} template here</p>`; + * } + * } + * + * customElements.define('my-element', MyElement); + * ``` + * + * `LitElement` extends {@linkcode ReactiveElement} and adds lit-html + * templating. The `ReactiveElement` class is provided for users that want to + * build their own custom element base classes that don't use lit-html. + * + * @packageDocumentation + */ +import { PropertyValues, ReactiveElement } from '@lit/reactive-element'; +import { RenderOptions } from 'lit-html'; +export * from '@lit/reactive-element'; +export * from 'lit-html'; +import { LitUnstable } from 'lit-html'; +import { ReactiveUnstable } from '@lit/reactive-element'; +/** + * Contains types that are part of the unstable debug API. + * + * Everything in this API is not stable and may change or be removed in the future, + * even on patch releases. + */ +export declare namespace Unstable { + /** + * When Lit is running in dev mode and `window.emitLitDebugLogEvents` is true, + * we will emit 'lit-debug' events to window, with live details about the update and render + * lifecycle. These can be useful for writing debug tooling and visualizations. + * + * Please be aware that running with window.emitLitDebugLogEvents has performance overhead, + * making certain operations that are normally very cheap (like a no-op render) much slower, + * because we must copy data and dispatch events. + */ + namespace DebugLog { + type Entry = LitUnstable.DebugLog.Entry | ReactiveUnstable.DebugLog.Entry; + } +} +/** + * Base element class that manages element properties and attributes, and + * renders a lit-html template. + * + * To define a component, subclass `LitElement` and implement a + * `render` method to provide the component's template. Define properties + * using the {@linkcode LitElement.properties properties} property or the + * {@linkcode property} decorator. + */ +export declare class LitElement extends ReactiveElement { + static ['_$litElement$']: boolean; + /** + * @category rendering + */ + readonly renderOptions: RenderOptions; + private __childPart; + /** + * @category rendering + */ + protected createRenderRoot(): HTMLElement | DocumentFragment; + /** + * Updates the element. This method reflects property values to attributes + * and calls `render` to render DOM via lit-html. Setting properties inside + * this method will *not* trigger another update. + * @param changedProperties Map of changed properties with old values + * @category updates + */ + protected update(changedProperties: PropertyValues): void; + /** + * Invoked when the component is added to the document's DOM. + * + * In `connectedCallback()` you should setup tasks that should only occur when + * the element is connected to the document. The most common of these is + * adding event listeners to nodes external to the element, like a keydown + * event handler added to the window. + * + * ```ts + * connectedCallback() { + * super.connectedCallback(); + * addEventListener('keydown', this._handleKeydown); + * } + * ``` + * + * Typically, anything done in `connectedCallback()` should be undone when the + * element is disconnected, in `disconnectedCallback()`. + * + * @category lifecycle + */ + connectedCallback(): void; + /** + * Invoked when the component is removed from the document's DOM. + * + * This callback is the main signal to the element that it may no longer be + * used. `disconnectedCallback()` should ensure that nothing is holding a + * reference to the element (such as event listeners added to nodes external + * to the element), so that it is free to be garbage collected. + * + * ```ts + * disconnectedCallback() { + * super.disconnectedCallback(); + * window.removeEventListener('keydown', this._handleKeydown); + * } + * ``` + * + * An element may be re-connected after being disconnected. + * + * @category lifecycle + */ + disconnectedCallback(): void; + /** + * Invoked on each update to perform rendering tasks. This method may return + * any value renderable by lit-html's `ChildPart` - typically a + * `TemplateResult`. Setting properties inside this method will *not* trigger + * the element to update. + * @category rendering + */ + protected render(): unknown; +} +/** + * END USERS SHOULD NOT RELY ON THIS OBJECT. + * + * Private exports for use by other Lit packages, not intended for use by + * external users. + * + * 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 _$LE 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. + * + * This has a unique name, to disambiguate it from private exports in + * lit-html, since this module re-exports all of lit-html. + * + * @private + */ +export declare const _$LE: { + _$attributeToProperty: (el: LitElement, name: string, value: string | null) => void; + _$changedProperties: (el: LitElement) => any; +}; +//# sourceMappingURL=lit-element.d.ts.map
\ No newline at end of file diff --git a/chromium/third_party/node/node_modules/lit-element/lit-element.js b/chromium/third_party/node/node_modules/lit-element/lit-element.js new file mode 100644 index 00000000000..59afa97c415 --- /dev/null +++ b/chromium/third_party/node/node_modules/lit-element/lit-element.js @@ -0,0 +1,7 @@ +import{ReactiveElement as t}from"@lit/reactive-element";export*from"@lit/reactive-element";import{render as e,noChange as i}from"lit-html";export*from"lit-html"; +/** + * @license + * Copyright 2017 Google LLC + * SPDX-License-Identifier: BSD-3-Clause + */class s extends t{constructor(){super(...arguments),this.renderOptions={host:this},this._$Do=void 0}createRenderRoot(){const t=super.createRenderRoot();return this.renderOptions.renderBefore??=t.firstChild,t}update(t){const i=this.render();this.hasUpdated||(this.renderOptions.isConnected=this.isConnected),super.update(t),this._$Do=e(i,this.renderRoot,this.renderOptions)}connectedCallback(){super.connectedCallback(),this._$Do?.setConnected(!0)}disconnectedCallback(){super.disconnectedCallback(),this._$Do?.setConnected(!1)}render(){return i}}s._$litElement$=!0,s[("finalized","finalized")]=!0,globalThis.litElementHydrateSupport?.({LitElement:s});const r=globalThis.litElementPolyfillSupport;r?.({LitElement:s});const o={_$AK:(t,e,i)=>{t._$AK(e,i)},_$AL:t=>t._$AL};(globalThis.litElementVersions??=[]).push("4.0.2");export{s as LitElement,o as _$LE}; +//# sourceMappingURL=lit-element.js.map diff --git a/chromium/third_party/node/node_modules/lit-html/LICENSE b/chromium/third_party/node/node_modules/lit-html/LICENSE new file mode 100644 index 00000000000..c8ed22676f5 --- /dev/null +++ b/chromium/third_party/node/node_modules/lit-html/LICENSE @@ -0,0 +1,28 @@ +BSD 3-Clause License + +Copyright (c) 2017 Google LLC. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + +1. Redistributions of source code must retain the above copyright notice, this + list of conditions and the following disclaimer. + +2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions and the following disclaimer in the documentation + and/or other materials provided with the distribution. + +3. Neither the name of the copyright holder nor the names of its + contributors may be used to endorse or promote products derived from + this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE +FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR +SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, +OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. diff --git a/chromium/third_party/node/node_modules/lit-html/async-directive.d.ts b/chromium/third_party/node/node_modules/lit-html/async-directive.d.ts new file mode 100644 index 00000000000..2b14fd3f8ea --- /dev/null +++ b/chromium/third_party/node/node_modules/lit-html/async-directive.d.ts @@ -0,0 +1,171 @@ +/** + * @license + * Copyright 2017 Google LLC + * SPDX-License-Identifier: BSD-3-Clause + */ +/** + * Overview: + * + * This module is designed to add support for an async `setValue` API and + * `disconnected` callback to directives with the least impact on the core + * runtime or payload when that feature is not used. + * + * The strategy is to introduce a `AsyncDirective` subclass of + * `Directive` that climbs the "parent" tree in its constructor to note which + * branches of lit-html's "logical tree" of data structures contain such + * directives and thus need to be crawled when a subtree is being cleared (or + * manually disconnected) in order to run the `disconnected` callback. + * + * The "nodes" of the logical tree include Parts, TemplateInstances (for when a + * TemplateResult is committed to a value of a ChildPart), and Directives; these + * all implement a common interface called `DisconnectableChild`. Each has a + * `_$parent` reference which is set during construction in the core code, and a + * `_$disconnectableChildren` field which is initially undefined. + * + * The sparse tree created by means of the `AsyncDirective` constructor + * crawling up the `_$parent` tree and placing a `_$disconnectableChildren` Set + * on each parent that includes each child that contains a + * `AsyncDirective` directly or transitively via its children. In order to + * notify connection state changes and disconnect (or reconnect) a tree, the + * `_$notifyConnectionChanged` API is patched onto ChildParts as a directive + * climbs the parent tree, which is called by the core when clearing a part if + * it exists. When called, that method iterates over the sparse tree of + * Set<DisconnectableChildren> built up by AsyncDirectives, and calls + * `_$notifyDirectiveConnectionChanged` on any directives that are encountered + * in that tree, running the required callbacks. + * + * A given "logical tree" of lit-html data-structures might look like this: + * + * ChildPart(N1) _$dC=[D2,T3] + * ._directive + * AsyncDirective(D2) + * ._value // user value was TemplateResult + * TemplateInstance(T3) _$dC=[A4,A6,N10,N12] + * ._$parts[] + * AttributePart(A4) _$dC=[D5] + * ._directives[] + * AsyncDirective(D5) + * AttributePart(A6) _$dC=[D7,D8] + * ._directives[] + * AsyncDirective(D7) + * Directive(D8) _$dC=[D9] + * ._directive + * AsyncDirective(D9) + * ChildPart(N10) _$dC=[D11] + * ._directive + * AsyncDirective(D11) + * ._value + * string + * ChildPart(N12) _$dC=[D13,N14,N16] + * ._directive + * AsyncDirective(D13) + * ._value // user value was iterable + * Array<ChildPart> + * ChildPart(N14) _$dC=[D15] + * ._value + * string + * ChildPart(N16) _$dC=[D17,T18] + * ._directive + * AsyncDirective(D17) + * ._value // user value was TemplateResult + * TemplateInstance(T18) _$dC=[A19,A21,N25] + * ._$parts[] + * AttributePart(A19) _$dC=[D20] + * ._directives[] + * AsyncDirective(D20) + * AttributePart(A21) _$dC=[22,23] + * ._directives[] + * AsyncDirective(D22) + * Directive(D23) _$dC=[D24] + * ._directive + * AsyncDirective(D24) + * ChildPart(N25) _$dC=[D26] + * ._directive + * AsyncDirective(D26) + * ._value + * string + * + * Example 1: The directive in ChildPart(N12) updates and returns `nothing`. The + * ChildPart will _clear() itself, and so we need to disconnect the "value" of + * the ChildPart (but not its directive). In this case, when `_clear()` calls + * `_$notifyConnectionChanged()`, we don't iterate all of the + * _$disconnectableChildren, rather we do a value-specific disconnection: i.e. + * since the _value was an Array<ChildPart> (because an iterable had been + * committed), we iterate the array of ChildParts (N14, N16) and run + * `setConnected` on them (which does recurse down the full tree of + * `_$disconnectableChildren` below it, and also removes N14 and N16 from N12's + * `_$disconnectableChildren`). Once the values have been disconnected, we then + * check whether the ChildPart(N12)'s list of `_$disconnectableChildren` is empty + * (and would remove it from its parent TemplateInstance(T3) if so), but since + * it would still contain its directive D13, it stays in the disconnectable + * tree. + * + * Example 2: In the course of Example 1, `setConnected` will reach + * ChildPart(N16); in this case the entire part is being disconnected, so we + * simply iterate all of N16's `_$disconnectableChildren` (D17,T18) and + * recursively run `setConnected` on them. Note that we only remove children + * from `_$disconnectableChildren` for the top-level values being disconnected + * on a clear; doing this bookkeeping lower in the tree is wasteful since it's + * all being thrown away. + * + * Example 3: If the LitElement containing the entire tree above becomes + * disconnected, it will run `childPart.setConnected()` (which calls + * `childPart._$notifyConnectionChanged()` if it exists); in this case, we + * recursively run `setConnected()` over the entire tree, without removing any + * children from `_$disconnectableChildren`, since this tree is required to + * re-connect the tree, which does the same operation, simply passing + * `isConnected: true` down the tree, signaling which callback to run. + */ +import { Disconnectable, Part } from './lit-html.js'; +import { Directive } from './directive.js'; +export * from './directive.js'; +/** + * An abstract `Directive` base class whose `disconnected` method will be + * called when the part containing the directive is cleared as a result of + * re-rendering, or when the user calls `part.setConnected(false)` on + * a part that was previously rendered containing the directive (as happens + * when e.g. a LitElement disconnects from the DOM). + * + * If `part.setConnected(true)` is subsequently called on a + * containing part, the directive's `reconnected` method will be called prior + * to its next `update`/`render` callbacks. When implementing `disconnected`, + * `reconnected` should also be implemented to be compatible with reconnection. + * + * Note that updates may occur while the directive is disconnected. As such, + * directives should generally check the `this.isConnected` flag during + * render/update to determine whether it is safe to subscribe to resources + * that may prevent garbage collection. + */ +export declare abstract class AsyncDirective extends Directive { + /** + * The connection state for this Directive. + */ + isConnected: boolean; + /** + * Initialize the part with internal fields + * @param part + * @param parent + * @param attributeIndex + */ + _$initialize(part: Part, parent: Disconnectable, attributeIndex: number | undefined): void; + /** + * Sets the value of the directive's Part outside the normal `update`/`render` + * lifecycle of a directive. + * + * This method should not be called synchronously from a directive's `update` + * or `render`. + * + * @param directive The directive to update + * @param value The value to set + */ + setValue(value: unknown): void; + /** + * User callbacks for implementing logic to release any resources/subscriptions + * that may have been retained by this directive. Since directives may also be + * re-connected, `reconnected` should also be implemented to restore the + * working state of the directive prior to the next render. + */ + protected disconnected(): void; + protected reconnected(): void; +} +//# sourceMappingURL=async-directive.d.ts.map
\ No newline at end of file diff --git a/chromium/third_party/node/node_modules/lit-html/directive-helpers.d.ts b/chromium/third_party/node/node_modules/lit-html/directive-helpers.d.ts new file mode 100644 index 00000000000..dede0f33661 --- /dev/null +++ b/chromium/third_party/node/node_modules/lit-html/directive-helpers.d.ts @@ -0,0 +1,116 @@ +/** + * @license + * Copyright 2020 Google LLC + * SPDX-License-Identifier: BSD-3-Clause + */ +import { Part, DirectiveParent, CompiledTemplateResult, MaybeCompiledTemplateResult, UncompiledTemplateResult } from './lit-html.js'; +import { DirectiveResult, DirectiveClass, PartInfo } from './directive.js'; +type Primitive = null | undefined | boolean | number | string | symbol | bigint; +declare const ChildPart: typeof import("./lit-html.js").ChildPart; +type ChildPart = InstanceType<typeof ChildPart>; +/** + * Tests if a value is a primitive value. + * + * See https://tc39.github.io/ecma262/#sec-typeof-operator + */ +export declare const isPrimitive: (value: unknown) => value is Primitive; +export declare const TemplateResultType: { + readonly HTML: 1; + readonly SVG: 2; +}; +export type TemplateResultType = (typeof TemplateResultType)[keyof typeof TemplateResultType]; +type IsTemplateResult = { + (val: unknown): val is MaybeCompiledTemplateResult; + <T extends TemplateResultType>(val: unknown, type: T): val is UncompiledTemplateResult<T>; +}; +/** + * Tests if a value is a TemplateResult or a CompiledTemplateResult. + */ +export declare const isTemplateResult: IsTemplateResult; +/** + * Tests if a value is a CompiledTemplateResult. + */ +export declare const isCompiledTemplateResult: (value: unknown) => value is CompiledTemplateResult; +/** + * Tests if a value is a DirectiveResult. + */ +export declare const isDirectiveResult: (value: unknown) => value is DirectiveResult<DirectiveClass>; +/** + * Retrieves the Directive class for a DirectiveResult + */ +export declare const getDirectiveClass: (value: unknown) => DirectiveClass | undefined; +/** + * Tests whether a part has only a single-expression with no strings to + * interpolate between. + * + * Only AttributePart and PropertyPart can have multiple expressions. + * Multi-expression parts have a `strings` property and single-expression + * parts do not. + */ +export declare const isSingleExpression: (part: PartInfo) => boolean; +/** + * Inserts a ChildPart into the given container ChildPart's DOM, either at the + * end of the container ChildPart, or before the optional `refPart`. + * + * This does not add the part to the containerPart's committed value. That must + * be done by callers. + * + * @param containerPart Part within which to add the new ChildPart + * @param refPart Part before which to add the new ChildPart; when omitted the + * part added to the end of the `containerPart` + * @param part Part to insert, or undefined to create a new part + */ +export declare const insertPart: (containerPart: ChildPart, refPart?: ChildPart, part?: ChildPart) => ChildPart; +/** + * Sets the value of a Part. + * + * Note that this should only be used to set/update the value of user-created + * parts (i.e. those created using `insertPart`); it should not be used + * by directives to set the value of the directive's container part. Directives + * should return a value from `update`/`render` to update their part state. + * + * For directives that require setting their part value asynchronously, they + * should extend `AsyncDirective` and call `this.setValue()`. + * + * @param part Part to set + * @param value Value to set + * @param index For `AttributePart`s, the index to set + * @param directiveParent Used internally; should not be set by user + */ +export declare const setChildPartValue: <T extends import("./lit-html.js").ChildPart>(part: T, value: unknown, directiveParent?: DirectiveParent) => T; +/** + * Sets the committed value of a ChildPart directly without triggering the + * commit stage of the part. + * + * This is useful in cases where a directive needs to update the part such + * that the next update detects a value change or not. When value is omitted, + * the next update will be guaranteed to be detected as a change. + * + * @param part + * @param value + */ +export declare const setCommittedValue: (part: Part, value?: unknown) => unknown; +/** + * Returns the committed value of a ChildPart. + * + * The committed value is used for change detection and efficient updates of + * the part. It can differ from the value set by the template or directive in + * cases where the template value is transformed before being committed. + * + * - `TemplateResult`s are committed as a `TemplateInstance` + * - Iterables are committed as `Array<ChildPart>` + * - All other types are committed as the template value or value returned or + * set by a directive. + * + * @param part + */ +export declare const getCommittedValue: (part: ChildPart) => unknown; +/** + * Removes a ChildPart from the DOM, including any of its content. + * + * @param part The Part to remove + */ +export declare const removePart: (part: ChildPart) => void; +export declare const clearPart: (part: ChildPart) => void; +export {}; +//# sourceMappingURL=directive-helpers.d.ts.map
\ No newline at end of file diff --git a/chromium/third_party/node/node_modules/lit-html/directive.d.ts b/chromium/third_party/node/node_modules/lit-html/directive.d.ts new file mode 100644 index 00000000000..85941303a56 --- /dev/null +++ b/chromium/third_party/node/node_modules/lit-html/directive.d.ts @@ -0,0 +1,66 @@ +/** + * @license + * Copyright 2017 Google LLC + * SPDX-License-Identifier: BSD-3-Clause + */ +import { Disconnectable, Part } from './lit-html.js'; +export { AttributePart, BooleanAttributePart, ChildPart, ElementPart, EventPart, Part, PropertyPart, } from './lit-html.js'; +export interface DirectiveClass { + new (part: PartInfo): Directive; +} +/** + * This utility type extracts the signature of a directive class's render() + * method so we can use it for the type of the generated directive function. + */ +export type DirectiveParameters<C extends Directive> = Parameters<C['render']>; +/** + * A generated directive function doesn't evaluate the directive, but just + * returns a DirectiveResult object that captures the arguments. + */ +export interface DirectiveResult<C extends DirectiveClass = DirectiveClass> { +} +export declare const PartType: { + readonly ATTRIBUTE: 1; + readonly CHILD: 2; + readonly PROPERTY: 3; + readonly BOOLEAN_ATTRIBUTE: 4; + readonly EVENT: 5; + readonly ELEMENT: 6; +}; +export type PartType = (typeof PartType)[keyof typeof PartType]; +export interface ChildPartInfo { + readonly type: typeof PartType.CHILD; +} +export interface AttributePartInfo { + readonly type: typeof PartType.ATTRIBUTE | typeof PartType.PROPERTY | typeof PartType.BOOLEAN_ATTRIBUTE | typeof PartType.EVENT; + readonly strings?: ReadonlyArray<string>; + readonly name: string; + readonly tagName: string; +} +export interface ElementPartInfo { + readonly type: typeof PartType.ELEMENT; +} +/** + * Information about the part a directive is bound to. + * + * This is useful for checking that a directive is attached to a valid part, + * such as with directive that can only be used on attribute bindings. + */ +export type PartInfo = ChildPartInfo | AttributePartInfo | ElementPartInfo; +/** + * Creates a user-facing directive function from a Directive class. This + * function has the same parameters as the directive's render() method. + */ +export declare const directive: <C extends DirectiveClass>(c: C) => (...values: Parameters<InstanceType<C>["render"]>) => DirectiveResult<C>; +/** + * Base class for creating custom directives. Users should extend this class, + * implement `render` and/or `update`, and then pass their subclass to + * `directive`. + */ +export declare abstract class Directive implements Disconnectable { + constructor(_partInfo: PartInfo); + get _$isConnected(): boolean; + abstract render(...props: Array<unknown>): unknown; + update(_part: Part, props: Array<unknown>): unknown; +} +//# sourceMappingURL=directive.d.ts.map
\ No newline at end of file diff --git a/chromium/third_party/node/node_modules/lit-html/directives/async-append.d.ts b/chromium/third_party/node/node_modules/lit-html/directives/async-append.d.ts new file mode 100644 index 00000000000..34b0b18868c --- /dev/null +++ b/chromium/third_party/node/node_modules/lit-html/directives/async-append.d.ts @@ -0,0 +1,39 @@ +/** + * @license + * Copyright 2017 Google LLC + * SPDX-License-Identifier: BSD-3-Clause + */ +import { ChildPart } from '../lit-html.js'; +import { DirectiveParameters, PartInfo } from '../directive.js'; +import { AsyncReplaceDirective } from './async-replace.js'; +declare class AsyncAppendDirective extends AsyncReplaceDirective { + private __childPart; + constructor(partInfo: PartInfo); + update(part: ChildPart, params: DirectiveParameters<this>): typeof import("../lit-html.js").noChange | undefined; + protected commitValue(value: unknown, index: number): void; +} +/** + * A directive that renders the items of an async iterable[1], appending new + * values after previous values, similar to the built-in support for iterables. + * This directive is usable only in child expressions. + * + * Async iterables are objects with a [Symbol.asyncIterator] method, which + * returns an iterator who's `next()` method returns a Promise. When a new + * value is available, the Promise resolves and the value is appended to the + * Part controlled by the directive. If another value other than this + * directive has been set on the Part, the iterable will no longer be listened + * to and new values won't be written to the Part. + * + * [1]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/for-await...of + * + * @param value An async iterable + * @param mapper An optional function that maps from (value, index) to another + * value. Useful for generating templates for each item in the iterable. + */ +export declare const asyncAppend: (value: AsyncIterable<unknown>, _mapper?: ((v: unknown, index?: number | undefined) => unknown) | undefined) => import("../directive.js").DirectiveResult<typeof AsyncAppendDirective>; +/** + * The type of the class that powers this directive. Necessary for naming the + * directive's return type. + */ +export type { AsyncAppendDirective }; +//# sourceMappingURL=async-append.d.ts.map
\ No newline at end of file diff --git a/chromium/third_party/node/node_modules/lit-html/directives/async-replace.d.ts b/chromium/third_party/node/node_modules/lit-html/directives/async-replace.d.ts new file mode 100644 index 00000000000..c7413279f14 --- /dev/null +++ b/chromium/third_party/node/node_modules/lit-html/directives/async-replace.d.ts @@ -0,0 +1,39 @@ +/** + * @license + * Copyright 2017 Google LLC + * SPDX-License-Identifier: BSD-3-Clause + */ +import { ChildPart, noChange } from '../lit-html.js'; +import { AsyncDirective, DirectiveParameters } from '../async-directive.js'; +type Mapper<T> = (v: T, index?: number) => unknown; +export declare class AsyncReplaceDirective extends AsyncDirective { + private __value?; + private __weakThis; + private __pauser; + render<T>(value: AsyncIterable<T>, _mapper?: Mapper<T>): symbol; + update(_part: ChildPart, [value, mapper]: DirectiveParameters<this>): typeof noChange | undefined; + protected commitValue(value: unknown, _index: number): void; + disconnected(): void; + reconnected(): void; +} +/** + * A directive that renders the items of an async iterable[1], replacing + * previous values with new values, so that only one value is ever rendered + * at a time. This directive may be used in any expression type. + * + * Async iterables are objects with a `[Symbol.asyncIterator]` method, which + * returns an iterator who's `next()` method returns a Promise. When a new + * value is available, the Promise resolves and the value is rendered to the + * Part controlled by the directive. If another value other than this + * directive has been set on the Part, the iterable will no longer be listened + * to and new values won't be written to the Part. + * + * [1]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/for-await...of + * + * @param value An async iterable + * @param mapper An optional function that maps from (value, index) to another + * value. Useful for generating templates for each item in the iterable. + */ +export declare const asyncReplace: (value: AsyncIterable<unknown>, _mapper?: Mapper<unknown> | undefined) => import("../directive.js").DirectiveResult<typeof AsyncReplaceDirective>; +export {}; +//# sourceMappingURL=async-replace.d.ts.map
\ No newline at end of file diff --git a/chromium/third_party/node/node_modules/lit-html/directives/cache.d.ts b/chromium/third_party/node/node_modules/lit-html/directives/cache.d.ts new file mode 100644 index 00000000000..a8f7c400fa4 --- /dev/null +++ b/chromium/third_party/node/node_modules/lit-html/directives/cache.d.ts @@ -0,0 +1,35 @@ +/** + * @license + * Copyright 2017 Google LLC + * SPDX-License-Identifier: BSD-3-Clause + */ +import { ChildPart } from '../lit-html.js'; +import { Directive, DirectiveParameters, PartInfo } from '../directive.js'; +declare class CacheDirective extends Directive { + private _templateCache; + private _value?; + constructor(partInfo: PartInfo); + render(v: unknown): unknown[]; + update(containerPart: ChildPart, [v]: DirectiveParameters<this>): unknown[]; +} +/** + * Enables fast switching between multiple templates by caching the DOM nodes + * and TemplateInstances produced by the templates. + * + * Example: + * + * ```js + * let checked = false; + * + * html` + * ${cache(checked ? html`input is checked` : html`input is not checked`)} + * ` + * ``` + */ +export declare const cache: (v: unknown) => import("../directive.js").DirectiveResult<typeof CacheDirective>; +/** + * The type of the class that powers this directive. Necessary for naming the + * directive's return type. + */ +export type { CacheDirective }; +//# sourceMappingURL=cache.d.ts.map
\ No newline at end of file diff --git a/chromium/third_party/node/node_modules/lit-html/directives/choose.d.ts b/chromium/third_party/node/node_modules/lit-html/directives/choose.d.ts new file mode 100644 index 00000000000..4091177ac4b --- /dev/null +++ b/chromium/third_party/node/node_modules/lit-html/directives/choose.d.ts @@ -0,0 +1,32 @@ +/** + * @license + * Copyright 2021 Google LLC + * SPDX-License-Identifier: BSD-3-Clause + */ +/** + * Chooses and evaluates a template function from a list based on matching + * the given `value` to a case. + * + * Cases are structured as `[caseValue, func]`. `value` is matched to + * `caseValue` by strict equality. The first match is selected. Case values + * can be of any type including primitives, objects, and symbols. + * + * This is similar to a switch statement, but as an expression and without + * fallthrough. + * + * @example + * + * ```ts + * render() { + * return html` + * ${choose(this.section, [ + * ['home', () => html`<h1>Home</h1>`], + * ['about', () => html`<h1>About</h1>`] + * ], + * () => html`<h1>Error</h1>`)} + * `; + * } + * ``` + */ +export declare const choose: <T, V, K extends T = T>(value: T, cases: [K, () => V][], defaultCase?: (() => V) | undefined) => V | undefined; +//# sourceMappingURL=choose.d.ts.map
\ No newline at end of file diff --git a/chromium/third_party/node/node_modules/lit-html/directives/class-map.d.ts b/chromium/third_party/node/node_modules/lit-html/directives/class-map.d.ts new file mode 100644 index 00000000000..d3c2d8a7c19 --- /dev/null +++ b/chromium/third_party/node/node_modules/lit-html/directives/class-map.d.ts @@ -0,0 +1,45 @@ +/** + * @license + * Copyright 2018 Google LLC + * SPDX-License-Identifier: BSD-3-Clause + */ +import { AttributePart, noChange } from '../lit-html.js'; +import { Directive, DirectiveParameters, PartInfo } from '../directive.js'; +/** + * A key-value set of class names to truthy values. + */ +export interface ClassInfo { + readonly [name: string]: string | boolean | number; +} +declare class ClassMapDirective extends Directive { + /** + * Stores the ClassInfo object applied to a given AttributePart. + * Used to unset existing values when a new ClassInfo object is applied. + */ + private _previousClasses?; + private _staticClasses?; + constructor(partInfo: PartInfo); + render(classInfo: ClassInfo): string; + update(part: AttributePart, [classInfo]: DirectiveParameters<this>): string | typeof noChange; +} +/** + * A directive that applies dynamic CSS classes. + * + * This must be used in the `class` attribute and must be the only part used in + * the attribute. It takes each property in the `classInfo` argument and adds + * the property name to the element's `classList` if the property value is + * truthy; if the property value is falsey, the property name is removed from + * the element's `class`. + * + * For example `{foo: bar}` applies the class `foo` if the value of `bar` is + * truthy. + * + * @param classInfo + */ +export declare const classMap: (classInfo: ClassInfo) => import("../directive.js").DirectiveResult<typeof ClassMapDirective>; +/** + * The type of the class that powers this directive. Necessary for naming the + * directive's return type. + */ +export type { ClassMapDirective }; +//# sourceMappingURL=class-map.d.ts.map
\ No newline at end of file diff --git a/chromium/third_party/node/node_modules/lit-html/directives/guard.d.ts b/chromium/third_party/node/node_modules/lit-html/directives/guard.d.ts new file mode 100644 index 00000000000..d571cbcfc76 --- /dev/null +++ b/chromium/third_party/node/node_modules/lit-html/directives/guard.d.ts @@ -0,0 +1,60 @@ +/** + * @license + * Copyright 2018 Google LLC + * SPDX-License-Identifier: BSD-3-Clause + */ +import { Part } from '../lit-html.js'; +import { Directive, DirectiveParameters } from '../directive.js'; +declare class GuardDirective extends Directive { + private _previousValue; + render(_value: unknown, f: () => unknown): unknown; + update(_part: Part, [value, f]: DirectiveParameters<this>): unknown; +} +/** + * Prevents re-render of a template function until a single value or an array of + * values changes. + * + * Values are checked against previous values with strict equality (`===`), and + * so the check won't detect nested property changes inside objects or arrays. + * Arrays values have each item checked against the previous value at the same + * index with strict equality. Nested arrays are also checked only by strict + * equality. + * + * Example: + * + * ```js + * html` + * <div> + * ${guard([user.id, company.id], () => html`...`)} + * </div> + * ` + * ``` + * + * In this case, the template only rerenders if either `user.id` or `company.id` + * changes. + * + * guard() is useful with immutable data patterns, by preventing expensive work + * until data updates. + * + * Example: + * + * ```js + * html` + * <div> + * ${guard([immutableItems], () => immutableItems.map(i => html`${i}`))} + * </div> + * ` + * ``` + * + * In this case, items are mapped over only when the array reference changes. + * + * @param value the value to check before re-rendering + * @param f the template function + */ +export declare const guard: (_value: unknown, f: () => unknown) => import("../directive.js").DirectiveResult<typeof GuardDirective>; +/** + * The type of the class that powers this directive. Necessary for naming the + * directive's return type. + */ +export type { GuardDirective }; +//# sourceMappingURL=guard.d.ts.map
\ No newline at end of file diff --git a/chromium/third_party/node/node_modules/lit-html/directives/if-defined.d.ts b/chromium/third_party/node/node_modules/lit-html/directives/if-defined.d.ts new file mode 100644 index 00000000000..6f169e85f8b --- /dev/null +++ b/chromium/third_party/node/node_modules/lit-html/directives/if-defined.d.ts @@ -0,0 +1,14 @@ +/** + * @license + * Copyright 2018 Google LLC + * SPDX-License-Identifier: BSD-3-Clause + */ +import { nothing } from '../lit-html.js'; +/** + * For AttributeParts, sets the attribute if the value is defined and removes + * the attribute if the value is undefined. + * + * For other part types, this directive is a no-op. + */ +export declare const ifDefined: <T>(value: T) => typeof nothing | NonNullable<T>; +//# sourceMappingURL=if-defined.d.ts.map
\ No newline at end of file diff --git a/chromium/third_party/node/node_modules/lit-html/directives/join.d.ts b/chromium/third_party/node/node_modules/lit-html/directives/join.d.ts new file mode 100644 index 00000000000..682fc603ab2 --- /dev/null +++ b/chromium/third_party/node/node_modules/lit-html/directives/join.d.ts @@ -0,0 +1,21 @@ +/** + * @license + * Copyright 2021 Google LLC + * SPDX-License-Identifier: BSD-3-Clause + */ +/** + * Returns an iterable containing the values in `items` interleaved with the + * `joiner` value. + * + * @example + * + * ```ts + * render() { + * return html` + * ${join(items, html`<span class="separator">|</span>`)} + * `; + * } + */ +export declare function join<I, J>(items: Iterable<I> | undefined, joiner: (index: number) => J): Iterable<I | J>; +export declare function join<I, J>(items: Iterable<I> | undefined, joiner: J): Iterable<I | J>; +//# sourceMappingURL=join.d.ts.map
\ No newline at end of file diff --git a/chromium/third_party/node/node_modules/lit-html/directives/keyed.d.ts b/chromium/third_party/node/node_modules/lit-html/directives/keyed.d.ts new file mode 100644 index 00000000000..457237ff8fd --- /dev/null +++ b/chromium/third_party/node/node_modules/lit-html/directives/keyed.d.ts @@ -0,0 +1,27 @@ +/** + * @license + * Copyright 2021 Google LLC + * SPDX-License-Identifier: BSD-3-Clause + */ +import { Directive, ChildPart, DirectiveParameters } from '../directive.js'; +declare class Keyed extends Directive { + key: unknown; + render(k: unknown, v: unknown): unknown; + update(part: ChildPart, [k, v]: DirectiveParameters<this>): unknown; +} +/** + * Associates a renderable value with a unique key. When the key changes, the + * previous DOM is removed and disposed before rendering the next value, even + * if the value - such as a template - is the same. + * + * This is useful for forcing re-renders of stateful components, or working + * with code that expects new data to generate new HTML elements, such as some + * animation techniques. + */ +export declare const keyed: (k: unknown, v: unknown) => import("../directive.js").DirectiveResult<typeof Keyed>; +/** + * The type of the class that powers this directive. Necessary for naming the + * directive's return type. + */ +export type { Keyed }; +//# sourceMappingURL=keyed.d.ts.map
\ No newline at end of file diff --git a/chromium/third_party/node/node_modules/lit-html/directives/live.d.ts b/chromium/third_party/node/node_modules/lit-html/directives/live.d.ts new file mode 100644 index 00000000000..f472de738a5 --- /dev/null +++ b/chromium/third_party/node/node_modules/lit-html/directives/live.d.ts @@ -0,0 +1,43 @@ +/** + * @license + * Copyright 2020 Google LLC + * SPDX-License-Identifier: BSD-3-Clause + */ +import { AttributePart } from '../lit-html.js'; +import { Directive, DirectiveParameters, PartInfo } from '../directive.js'; +declare class LiveDirective extends Directive { + constructor(partInfo: PartInfo); + render(value: unknown): unknown; + update(part: AttributePart, [value]: DirectiveParameters<this>): unknown; +} +/** + * Checks binding values against live DOM values, instead of previously bound + * values, when determining whether to update the value. + * + * This is useful for cases where the DOM value may change from outside of + * lit-html, such as with a binding to an `<input>` element's `value` property, + * a content editable elements text, or to a custom element that changes it's + * own properties or attributes. + * + * In these cases if the DOM value changes, but the value set through lit-html + * bindings hasn't, lit-html won't know to update the DOM value and will leave + * it alone. If this is not what you want--if you want to overwrite the DOM + * value with the bound value no matter what--use the `live()` directive: + * + * ```js + * html`<input .value=${live(x)}>` + * ``` + * + * `live()` performs a strict equality check against the live DOM value, and if + * the new value is equal to the live value, does nothing. This means that + * `live()` should not be used when the binding will cause a type conversion. If + * you use `live()` with an attribute binding, make sure that only strings are + * passed in, or the binding will update every render. + */ +export declare const live: (value: unknown) => import("../directive.js").DirectiveResult<typeof LiveDirective>; +/** + * The type of the class that powers this directive. Necessary for naming the + * directive's return type. + */ +export type { LiveDirective }; +//# sourceMappingURL=live.d.ts.map
\ No newline at end of file diff --git a/chromium/third_party/node/node_modules/lit-html/directives/map.d.ts b/chromium/third_party/node/node_modules/lit-html/directives/map.d.ts new file mode 100644 index 00000000000..0ebaf3ec1d4 --- /dev/null +++ b/chromium/third_party/node/node_modules/lit-html/directives/map.d.ts @@ -0,0 +1,23 @@ +/** + * @license + * Copyright 2021 Google LLC + * SPDX-License-Identifier: BSD-3-Clause + */ +/** + * Returns an iterable containing the result of calling `f(value)` on each + * value in `items`. + * + * @example + * + * ```ts + * render() { + * return html` + * <ul> + * ${map(items, (i) => html`<li>${i}</li>`)} + * </ul> + * `; + * } + * ``` + */ +export declare function map<T>(items: Iterable<T> | undefined, f: (value: T, index: number) => unknown): Generator<unknown, void, unknown>; +//# sourceMappingURL=map.d.ts.map
\ No newline at end of file diff --git a/chromium/third_party/node/node_modules/lit-html/directives/private-async-helpers.d.ts b/chromium/third_party/node/node_modules/lit-html/directives/private-async-helpers.d.ts new file mode 100644 index 00000000000..1090d68b644 --- /dev/null +++ b/chromium/third_party/node/node_modules/lit-html/directives/private-async-helpers.d.ts @@ -0,0 +1,58 @@ +/** + * @license + * Copyright 2021 Google LLC + * SPDX-License-Identifier: BSD-3-Clause + */ +/** + * Helper to iterate an AsyncIterable in its own closure. + * @param iterable The iterable to iterate + * @param callback The callback to call for each value. If the callback returns + * `false`, the loop will be broken. + */ +export declare const forAwaitOf: <T>(iterable: AsyncIterable<T>, callback: (value: T) => Promise<boolean>) => Promise<void>; +/** + * Holds a reference to an instance that can be disconnected and reconnected, + * so that a closure over the ref (e.g. in a then function to a promise) does + * not strongly hold a ref to the instance. Approximates a WeakRef but must + * be manually connected & disconnected to the backing instance. + */ +export declare class PseudoWeakRef<T> { + private _ref?; + constructor(ref: T); + /** + * Disassociates the ref with the backing instance. + */ + disconnect(): void; + /** + * Reassociates the ref with the backing instance. + */ + reconnect(ref: T): void; + /** + * Retrieves the backing instance (will be undefined when disconnected) + */ + deref(): T | undefined; +} +/** + * A helper to pause and resume waiting on a condition in an async function + */ +export declare class Pauser { + private _promise?; + private _resolve?; + /** + * When paused, returns a promise to be awaited; when unpaused, returns + * undefined. Note that in the microtask between the pauser being resumed + * an an await of this promise resolving, the pauser could be paused again, + * hence callers should check the promise in a loop when awaiting. + * @returns A promise to be awaited when paused or undefined + */ + get(): Promise<void> | undefined; + /** + * Creates a promise to be awaited + */ + pause(): void; + /** + * Resolves the promise which may be awaited + */ + resume(): void; +} +//# sourceMappingURL=private-async-helpers.d.ts.map
\ No newline at end of file diff --git a/chromium/third_party/node/node_modules/lit-html/directives/range.d.ts b/chromium/third_party/node/node_modules/lit-html/directives/range.d.ts new file mode 100644 index 00000000000..03e567f5a79 --- /dev/null +++ b/chromium/third_party/node/node_modules/lit-html/directives/range.d.ts @@ -0,0 +1,24 @@ +/** + * @license + * Copyright 2021 Google LLC + * SPDX-License-Identifier: BSD-3-Clause + */ +/** + * Returns an iterable of integers from `start` to `end` (exclusive) + * incrementing by `step`. + * + * If `start` is omitted, the range starts at `0`. `step` defaults to `1`. + * + * @example + * + * ```ts + * render() { + * return html` + * ${map(range(8), () => html`<div class="cell"></div>`)} + * `; + * } + * ``` + */ +export declare function range(end: number): Iterable<number>; +export declare function range(start: number, end: number, step?: number): Iterable<number>; +//# sourceMappingURL=range.d.ts.map
\ No newline at end of file diff --git a/chromium/third_party/node/node_modules/lit-html/directives/ref.d.ts b/chromium/third_party/node/node_modules/lit-html/directives/ref.d.ts new file mode 100644 index 00000000000..75b2191c074 --- /dev/null +++ b/chromium/third_party/node/node_modules/lit-html/directives/ref.d.ts @@ -0,0 +1,66 @@ +/** + * @license + * Copyright 2020 Google LLC + * SPDX-License-Identifier: BSD-3-Clause + */ +import { ElementPart } from '../lit-html.js'; +import { AsyncDirective } from '../async-directive.js'; +/** + * Creates a new Ref object, which is container for a reference to an element. + */ +export declare const createRef: <T = Element>() => Ref<T>; +/** + * An object that holds a ref value. + */ +declare class Ref<T = Element> { + /** + * The current Element value of the ref, or else `undefined` if the ref is no + * longer rendered. + */ + readonly value?: T; +} +export type { Ref }; +export type RefOrCallback<T = Element> = Ref<T> | ((el: T | undefined) => void); +declare class RefDirective extends AsyncDirective { + private _element?; + private _ref?; + private _context?; + render(_ref?: RefOrCallback): symbol; + update(part: ElementPart, [ref]: Parameters<this['render']>): symbol; + private _updateRefValue; + private get _lastElementForRef(); + disconnected(): void; + reconnected(): void; +} +/** + * Sets the value of a Ref object or calls a ref callback with the element it's + * bound to. + * + * A Ref object acts as a container for a reference to an element. A ref + * callback is a function that takes an element as its only argument. + * + * The ref directive sets the value of the Ref object or calls the ref callback + * during rendering, if the referenced element changed. + * + * Note: If a ref callback is rendered to a different element position or is + * removed in a subsequent render, it will first be called with `undefined`, + * followed by another call with the new element it was rendered to (if any). + * + * ```js + * // Using Ref object + * const inputRef = createRef(); + * render(html`<input ${ref(inputRef)}>`, container); + * inputRef.value.focus(); + * + * // Using callback + * const callback = (inputElement) => inputElement.focus(); + * render(html`<input ${ref(callback)}>`, container); + * ``` + */ +export declare const ref: (_ref?: RefOrCallback<Element> | undefined) => import("../directive.js").DirectiveResult<typeof RefDirective>; +/** + * The type of the class that powers this directive. Necessary for naming the + * directive's return type. + */ +export type { RefDirective }; +//# sourceMappingURL=ref.d.ts.map
\ No newline at end of file diff --git a/chromium/third_party/node/node_modules/lit-html/directives/repeat.d.ts b/chromium/third_party/node/node_modules/lit-html/directives/repeat.d.ts new file mode 100644 index 00000000000..b52b52da8c5 --- /dev/null +++ b/chromium/third_party/node/node_modules/lit-html/directives/repeat.d.ts @@ -0,0 +1,64 @@ +/** + * @license + * Copyright 2017 Google LLC + * SPDX-License-Identifier: BSD-3-Clause + */ +import { ChildPart, noChange } from '../lit-html.js'; +import { Directive, PartInfo } from '../directive.js'; +export type KeyFn<T> = (item: T, index: number) => unknown; +export type ItemTemplate<T> = (item: T, index: number) => unknown; +declare class RepeatDirective extends Directive { + private _itemKeys?; + constructor(partInfo: PartInfo); + private _getValuesAndKeys; + render<T>(items: Iterable<T>, template: ItemTemplate<T>): Array<unknown>; + render<T>(items: Iterable<T>, keyFn: KeyFn<T> | ItemTemplate<T>, template: ItemTemplate<T>): Array<unknown>; + update<T>(containerPart: ChildPart, [items, keyFnOrTemplate, template]: [ + Iterable<T>, + KeyFn<T> | ItemTemplate<T>, + ItemTemplate<T> + ]): unknown[] | typeof noChange; +} +export interface RepeatDirectiveFn { + <T>(items: Iterable<T>, keyFnOrTemplate: KeyFn<T> | ItemTemplate<T>, template?: ItemTemplate<T>): unknown; + <T>(items: Iterable<T>, template: ItemTemplate<T>): unknown; + <T>(items: Iterable<T>, keyFn: KeyFn<T> | ItemTemplate<T>, template: ItemTemplate<T>): unknown; +} +/** + * A directive that repeats a series of values (usually `TemplateResults`) + * generated from an iterable, and updates those items efficiently when the + * iterable changes based on user-provided `keys` associated with each item. + * + * Note that if a `keyFn` is provided, strict key-to-DOM mapping is maintained, + * meaning previous DOM for a given key is moved into the new position if + * needed, and DOM will never be reused with values for different keys (new DOM + * will always be created for new keys). This is generally the most efficient + * way to use `repeat` since it performs minimum unnecessary work for insertions + * and removals. + * + * The `keyFn` takes two parameters, the item and its index, and returns a unique key value. + * + * ```js + * html` + * <ol> + * ${repeat(this.items, (item) => item.id, (item, index) => { + * return html`<li>${index}: ${item.name}</li>`; + * })} + * </ol> + * ` + * ``` + * + * **Important**: If providing a `keyFn`, keys *must* be unique for all items in a + * given call to `repeat`. The behavior when two or more items have the same key + * is undefined. + * + * If no `keyFn` is provided, this directive will perform similar to mapping + * items to values, and DOM will be reused against potentially different items. + */ +export declare const repeat: RepeatDirectiveFn; +/** + * The type of the class that powers this directive. Necessary for naming the + * directive's return type. + */ +export type { RepeatDirective }; +//# sourceMappingURL=repeat.d.ts.map
\ No newline at end of file diff --git a/chromium/third_party/node/node_modules/lit-html/directives/style-map.d.ts b/chromium/third_party/node/node_modules/lit-html/directives/style-map.d.ts new file mode 100644 index 00000000000..7d93b632b82 --- /dev/null +++ b/chromium/third_party/node/node_modules/lit-html/directives/style-map.d.ts @@ -0,0 +1,50 @@ +/** + * @license + * Copyright 2018 Google LLC + * SPDX-License-Identifier: BSD-3-Clause + */ +import { AttributePart, noChange } from '../lit-html.js'; +import { Directive, DirectiveParameters, PartInfo } from '../directive.js'; +/** + * A key-value set of CSS properties and values. + * + * The key should be either a valid CSS property name string, like + * `'background-color'`, or a valid JavaScript camel case property name + * for CSSStyleDeclaration like `backgroundColor`. + */ +export interface StyleInfo { + [name: string]: string | number | undefined | null; +} +declare class StyleMapDirective extends Directive { + private _previousStyleProperties?; + constructor(partInfo: PartInfo); + render(styleInfo: Readonly<StyleInfo>): string; + update(part: AttributePart, [styleInfo]: DirectiveParameters<this>): string | typeof noChange; +} +/** + * A directive that applies CSS properties to an element. + * + * `styleMap` can only be used in the `style` attribute and must be the only + * expression in the attribute. It takes the property names in the + * {@link StyleInfo styleInfo} object and adds the properties to the inline + * style of the element. + * + * Property names with dashes (`-`) are assumed to be valid CSS + * property names and set on the element's style object using `setProperty()`. + * Names without dashes are assumed to be camelCased JavaScript property names + * and set on the element's style object using property assignment, allowing the + * style object to translate JavaScript-style names to CSS property names. + * + * For example `styleMap({backgroundColor: 'red', 'border-top': '5px', '--size': + * '0'})` sets the `background-color`, `border-top` and `--size` properties. + * + * @param styleInfo + * @see {@link https://lit.dev/docs/templates/directives/#stylemap styleMap code samples on Lit.dev} + */ +export declare const styleMap: (styleInfo: Readonly<StyleInfo>) => import("../directive.js").DirectiveResult<typeof StyleMapDirective>; +/** + * The type of the class that powers this directive. Necessary for naming the + * directive's return type. + */ +export type { StyleMapDirective }; +//# sourceMappingURL=style-map.d.ts.map
\ No newline at end of file diff --git a/chromium/third_party/node/node_modules/lit-html/directives/template-content.d.ts b/chromium/third_party/node/node_modules/lit-html/directives/template-content.d.ts new file mode 100644 index 00000000000..f28bd204677 --- /dev/null +++ b/chromium/third_party/node/node_modules/lit-html/directives/template-content.d.ts @@ -0,0 +1,26 @@ +/** + * @license + * Copyright 2020 Google LLC + * SPDX-License-Identifier: BSD-3-Clause + */ +import { noChange } from '../lit-html.js'; +import { Directive, PartInfo } from '../directive.js'; +declare class TemplateContentDirective extends Directive { + private _previousTemplate?; + constructor(partInfo: PartInfo); + render(template: HTMLTemplateElement): DocumentFragment | typeof noChange; +} +/** + * Renders the content of a template element as HTML. + * + * Note, the template should be developer controlled and not user controlled. + * Rendering a user-controlled template with this directive + * could lead to cross-site-scripting vulnerabilities. + */ +export declare const templateContent: (template: HTMLTemplateElement) => import("../directive.js").DirectiveResult<typeof TemplateContentDirective>; +/** + * The type of the class that powers this directive. Necessary for naming the + * directive's return type. + */ +export type { TemplateContentDirective }; +//# sourceMappingURL=template-content.d.ts.map
\ No newline at end of file diff --git a/chromium/third_party/node/node_modules/lit-html/directives/unsafe-html.d.ts b/chromium/third_party/node/node_modules/lit-html/directives/unsafe-html.d.ts new file mode 100644 index 00000000000..8ad4e07a026 --- /dev/null +++ b/chromium/third_party/node/node_modules/lit-html/directives/unsafe-html.d.ts @@ -0,0 +1,27 @@ +/** + * @license + * Copyright 2017 Google LLC + * SPDX-License-Identifier: BSD-3-Clause + */ +import { nothing, TemplateResult, noChange } from '../lit-html.js'; +import { Directive, PartInfo } from '../directive.js'; +export declare class UnsafeHTMLDirective extends Directive { + static directiveName: string; + static resultType: number; + private _value; + private _templateResult?; + constructor(partInfo: PartInfo); + render(value: string | typeof nothing | typeof noChange | undefined | null): typeof noChange | typeof nothing | TemplateResult | null | undefined; +} +/** + * Renders the result as HTML, rather than text. + * + * The values `undefined`, `null`, and `nothing`, will all result in no content + * (empty string) being rendered. + * + * Note, this is unsafe to use with any user-provided input that hasn't been + * sanitized or escaped, as it may lead to cross-site-scripting + * vulnerabilities. + */ +export declare const unsafeHTML: (value: string | typeof noChange | typeof nothing | null | undefined) => import("../directive.js").DirectiveResult<typeof UnsafeHTMLDirective>; +//# sourceMappingURL=unsafe-html.d.ts.map
\ No newline at end of file diff --git a/chromium/third_party/node/node_modules/lit-html/directives/unsafe-svg.d.ts b/chromium/third_party/node/node_modules/lit-html/directives/unsafe-svg.d.ts new file mode 100644 index 00000000000..82f45cb0e0a --- /dev/null +++ b/chromium/third_party/node/node_modules/lit-html/directives/unsafe-svg.d.ts @@ -0,0 +1,27 @@ +/** + * @license + * Copyright 2017 Google LLC + * SPDX-License-Identifier: BSD-3-Clause + */ +import { UnsafeHTMLDirective } from './unsafe-html.js'; +declare class UnsafeSVGDirective extends UnsafeHTMLDirective { + static directiveName: string; + static resultType: number; +} +/** + * Renders the result as SVG, rather than text. + * + * The values `undefined`, `null`, and `nothing`, will all result in no content + * (empty string) being rendered. + * + * Note, this is unsafe to use with any user-provided input that hasn't been + * sanitized or escaped, as it may lead to cross-site-scripting + * vulnerabilities. + */ +export declare const unsafeSVG: (value: string | typeof import("../lit-html.js").noChange | typeof import("../lit-html.js").nothing | null | undefined) => import("../directive.js").DirectiveResult<typeof UnsafeSVGDirective>; +/** + * The type of the class that powers this directive. Necessary for naming the + * directive's return type. + */ +export type { UnsafeSVGDirective }; +//# sourceMappingURL=unsafe-svg.d.ts.map
\ No newline at end of file diff --git a/chromium/third_party/node/node_modules/lit-html/directives/until.d.ts b/chromium/third_party/node/node_modules/lit-html/directives/until.d.ts new file mode 100644 index 00000000000..6319be2751c --- /dev/null +++ b/chromium/third_party/node/node_modules/lit-html/directives/until.d.ts @@ -0,0 +1,44 @@ +/** + * @license + * Copyright 2017 Google LLC + * SPDX-License-Identifier: BSD-3-Clause + */ +import { Part } from '../lit-html.js'; +import { AsyncDirective } from '../async-directive.js'; +export declare class UntilDirective extends AsyncDirective { + private __lastRenderedIndex; + private __values; + private __weakThis; + private __pauser; + render(...args: Array<unknown>): unknown; + update(_part: Part, args: Array<unknown>): unknown; + disconnected(): void; + reconnected(): void; +} +/** + * Renders one of a series of values, including Promises, to a Part. + * + * Values are rendered in priority order, with the first argument having the + * highest priority and the last argument having the lowest priority. If a + * value is a Promise, low-priority values will be rendered until it resolves. + * + * The priority of values can be used to create placeholder content for async + * data. For example, a Promise with pending content can be the first, + * highest-priority, argument, and a non_promise loading indicator template can + * be used as the second, lower-priority, argument. The loading indicator will + * render immediately, and the primary content will render when the Promise + * resolves. + * + * Example: + * + * ```js + * const content = fetch('./content.txt').then(r => r.text()); + * html`${until(content, html`<span>Loading...</span>`)}` + * ``` + */ +export declare const until: (...values: unknown[]) => import("../directive.js").DirectiveResult<typeof UntilDirective>; +/** + * The type of the class that powers this directive. Necessary for naming the + * directive's return type. + */ +//# sourceMappingURL=until.d.ts.map
\ No newline at end of file diff --git a/chromium/third_party/node/node_modules/lit-html/directives/when.d.ts b/chromium/third_party/node/node_modules/lit-html/directives/when.d.ts new file mode 100644 index 00000000000..1af1e70004c --- /dev/null +++ b/chromium/third_party/node/node_modules/lit-html/directives/when.d.ts @@ -0,0 +1,28 @@ +/** + * @license + * Copyright 2021 Google LLC + * SPDX-License-Identifier: BSD-3-Clause + */ +type Falsy = null | undefined | false | 0 | -0 | 0n | ''; +/** + * When `condition` is true, returns the result of calling `trueCase()`, else + * returns the result of calling `falseCase()` if `falseCase` is defined. + * + * This is a convenience wrapper around a ternary expression that makes it a + * little nicer to write an inline conditional without an else. + * + * @example + * + * ```ts + * render() { + * return html` + * ${when(this.user, () => html`User: ${this.user.username}`, () => html`Sign In...`)} + * `; + * } + * ``` + */ +export declare function when<C extends Falsy, T, F = undefined>(condition: C, trueCase: (c: C) => T, falseCase?: (c: C) => F): F; +export declare function when<C, T, F>(condition: C extends Falsy ? never : C, trueCase: (c: C) => T, falseCase?: (c: C) => F): T; +export declare function when<C, T, F = undefined>(condition: C, trueCase: (c: Exclude<C, Falsy>) => T, falseCase?: (c: Extract<C, Falsy>) => F): C extends Falsy ? F : T; +export {}; +//# sourceMappingURL=when.d.ts.map
\ No newline at end of file diff --git a/chromium/third_party/node/node_modules/lit-html/is-server.d.ts b/chromium/third_party/node/node_modules/lit-html/is-server.d.ts new file mode 100644 index 00000000000..072c7b0f962 --- /dev/null +++ b/chromium/third_party/node/node_modules/lit-html/is-server.d.ts @@ -0,0 +1,15 @@ +/** + * @license + * Copyright 2022 Google LLC + * SPDX-License-Identifier: BSD-3-Clause + */ +/** + * A boolean that will be `true` in server environments like Node, and `false` + * in browser environments. Note that your server environment or toolchain must + * support the `"node"` export condition for this to be `true`. + * + * This can be used when authoring components to change behavior based on + * whether or not the component is executing in an SSR context. + */ +export declare const isServer = false; +//# sourceMappingURL=is-server.d.ts.map
\ No newline at end of file diff --git a/chromium/third_party/node/node_modules/lit-html/is-server.js b/chromium/third_party/node/node_modules/lit-html/is-server.js new file mode 100644 index 00000000000..fa9df6fa0fd --- /dev/null +++ b/chromium/third_party/node/node_modules/lit-html/is-server.js @@ -0,0 +1,7 @@ +/** + * @license + * Copyright 2022 Google LLC + * SPDX-License-Identifier: BSD-3-Clause + */ +const o=!1;export{o as isServer}; +//# sourceMappingURL=is-server.js.map diff --git a/chromium/third_party/node/node_modules/lit-html/lit-html.d.ts b/chromium/third_party/node/node_modules/lit-html/lit-html.d.ts new file mode 100644 index 00000000000..bcb75f41107 --- /dev/null +++ b/chromium/third_party/node/node_modules/lit-html/lit-html.d.ts @@ -0,0 +1,586 @@ +/** + * @license + * Copyright 2017 Google LLC + * SPDX-License-Identifier: BSD-3-Clause + */ +/// <reference types="trusted-types" /> +import type { Directive } from './directive.js'; +/** + * Contains types that are part of the unstable debug API. + * + * Everything in this API is not stable and may change or be removed in the future, + * even on patch releases. + */ +export declare namespace LitUnstable { + /** + * When Lit is running in dev mode and `window.emitLitDebugLogEvents` is true, + * we will emit 'lit-debug' events to window, with live details about the update and render + * lifecycle. These can be useful for writing debug tooling and visualizations. + * + * Please be aware that running with window.emitLitDebugLogEvents has performance overhead, + * making certain operations that are normally very cheap (like a no-op render) much slower, + * because we must copy data and dispatch events. + */ + namespace DebugLog { + type Entry = TemplatePrep | TemplateInstantiated | TemplateInstantiatedAndUpdated | TemplateUpdating | BeginRender | EndRender | CommitPartEntry | SetPartValue; + interface TemplatePrep { + kind: 'template prep'; + template: Template; + strings: TemplateStringsArray; + clonableTemplate: HTMLTemplateElement; + parts: TemplatePart[]; + } + interface BeginRender { + kind: 'begin render'; + id: number; + value: unknown; + container: HTMLElement | DocumentFragment; + options: RenderOptions | undefined; + part: ChildPart | undefined; + } + interface EndRender { + kind: 'end render'; + id: number; + value: unknown; + container: HTMLElement | DocumentFragment; + options: RenderOptions | undefined; + part: ChildPart; + } + interface TemplateInstantiated { + kind: 'template instantiated'; + template: Template | CompiledTemplate; + instance: TemplateInstance; + options: RenderOptions | undefined; + fragment: Node; + parts: Array<Part | undefined>; + values: unknown[]; + } + interface TemplateInstantiatedAndUpdated { + kind: 'template instantiated and updated'; + template: Template | CompiledTemplate; + instance: TemplateInstance; + options: RenderOptions | undefined; + fragment: Node; + parts: Array<Part | undefined>; + values: unknown[]; + } + interface TemplateUpdating { + kind: 'template updating'; + template: Template | CompiledTemplate; + instance: TemplateInstance; + options: RenderOptions | undefined; + parts: Array<Part | undefined>; + values: unknown[]; + } + interface SetPartValue { + kind: 'set part'; + part: Part; + value: unknown; + valueIndex: number; + values: unknown[]; + templateInstance: TemplateInstance; + } + type CommitPartEntry = CommitNothingToChildEntry | CommitText | CommitNode | CommitAttribute | CommitProperty | CommitBooleanAttribute | CommitEventListener | CommitToElementBinding; + interface CommitNothingToChildEntry { + kind: 'commit nothing to child'; + start: ChildNode; + end: ChildNode | null; + parent: Disconnectable | undefined; + options: RenderOptions | undefined; + } + interface CommitText { + kind: 'commit text'; + node: Text; + value: unknown; + options: RenderOptions | undefined; + } + interface CommitNode { + kind: 'commit node'; + start: Node; + parent: Disconnectable | undefined; + value: Node; + options: RenderOptions | undefined; + } + interface CommitAttribute { + kind: 'commit attribute'; + element: Element; + name: string; + value: unknown; + options: RenderOptions | undefined; + } + interface CommitProperty { + kind: 'commit property'; + element: Element; + name: string; + value: unknown; + options: RenderOptions | undefined; + } + interface CommitBooleanAttribute { + kind: 'commit boolean attribute'; + element: Element; + name: string; + value: boolean; + options: RenderOptions | undefined; + } + interface CommitEventListener { + kind: 'commit event listener'; + element: Element; + name: string; + value: unknown; + oldListener: unknown; + options: RenderOptions | undefined; + removeListener: boolean; + addListener: boolean; + } + interface CommitToElementBinding { + kind: 'commit to element binding'; + element: Element; + value: unknown; + options: RenderOptions | undefined; + } + } +} +/** + * Used to sanitize any value before it is written into the DOM. This can be + * used to implement a security policy of allowed and disallowed values in + * order to prevent XSS attacks. + * + * One way of using this callback would be to check attributes and properties + * against a list of high risk fields, and require that values written to such + * fields be instances of a class which is safe by construction. Closure's Safe + * HTML Types is one implementation of this technique ( + * https://github.com/google/safe-html-types/blob/master/doc/safehtml-types.md). + * The TrustedTypes polyfill in API-only mode could also be used as a basis + * for this technique (https://github.com/WICG/trusted-types). + * + * @param node The HTML node (usually either a #text node or an Element) that + * is being written to. Note that this is just an exemplar node, the write + * may take place against another instance of the same class of node. + * @param name The name of an attribute or property (for example, 'href'). + * @param type Indicates whether the write that's about to be performed will + * be to a property or a node. + * @return A function that will sanitize this class of writes. + */ +export type SanitizerFactory = (node: Node, name: string, type: 'property' | 'attribute') => ValueSanitizer; +/** + * A function which can sanitize values that will be written to a specific kind + * of DOM sink. + * + * See SanitizerFactory. + * + * @param value The value to sanitize. Will be the actual value passed into + * the lit-html template literal, so this could be of any type. + * @return The value to write to the DOM. Usually the same as the input value, + * unless sanitization is needed. + */ +export type ValueSanitizer = (value: unknown) => unknown; +/** TemplateResult types */ +declare const HTML_RESULT = 1; +declare const SVG_RESULT = 2; +type ResultType = typeof HTML_RESULT | typeof SVG_RESULT; +declare const ATTRIBUTE_PART = 1; +declare const CHILD_PART = 2; +declare const ELEMENT_PART = 6; +declare const COMMENT_PART = 7; +/** + * The return type of the template tag functions, {@linkcode html} and + * {@linkcode svg} when it hasn't been compiled by @lit-labs/compiler. + * + * A `TemplateResult` object holds all the information about a template + * expression required to render it: the template strings, expression values, + * and type of template (html or svg). + * + * `TemplateResult` objects do not create any DOM on their own. To create or + * update DOM you need to render the `TemplateResult`. See + * [Rendering](https://lit.dev/docs/components/rendering) for more information. + * + */ +export type UncompiledTemplateResult<T extends ResultType = ResultType> = { + ['_$litType$']: T; + strings: TemplateStringsArray; + values: unknown[]; +}; +/** + * This is a template result that may be either uncompiled or compiled. + * + * In the future, TemplateResult will be this type. If you want to explicitly + * note that a template result is potentially compiled, you can reference this + * type and it will continue to behave the same through the next major version + * of Lit. This can be useful for code that wants to prepare for the next + * major version of Lit. + */ +export type MaybeCompiledTemplateResult<T extends ResultType = ResultType> = UncompiledTemplateResult<T> | CompiledTemplateResult; +/** + * The return type of the template tag functions, {@linkcode html} and + * {@linkcode svg}. + * + * A `TemplateResult` object holds all the information about a template + * expression required to render it: the template strings, expression values, + * and type of template (html or svg). + * + * `TemplateResult` objects do not create any DOM on their own. To create or + * update DOM you need to render the `TemplateResult`. See + * [Rendering](https://lit.dev/docs/components/rendering) for more information. + * + * In Lit 4, this type will be an alias of + * MaybeCompiledTemplateResult, so that code will get type errors if it assumes + * that Lit templates are not compiled. When deliberately working with only + * one, use either {@linkcode CompiledTemplateResult} or + * {@linkcode UncompiledTemplateResult} explicitly. + */ +export type TemplateResult<T extends ResultType = ResultType> = UncompiledTemplateResult<T>; +export type HTMLTemplateResult = TemplateResult<typeof HTML_RESULT>; +export type SVGTemplateResult = TemplateResult<typeof SVG_RESULT>; +/** + * A TemplateResult that has been compiled by @lit-labs/compiler, skipping the + * prepare step. + */ +export interface CompiledTemplateResult { + ['_$litType$']: CompiledTemplate; + values: unknown[]; +} +export interface CompiledTemplate extends Omit<Template, 'el'> { + el?: HTMLTemplateElement; + h: TemplateStringsArray; +} +/** + * Interprets a template literal as an HTML template that can efficiently + * render to and update a container. + * + * ```ts + * const header = (title: string) => html`<h1>${title}</h1>`; + * ``` + * + * The `html` tag returns a description of the DOM to render as a value. It is + * lazy, meaning no work is done until the template is rendered. When rendering, + * if a template comes from the same expression as a previously rendered result, + * it's efficiently updated instead of replaced. + */ +export declare const html: (strings: TemplateStringsArray, ...values: unknown[]) => TemplateResult<1>; +/** + * Interprets a template literal as an SVG fragment that can efficiently + * render to and update a container. + * + * ```ts + * const rect = svg`<rect width="10" height="10"></rect>`; + * + * const myImage = html` + * <svg viewBox="0 0 10 10" xmlns="http://www.w3.org/2000/svg"> + * ${rect} + * </svg>`; + * ``` + * + * The `svg` *tag function* should only be used for SVG fragments, or elements + * that would be contained **inside** an `<svg>` HTML element. A common error is + * placing an `<svg>` *element* in a template tagged with the `svg` tag + * function. The `<svg>` element is an HTML element and should be used within a + * template tagged with the {@linkcode html} tag function. + * + * In LitElement usage, it's invalid to return an SVG fragment from the + * `render()` method, as the SVG fragment will be contained within the element's + * shadow root and thus cannot be used within an `<svg>` HTML element. + */ +export declare const svg: (strings: TemplateStringsArray, ...values: unknown[]) => TemplateResult<2>; +/** + * A sentinel value that signals that a value was handled by a directive and + * should not be written to the DOM. + */ +export declare const noChange: unique symbol; +/** + * A sentinel value that signals a ChildPart to fully clear its content. + * + * ```ts + * const button = html`${ + * user.isAdmin + * ? html`<button>DELETE</button>` + * : nothing + * }`; + * ``` + * + * Prefer using `nothing` over other falsy values as it provides a consistent + * behavior between various expression binding contexts. + * + * In child expressions, `undefined`, `null`, `''`, and `nothing` all behave the + * same and render no nodes. In attribute expressions, `nothing` _removes_ the + * attribute, while `undefined` and `null` will render an empty string. In + * property expressions `nothing` becomes `undefined`. + */ +export declare const nothing: unique symbol; +/** + * Object specifying options for controlling lit-html rendering. Note that + * while `render` may be called multiple times on the same `container` (and + * `renderBefore` reference node) to efficiently update the rendered content, + * only the options passed in during the first render are respected during + * the lifetime of renders to that unique `container` + `renderBefore` + * combination. + */ +export interface RenderOptions { + /** + * An object to use as the `this` value for event listeners. It's often + * useful to set this to the host component rendering a template. + */ + host?: object; + /** + * A DOM node before which to render content in the container. + */ + renderBefore?: ChildNode | null; + /** + * Node used for cloning the template (`importNode` will be called on this + * node). This controls the `ownerDocument` of the rendered DOM, along with + * any inherited context. Defaults to the global `document`. + */ + creationScope?: { + importNode(node: Node, deep?: boolean): Node; + }; + /** + * The initial connected state for the top-level part being rendered. If no + * `isConnected` option is set, `AsyncDirective`s will be connected by + * default. Set to `false` if the initial render occurs in a disconnected tree + * and `AsyncDirective`s should see `isConnected === false` for their initial + * render. The `part.setConnected()` method must be used subsequent to initial + * render to change the connected state of the part. + */ + isConnected?: boolean; +} +export interface DirectiveParent { + _$parent?: DirectiveParent; + _$isConnected: boolean; + __directive?: Directive; + __directives?: Array<Directive | undefined>; +} +declare class Template { + parts: Array<TemplatePart>; + constructor({ strings, ['_$litType$']: type }: UncompiledTemplateResult, options?: RenderOptions); + /** @nocollapse */ + static createElement(html: TrustedHTML, _options?: RenderOptions): HTMLTemplateElement; +} +export interface Disconnectable { + _$parent?: Disconnectable; + _$disconnectableChildren?: Set<Disconnectable>; + _$isConnected: boolean; +} +declare function resolveDirective(part: ChildPart | AttributePart | ElementPart, value: unknown, parent?: DirectiveParent, attributeIndex?: number): unknown; +export type { TemplateInstance }; +/** + * An updateable instance of a Template. Holds references to the Parts used to + * update the template instance. + */ +declare class TemplateInstance implements Disconnectable { + _$template: Template; + _$parts: Array<Part | undefined>; + constructor(template: Template, parent: ChildPart); + get parentNode(): Node; + get _$isConnected(): boolean; + _clone(options: RenderOptions | undefined): Node; + _update(values: Array<unknown>): void; +} +type AttributeTemplatePart = { + readonly type: typeof ATTRIBUTE_PART; + readonly index: number; + readonly name: string; + readonly ctor: typeof AttributePart; + readonly strings: ReadonlyArray<string>; +}; +type ChildTemplatePart = { + readonly type: typeof CHILD_PART; + readonly index: number; +}; +type ElementTemplatePart = { + readonly type: typeof ELEMENT_PART; + readonly index: number; +}; +type CommentTemplatePart = { + readonly type: typeof COMMENT_PART; + readonly index: number; +}; +/** + * A TemplatePart represents a dynamic part in a template, before the template + * is instantiated. When a template is instantiated Parts are created from + * TemplateParts. + */ +type TemplatePart = ChildTemplatePart | AttributeTemplatePart | ElementTemplatePart | CommentTemplatePart; +export type Part = ChildPart | AttributePart | PropertyPart | BooleanAttributePart | ElementPart | EventPart; +export type { ChildPart }; +declare class ChildPart implements Disconnectable { + readonly type = 2; + readonly options: RenderOptions | undefined; + _$committedValue: unknown; + private _textSanitizer; + get _$isConnected(): boolean; + constructor(startNode: ChildNode, endNode: ChildNode | null, parent: TemplateInstance | ChildPart | undefined, options: RenderOptions | undefined); + /** + * The parent node into which the part renders its content. + * + * A ChildPart's content consists of a range of adjacent child nodes of + * `.parentNode`, possibly bordered by 'marker nodes' (`.startNode` and + * `.endNode`). + * + * - If both `.startNode` and `.endNode` are non-null, then the part's content + * consists of all siblings between `.startNode` and `.endNode`, exclusively. + * + * - If `.startNode` is non-null but `.endNode` is null, then the part's + * content consists of all siblings following `.startNode`, up to and + * including the last child of `.parentNode`. If `.endNode` is non-null, then + * `.startNode` will always be non-null. + * + * - If both `.endNode` and `.startNode` are null, then the part's content + * consists of all child nodes of `.parentNode`. + */ + get parentNode(): Node; + /** + * The part's leading marker node, if any. See `.parentNode` for more + * information. + */ + get startNode(): Node | null; + /** + * The part's trailing marker node, if any. See `.parentNode` for more + * information. + */ + get endNode(): Node | null; + _$setValue(value: unknown, directiveParent?: DirectiveParent): void; + private _insert; + private _commitNode; + private _commitText; + private _commitTemplateResult; + private _commitIterable; +} +/** + * A top-level `ChildPart` returned from `render` that manages the connected + * state of `AsyncDirective`s created throughout the tree below it. + */ +export interface RootPart extends ChildPart { + /** + * Sets the connection state for `AsyncDirective`s contained within this root + * ChildPart. + * + * lit-html does not automatically monitor the connectedness of DOM rendered; + * as such, it is the responsibility of the caller to `render` to ensure that + * `part.setConnected(false)` is called before the part object is potentially + * discarded, to ensure that `AsyncDirective`s have a chance to dispose of + * any resources being held. If a `RootPart` that was previously + * disconnected is subsequently re-connected (and its `AsyncDirective`s should + * re-connect), `setConnected(true)` should be called. + * + * @param isConnected Whether directives within this tree should be connected + * or not + */ + setConnected(isConnected: boolean): void; +} +export type { AttributePart }; +declare class AttributePart implements Disconnectable { + readonly type: 1 | 3 | 4 | 5; + readonly element: HTMLElement; + readonly name: string; + readonly options: RenderOptions | undefined; + /** + * If this attribute part represents an interpolation, this contains the + * static strings of the interpolation. For single-value, complete bindings, + * this is undefined. + */ + readonly strings?: ReadonlyArray<string>; + protected _sanitizer: ValueSanitizer | undefined; + get tagName(): string; + get _$isConnected(): boolean; + constructor(element: HTMLElement, name: string, strings: ReadonlyArray<string>, parent: Disconnectable, options: RenderOptions | undefined); +} +export type { PropertyPart }; +declare class PropertyPart extends AttributePart { + readonly type = 3; +} +export type { BooleanAttributePart }; +declare class BooleanAttributePart extends AttributePart { + readonly type = 4; +} +/** + * An AttributePart that manages an event listener via add/removeEventListener. + * + * This part works by adding itself as the event listener on an element, then + * delegating to the value passed to it. This reduces the number of calls to + * add/removeEventListener if the listener changes frequently, such as when an + * inline function is used as a listener. + * + * Because event options are passed when adding listeners, we must take case + * to add and remove the part as a listener when the event options change. + */ +export type { EventPart }; +declare class EventPart extends AttributePart { + readonly type = 5; + constructor(element: HTMLElement, name: string, strings: ReadonlyArray<string>, parent: Disconnectable, options: RenderOptions | undefined); + handleEvent(event: Event): void; +} +export type { ElementPart }; +declare class ElementPart implements Disconnectable { + element: Element; + readonly type = 6; + _$committedValue: undefined; + options: RenderOptions | undefined; + constructor(element: Element, parent: Disconnectable, options: RenderOptions | undefined); + get _$isConnected(): boolean; + _$setValue(value: unknown): void; +} +/** + * END USERS SHOULD NOT RELY ON THIS OBJECT. + * + * Private exports for use by other Lit packages, not intended for use by + * external users. + * + * 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. + * + * This has a unique name, to disambiguate it from private exports in + * lit-element, which re-exports all of lit-html. + * + * @private + */ +export declare const _$LH: { + _boundAttributeSuffix: string; + _marker: string; + _markerMatch: string; + _HTML_RESULT: number; + _getTemplateHtml: (strings: TemplateStringsArray, type: ResultType) => [TrustedHTML, Array<string>]; + _TemplateInstance: typeof TemplateInstance; + _isIterable: (value: unknown) => value is Iterable<unknown>; + _resolveDirective: typeof resolveDirective; + _ChildPart: typeof ChildPart; + _AttributePart: typeof AttributePart; + _BooleanAttributePart: typeof BooleanAttributePart; + _EventPart: typeof EventPart; + _PropertyPart: typeof PropertyPart; + _ElementPart: typeof ElementPart; +}; +/** + * Renders a value, usually a lit-html TemplateResult, to the container. + * + * This example renders the text "Hello, Zoe!" inside a paragraph tag, appending + * it to the container `document.body`. + * + * ```js + * import {html, render} from 'lit'; + * + * const name = "Zoe"; + * render(html`<p>Hello, ${name}!</p>`, document.body); + * ``` + * + * @param value Any [renderable + * value](https://lit.dev/docs/templates/expressions/#child-expressions), + * typically a {@linkcode TemplateResult} created by evaluating a template tag + * like {@linkcode html} or {@linkcode svg}. + * @param container A DOM container to render to. The first render will append + * the rendered value to the container, and subsequent renders will + * efficiently update the rendered value if the same result type was + * previously rendered there. + * @param options See {@linkcode RenderOptions} for options documentation. + * @see + * {@link https://lit.dev/docs/libraries/standalone-templates/#rendering-lit-html-templates| Rendering Lit HTML Templates} + */ +export declare const render: { + (value: unknown, container: HTMLElement | DocumentFragment, options?: RenderOptions): RootPart; + setSanitizer: (newSanitizer: SanitizerFactory) => void; + createSanitizer: SanitizerFactory; + _testOnlyClearSanitizerFactoryDoNotCallOrElse: () => void; +}; +//# sourceMappingURL=lit-html.d.ts.map
\ No newline at end of file diff --git a/chromium/third_party/node/node_modules/lit-html/lit-html.js b/chromium/third_party/node/node_modules/lit-html/lit-html.js new file mode 100644 index 00000000000..d97e52ec65b --- /dev/null +++ b/chromium/third_party/node/node_modules/lit-html/lit-html.js @@ -0,0 +1,7 @@ +/** + * @license + * Copyright 2017 Google LLC + * SPDX-License-Identifier: BSD-3-Clause + */ +const t=globalThis,i=t.trustedTypes,s=i?i.createPolicy("lit-html-desktop",{createHTML:t=>t}):void 0,e="$lit$",h=`lit$${(Math.random()+"").slice(9)}$`,o="?"+h,n=`<${o}>`,r=document,l=()=>r.createComment(""),c=t=>null===t||"object"!=typeof t&&"function"!=typeof t,a=Array.isArray,u=t=>a(t)||"function"==typeof t?.[Symbol.iterator],d="[ \t\n\f\r]",f=/<(?:(!--|\/[^a-zA-Z])|(\/?[a-zA-Z][^>\s]*)|(\/?$))/g,v=/-->/g,_=/>/g,m=RegExp(`>|${d}(?:([^\\s"'>=/]+)(${d}*=${d}*(?:[^ \t\n\f\r"'\`<>=]|("|')|))|$)`,"g"),p=/'/g,g=/"/g,$=/^(?:script|style|textarea|title)$/i,y=t=>(i,...s)=>({_$litType$:t,strings:i,values:s}),x=y(1),b=y(2),w=Symbol.for("lit-noChange"),T=Symbol.for("lit-nothing"),A=new WeakMap,E=r.createTreeWalker(r,129);function C(t,i){if(!Array.isArray(t)||!t.hasOwnProperty("raw"))throw Error("invalid template strings array");return void 0!==s?s.createHTML(i):i}const P=(t,i)=>{const s=t.length-1,o=[];let r,l=2===i?"<svg>":"",c=f;for(let i=0;i<s;i++){const s=t[i];let a,u,d=-1,y=0;for(;y<s.length&&(c.lastIndex=y,u=c.exec(s),null!==u);)y=c.lastIndex,c===f?"!--"===u[1]?c=v:void 0!==u[1]?c=_:void 0!==u[2]?($.test(u[2])&&(r=RegExp("</"+u[2],"g")),c=m):void 0!==u[3]&&(c=m):c===m?">"===u[0]?(c=r??f,d=-1):void 0===u[1]?d=-2:(d=c.lastIndex-u[2].length,a=u[1],c=void 0===u[3]?m:'"'===u[3]?g:p):c===g||c===p?c=m:c===v||c===_?c=f:(c=m,r=void 0);const x=c===m&&t[i+1].startsWith("/>")?" ":"";l+=c===f?s+n:d>=0?(o.push(a),s.slice(0,d)+e+s.slice(d)+h+x):s+h+(-2===d?i:x)}return[C(t,l+(t[s]||"<?>")+(2===i?"</svg>":"")),o]};class V{constructor({strings:t,_$litType$:s},n){let r;this.parts=[];let c=0,a=0;const u=t.length-1,d=this.parts,[f,v]=P(t,s);if(this.el=V.createElement(f,n),E.currentNode=this.el.content,2===s){const t=this.el.content.firstChild;t.replaceWith(...t.childNodes)}for(;null!==(r=E.nextNode())&&d.length<u;){if(1===r.nodeType){if(r.hasAttributes())for(const t of r.getAttributeNames())if(t.endsWith(e)){const i=v[a++],s=r.getAttribute(t).split(h),e=/([.?@])?(.*)/.exec(i);d.push({type:1,index:c,name:e[2],strings:s,ctor:"."===e[1]?k:"?"===e[1]?H:"@"===e[1]?I:R}),r.removeAttribute(t)}else t.startsWith(h)&&(d.push({type:6,index:c}),r.removeAttribute(t));if($.test(r.tagName)){const t=r.textContent.split(h),s=t.length-1;if(s>0){r.textContent=i?i.emptyScript:"";for(let i=0;i<s;i++)r.append(t[i],l()),E.nextNode(),d.push({type:2,index:++c});r.append(t[s],l())}}}else if(8===r.nodeType)if(r.data===o)d.push({type:2,index:c});else{let t=-1;for(;-1!==(t=r.data.indexOf(h,t+1));)d.push({type:7,index:c}),t+=h.length-1}c++}}static createElement(t,i){const s=r.createElement("template");return s.innerHTML=t,s}}function N(t,i,s=t,e){if(i===w)return i;let h=void 0!==e?s._$Co?.[e]:s._$Cl;const o=c(i)?void 0:i._$litDirective$;return h?.constructor!==o&&(h?._$AO?.(!1),void 0===o?h=void 0:(h=new o(t),h._$AT(t,s,e)),void 0!==e?(s._$Co??=[])[e]=h:s._$Cl=h),void 0!==h&&(i=N(t,h._$AS(t,i.values),h,e)),i}class S{constructor(t,i){this._$AV=[],this._$AN=void 0,this._$AD=t,this._$AM=i}get parentNode(){return this._$AM.parentNode}get _$AU(){return this._$AM._$AU}u(t){const{el:{content:i},parts:s}=this._$AD,e=(t?.creationScope??r).importNode(i,!0);E.currentNode=e;let h=E.nextNode(),o=0,n=0,l=s[0];for(;void 0!==l;){if(o===l.index){let i;2===l.type?i=new M(h,h.nextSibling,this,t):1===l.type?i=new l.ctor(h,l.name,l.strings,this,t):6===l.type&&(i=new L(h,this,t)),this._$AV.push(i),l=s[++n]}o!==l?.index&&(h=E.nextNode(),o++)}return E.currentNode=r,e}p(t){let i=0;for(const s of this._$AV)void 0!==s&&(void 0!==s.strings?(s._$AI(t,s,i),i+=s.strings.length-2):s._$AI(t[i])),i++}}class M{get _$AU(){return this._$AM?._$AU??this._$Cv}constructor(t,i,s,e){this.type=2,this._$AH=T,this._$AN=void 0,this._$AA=t,this._$AB=i,this._$AM=s,this.options=e,this._$Cv=e?.isConnected??!0}get parentNode(){let t=this._$AA.parentNode;const i=this._$AM;return void 0!==i&&11===t?.nodeType&&(t=i.parentNode),t}get startNode(){return this._$AA}get endNode(){return this._$AB}_$AI(t,i=this){t=N(this,t,i),c(t)?t===T||null==t||""===t?(this._$AH!==T&&this._$AR(),this._$AH=T):t!==this._$AH&&t!==w&&this._(t):void 0!==t._$litType$?this.g(t):void 0!==t.nodeType?this.$(t):u(t)?this.T(t):this._(t)}k(t){return this._$AA.parentNode.insertBefore(t,this._$AB)}$(t){this._$AH!==t&&(this._$AR(),this._$AH=this.k(t))}_(t){this._$AH!==T&&c(this._$AH)?this._$AA.nextSibling.data=t:this.$(r.createTextNode(t)),this._$AH=t}g(t){const{values:i,_$litType$:s}=t,e="number"==typeof s?this._$AC(t):(void 0===s.el&&(s.el=V.createElement(C(s.h,s.h[0]),this.options)),s);if(this._$AH?._$AD===e)this._$AH.p(i);else{const t=new S(e,this),s=t.u(this.options);t.p(i),this.$(s),this._$AH=t}}_$AC(t){let i=A.get(t.strings);return void 0===i&&A.set(t.strings,i=new V(t)),i}T(t){a(this._$AH)||(this._$AH=[],this._$AR());const i=this._$AH;let s,e=0;for(const h of t)e===i.length?i.push(s=new M(this.k(l()),this.k(l()),this,this.options)):s=i[e],s._$AI(h),e++;e<i.length&&(this._$AR(s&&s._$AB.nextSibling,e),i.length=e)}_$AR(t=this._$AA.nextSibling,i){for(this._$AP?.(!1,!0,i);t&&t!==this._$AB;){const i=t.nextSibling;t.remove(),t=i}}setConnected(t){void 0===this._$AM&&(this._$Cv=t,this._$AP?.(t))}}class R{get tagName(){return this.element.tagName}get _$AU(){return this._$AM._$AU}constructor(t,i,s,e,h){this.type=1,this._$AH=T,this._$AN=void 0,this.element=t,this.name=i,this._$AM=e,this.options=h,s.length>2||""!==s[0]||""!==s[1]?(this._$AH=Array(s.length-1).fill(new String),this.strings=s):this._$AH=T}_$AI(t,i=this,s,e){const h=this.strings;let o=!1;if(void 0===h)t=N(this,t,i,0),o=!c(t)||t!==this._$AH&&t!==w,o&&(this._$AH=t);else{const e=t;let n,r;for(t=h[0],n=0;n<h.length-1;n++)r=N(this,e[s+n],i,n),r===w&&(r=this._$AH[n]),o||=!c(r)||r!==this._$AH[n],r===T?t=T:t!==T&&(t+=(r??"")+h[n+1]),this._$AH[n]=r}o&&!e&&this.O(t)}O(t){t===T?this.element.removeAttribute(this.name):this.element.setAttribute(this.name,t??"")}}class k extends R{constructor(){super(...arguments),this.type=3}O(t){this.element[this.name]=t===T?void 0:t}}class H extends R{constructor(){super(...arguments),this.type=4}O(t){this.element.toggleAttribute(this.name,!!t&&t!==T)}}class I extends R{constructor(t,i,s,e,h){super(t,i,s,e,h),this.type=5}_$AI(t,i=this){if((t=N(this,t,i,0)??T)===w)return;const s=this._$AH,e=t===T&&s!==T||t.capture!==s.capture||t.once!==s.once||t.passive!==s.passive,h=t!==T&&(s===T||e);e&&this.element.removeEventListener(this.name,this,s),h&&this.element.addEventListener(this.name,this,t),this._$AH=t}handleEvent(t){"function"==typeof this._$AH?this._$AH.call(this.options?.host??this.element,t):this._$AH.handleEvent(t)}}class L{constructor(t,i,s){this.element=t,this.type=6,this._$AN=void 0,this._$AM=i,this.options=s}get _$AU(){return this._$AM._$AU}_$AI(t){N(this,t)}}const z={j:e,P:h,A:o,C:1,M:P,L:S,R:u,V:N,D:M,I:R,H,N:I,U:k,B:L},Z=t.litHtmlPolyfillSupport;Z?.(V,M),(t.litHtmlVersions??=[]).push("3.1.0");const j=(t,i,s)=>{const e=s?.renderBefore??i;let h=e._$litPart$;if(void 0===h){const t=s?.renderBefore??null;e._$litPart$=h=new M(i.insertBefore(l(),t),t,void 0,s??{})}return h._$AI(t),h};export{z as _$LH,x as html,w as noChange,T as nothing,j as render,b as svg}; +//# sourceMappingURL=lit-html.js.map diff --git a/chromium/third_party/node/node_modules/lit-html/static.d.ts b/chromium/third_party/node/node_modules/lit-html/static.d.ts new file mode 100644 index 00000000000..6987051bf97 --- /dev/null +++ b/chromium/third_party/node/node_modules/lit-html/static.d.ts @@ -0,0 +1,82 @@ +/** + * @license + * Copyright 2020 Google LLC + * SPDX-License-Identifier: BSD-3-Clause + */ +import { html as coreHtml, svg as coreSvg, TemplateResult } from './lit-html.js'; +export interface StaticValue { + /** The value to interpolate as-is into the template. */ + _$litStatic$: string; + /** + * A value that can't be decoded from ordinary JSON, make it harder for + * a attacker-controlled data that goes through JSON.parse to produce a valid + * StaticValue. + */ + r: typeof brand; +} +/** + * Prevents JSON injection attacks. + * + * The goals of this brand: + * 1) fast to check + * 2) code is small on the wire + * 3) multiple versions of Lit in a single page will all produce mutually + * interoperable StaticValues + * 4) normal JSON.parse (without an unusual reviver) can not produce a + * StaticValue + * + * Symbols satisfy (1), (2), and (4). We use Symbol.for to satisfy (3), but + * we don't care about the key, so we break ties via (2) and use the empty + * string. + */ +declare const brand: unique symbol; +/** + * 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) => StaticValue; +/** + * 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[]) => StaticValue; +/** + * 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.js`. + */ +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.js`. + */ +export declare const svg: (strings: TemplateStringsArray, ...values: unknown[]) => TemplateResult; +export {}; +//# sourceMappingURL=static.d.ts.map
\ No newline at end of file diff --git a/chromium/third_party/node/node_modules/lit/LICENSE b/chromium/third_party/node/node_modules/lit/LICENSE new file mode 100644 index 00000000000..be7a97b60d7 --- /dev/null +++ b/chromium/third_party/node/node_modules/lit/LICENSE @@ -0,0 +1,28 @@ +BSD 3-Clause License + +Copyright (c) 2017 Google LLC. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + +1. Redistributions of source code must retain the above copyright notice, this + list of conditions and the following disclaimer. + +2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions and the following disclaimer in the documentation + and/or other materials provided with the distribution. + +3. Neither the name of the copyright holder nor the names of its + contributors may be used to endorse or promote products derived from + this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE +FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR +SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, +OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
\ No newline at end of file diff --git a/chromium/third_party/node/node_modules/lit/async-directive.d.ts b/chromium/third_party/node/node_modules/lit/async-directive.d.ts new file mode 100644 index 00000000000..a73d6277470 --- /dev/null +++ b/chromium/third_party/node/node_modules/lit/async-directive.d.ts @@ -0,0 +1,7 @@ +/** + * @license + * Copyright 2021 Google LLC + * SPDX-License-Identifier: BSD-3-Clause + */ +export * from 'lit-html/async-directive.js'; +//# sourceMappingURL=async-directive.d.ts.map
\ No newline at end of file diff --git a/chromium/third_party/node/node_modules/lit/directive-helpers.d.ts b/chromium/third_party/node/node_modules/lit/directive-helpers.d.ts new file mode 100644 index 00000000000..58c1e06744f --- /dev/null +++ b/chromium/third_party/node/node_modules/lit/directive-helpers.d.ts @@ -0,0 +1,7 @@ +/** + * @license + * Copyright 2021 Google LLC + * SPDX-License-Identifier: BSD-3-Clause + */ +export * from 'lit-html/directive-helpers.js'; +//# sourceMappingURL=directive-helpers.d.ts.map
\ No newline at end of file diff --git a/chromium/third_party/node/node_modules/lit/directive.d.ts b/chromium/third_party/node/node_modules/lit/directive.d.ts new file mode 100644 index 00000000000..463d4775380 --- /dev/null +++ b/chromium/third_party/node/node_modules/lit/directive.d.ts @@ -0,0 +1,7 @@ +/** + * @license + * Copyright 2021 Google LLC + * SPDX-License-Identifier: BSD-3-Clause + */ +export * from 'lit-html/directive.js'; +//# sourceMappingURL=directive.d.ts.map
\ No newline at end of file diff --git a/chromium/third_party/node/node_modules/lit/directives/async-append.d.ts b/chromium/third_party/node/node_modules/lit/directives/async-append.d.ts new file mode 100644 index 00000000000..529b31252d0 --- /dev/null +++ b/chromium/third_party/node/node_modules/lit/directives/async-append.d.ts @@ -0,0 +1,7 @@ +/** + * @license + * Copyright 2021 Google LLC + * SPDX-License-Identifier: BSD-3-Clause + */ +export * from 'lit-html/directives/async-append.js'; +//# sourceMappingURL=async-append.d.ts.map
\ No newline at end of file diff --git a/chromium/third_party/node/node_modules/lit/directives/async-replace.d.ts b/chromium/third_party/node/node_modules/lit/directives/async-replace.d.ts new file mode 100644 index 00000000000..71361d8eb88 --- /dev/null +++ b/chromium/third_party/node/node_modules/lit/directives/async-replace.d.ts @@ -0,0 +1,7 @@ +/** + * @license + * Copyright 2021 Google LLC + * SPDX-License-Identifier: BSD-3-Clause + */ +export * from 'lit-html/directives/async-replace.js'; +//# sourceMappingURL=async-replace.d.ts.map
\ No newline at end of file diff --git a/chromium/third_party/node/node_modules/lit/directives/cache.d.ts b/chromium/third_party/node/node_modules/lit/directives/cache.d.ts new file mode 100644 index 00000000000..fdc2c74211f --- /dev/null +++ b/chromium/third_party/node/node_modules/lit/directives/cache.d.ts @@ -0,0 +1,7 @@ +/** + * @license + * Copyright 2021 Google LLC + * SPDX-License-Identifier: BSD-3-Clause + */ +export * from 'lit-html/directives/cache.js'; +//# sourceMappingURL=cache.d.ts.map
\ No newline at end of file diff --git a/chromium/third_party/node/node_modules/lit/directives/choose.d.ts b/chromium/third_party/node/node_modules/lit/directives/choose.d.ts new file mode 100644 index 00000000000..7a88e70cec5 --- /dev/null +++ b/chromium/third_party/node/node_modules/lit/directives/choose.d.ts @@ -0,0 +1,7 @@ +/** + * @license + * Copyright 2021 Google LLC + * SPDX-License-Identifier: BSD-3-Clause + */ +export * from 'lit-html/directives/choose.js'; +//# sourceMappingURL=choose.d.ts.map
\ No newline at end of file diff --git a/chromium/third_party/node/node_modules/lit/directives/class-map.d.ts b/chromium/third_party/node/node_modules/lit/directives/class-map.d.ts new file mode 100644 index 00000000000..a0561c6c4a3 --- /dev/null +++ b/chromium/third_party/node/node_modules/lit/directives/class-map.d.ts @@ -0,0 +1,7 @@ +/** + * @license + * Copyright 2021 Google LLC + * SPDX-License-Identifier: BSD-3-Clause + */ +export * from 'lit-html/directives/class-map.js'; +//# sourceMappingURL=class-map.d.ts.map
\ No newline at end of file diff --git a/chromium/third_party/node/node_modules/lit/directives/guard.d.ts b/chromium/third_party/node/node_modules/lit/directives/guard.d.ts new file mode 100644 index 00000000000..80abe98094c --- /dev/null +++ b/chromium/third_party/node/node_modules/lit/directives/guard.d.ts @@ -0,0 +1,7 @@ +/** + * @license + * Copyright 2021 Google LLC + * SPDX-License-Identifier: BSD-3-Clause + */ +export * from 'lit-html/directives/guard.js'; +//# sourceMappingURL=guard.d.ts.map
\ No newline at end of file diff --git a/chromium/third_party/node/node_modules/lit/directives/if-defined.d.ts b/chromium/third_party/node/node_modules/lit/directives/if-defined.d.ts new file mode 100644 index 00000000000..089cef0e384 --- /dev/null +++ b/chromium/third_party/node/node_modules/lit/directives/if-defined.d.ts @@ -0,0 +1,7 @@ +/** + * @license + * Copyright 2021 Google LLC + * SPDX-License-Identifier: BSD-3-Clause + */ +export * from 'lit-html/directives/if-defined.js'; +//# sourceMappingURL=if-defined.d.ts.map
\ No newline at end of file diff --git a/chromium/third_party/node/node_modules/lit/directives/join.d.ts b/chromium/third_party/node/node_modules/lit/directives/join.d.ts new file mode 100644 index 00000000000..244bd8afe1c --- /dev/null +++ b/chromium/third_party/node/node_modules/lit/directives/join.d.ts @@ -0,0 +1,7 @@ +/** + * @license + * Copyright 2021 Google LLC + * SPDX-License-Identifier: BSD-3-Clause + */ +export * from 'lit-html/directives/join.js'; +//# sourceMappingURL=join.d.ts.map
\ No newline at end of file diff --git a/chromium/third_party/node/node_modules/lit/directives/keyed.d.ts b/chromium/third_party/node/node_modules/lit/directives/keyed.d.ts new file mode 100644 index 00000000000..e6ae1ada06e --- /dev/null +++ b/chromium/third_party/node/node_modules/lit/directives/keyed.d.ts @@ -0,0 +1,7 @@ +/** + * @license + * Copyright 2021 Google LLC + * SPDX-License-Identifier: BSD-3-Clause + */ +export * from 'lit-html/directives/keyed.js'; +//# sourceMappingURL=keyed.d.ts.map
\ No newline at end of file diff --git a/chromium/third_party/node/node_modules/lit/directives/live.d.ts b/chromium/third_party/node/node_modules/lit/directives/live.d.ts new file mode 100644 index 00000000000..aae6024bed0 --- /dev/null +++ b/chromium/third_party/node/node_modules/lit/directives/live.d.ts @@ -0,0 +1,7 @@ +/** + * @license + * Copyright 2021 Google LLC + * SPDX-License-Identifier: BSD-3-Clause + */ +export * from 'lit-html/directives/live.js'; +//# sourceMappingURL=live.d.ts.map
\ No newline at end of file diff --git a/chromium/third_party/node/node_modules/lit/directives/map.d.ts b/chromium/third_party/node/node_modules/lit/directives/map.d.ts new file mode 100644 index 00000000000..28f094e6259 --- /dev/null +++ b/chromium/third_party/node/node_modules/lit/directives/map.d.ts @@ -0,0 +1,7 @@ +/** + * @license + * Copyright 2021 Google LLC + * SPDX-License-Identifier: BSD-3-Clause + */ +export * from 'lit-html/directives/map.js'; +//# sourceMappingURL=map.d.ts.map
\ No newline at end of file diff --git a/chromium/third_party/node/node_modules/lit/directives/range.d.ts b/chromium/third_party/node/node_modules/lit/directives/range.d.ts new file mode 100644 index 00000000000..1d7a9cacd04 --- /dev/null +++ b/chromium/third_party/node/node_modules/lit/directives/range.d.ts @@ -0,0 +1,7 @@ +/** + * @license + * Copyright 2021 Google LLC + * SPDX-License-Identifier: BSD-3-Clause + */ +export * from 'lit-html/directives/range.js'; +//# sourceMappingURL=range.d.ts.map
\ No newline at end of file diff --git a/chromium/third_party/node/node_modules/lit/directives/ref.d.ts b/chromium/third_party/node/node_modules/lit/directives/ref.d.ts new file mode 100644 index 00000000000..fb2b33eac78 --- /dev/null +++ b/chromium/third_party/node/node_modules/lit/directives/ref.d.ts @@ -0,0 +1,7 @@ +/** + * @license + * Copyright 2021 Google LLC + * SPDX-License-Identifier: BSD-3-Clause + */ +export * from 'lit-html/directives/ref.js'; +//# sourceMappingURL=ref.d.ts.map
\ No newline at end of file diff --git a/chromium/third_party/node/node_modules/lit/directives/repeat.d.ts b/chromium/third_party/node/node_modules/lit/directives/repeat.d.ts new file mode 100644 index 00000000000..8e91a0e8e57 --- /dev/null +++ b/chromium/third_party/node/node_modules/lit/directives/repeat.d.ts @@ -0,0 +1,7 @@ +/** + * @license + * Copyright 2021 Google LLC + * SPDX-License-Identifier: BSD-3-Clause + */ +export * from 'lit-html/directives/repeat.js'; +//# sourceMappingURL=repeat.d.ts.map
\ No newline at end of file diff --git a/chromium/third_party/node/node_modules/lit/directives/style-map.d.ts b/chromium/third_party/node/node_modules/lit/directives/style-map.d.ts new file mode 100644 index 00000000000..da4aa2565f8 --- /dev/null +++ b/chromium/third_party/node/node_modules/lit/directives/style-map.d.ts @@ -0,0 +1,7 @@ +/** + * @license + * Copyright 2021 Google LLC + * SPDX-License-Identifier: BSD-3-Clause + */ +export * from 'lit-html/directives/style-map.js'; +//# sourceMappingURL=style-map.d.ts.map
\ No newline at end of file diff --git a/chromium/third_party/node/node_modules/lit/directives/template-content.d.ts b/chromium/third_party/node/node_modules/lit/directives/template-content.d.ts new file mode 100644 index 00000000000..3e3af1ba112 --- /dev/null +++ b/chromium/third_party/node/node_modules/lit/directives/template-content.d.ts @@ -0,0 +1,7 @@ +/** + * @license + * Copyright 2021 Google LLC + * SPDX-License-Identifier: BSD-3-Clause + */ +export * from 'lit-html/directives/template-content.js'; +//# sourceMappingURL=template-content.d.ts.map
\ No newline at end of file diff --git a/chromium/third_party/node/node_modules/lit/directives/unsafe-html.d.ts b/chromium/third_party/node/node_modules/lit/directives/unsafe-html.d.ts new file mode 100644 index 00000000000..5c51191e8a8 --- /dev/null +++ b/chromium/third_party/node/node_modules/lit/directives/unsafe-html.d.ts @@ -0,0 +1,7 @@ +/** + * @license + * Copyright 2021 Google LLC + * SPDX-License-Identifier: BSD-3-Clause + */ +export * from 'lit-html/directives/unsafe-html.js'; +//# sourceMappingURL=unsafe-html.d.ts.map
\ No newline at end of file diff --git a/chromium/third_party/node/node_modules/lit/directives/unsafe-svg.d.ts b/chromium/third_party/node/node_modules/lit/directives/unsafe-svg.d.ts new file mode 100644 index 00000000000..14af03022c9 --- /dev/null +++ b/chromium/third_party/node/node_modules/lit/directives/unsafe-svg.d.ts @@ -0,0 +1,7 @@ +/** + * @license + * Copyright 2021 Google LLC + * SPDX-License-Identifier: BSD-3-Clause + */ +export * from 'lit-html/directives/unsafe-svg.js'; +//# sourceMappingURL=unsafe-svg.d.ts.map
\ No newline at end of file diff --git a/chromium/third_party/node/node_modules/lit/directives/until.d.ts b/chromium/third_party/node/node_modules/lit/directives/until.d.ts new file mode 100644 index 00000000000..a8856bf58c2 --- /dev/null +++ b/chromium/third_party/node/node_modules/lit/directives/until.d.ts @@ -0,0 +1,7 @@ +/** + * @license + * Copyright 2021 Google LLC + * SPDX-License-Identifier: BSD-3-Clause + */ +export * from 'lit-html/directives/until.js'; +//# sourceMappingURL=until.d.ts.map
\ No newline at end of file diff --git a/chromium/third_party/node/node_modules/lit/directives/when.d.ts b/chromium/third_party/node/node_modules/lit/directives/when.d.ts new file mode 100644 index 00000000000..dbfffda79b5 --- /dev/null +++ b/chromium/third_party/node/node_modules/lit/directives/when.d.ts @@ -0,0 +1,7 @@ +/** + * @license + * Copyright 2021 Google LLC + * SPDX-License-Identifier: BSD-3-Clause + */ +export * from 'lit-html/directives/when.js'; +//# sourceMappingURL=when.d.ts.map
\ No newline at end of file diff --git a/chromium/third_party/node/node_modules/lit/html.d.ts b/chromium/third_party/node/node_modules/lit/html.d.ts new file mode 100644 index 00000000000..b9ba1f88916 --- /dev/null +++ b/chromium/third_party/node/node_modules/lit/html.d.ts @@ -0,0 +1,7 @@ +/** + * @license + * Copyright 2021 Google LLC + * SPDX-License-Identifier: BSD-3-Clause + */ +export * from 'lit-html'; +//# sourceMappingURL=html.d.ts.map
\ No newline at end of file diff --git a/chromium/third_party/node/node_modules/lit/index.d.ts b/chromium/third_party/node/node_modules/lit/index.d.ts new file mode 100644 index 00000000000..c4f94fa5626 --- /dev/null +++ b/chromium/third_party/node/node_modules/lit/index.d.ts @@ -0,0 +1,10 @@ +/** + * @license + * Copyright 2021 Google LLC + * SPDX-License-Identifier: BSD-3-Clause + */ +import '@lit/reactive-element'; +import 'lit-html'; +export * from 'lit-element/lit-element.js'; +export * from 'lit-html/is-server.js'; +//# sourceMappingURL=index.d.ts.map
\ No newline at end of file diff --git a/chromium/third_party/node/node_modules/lit/index.js b/chromium/third_party/node/node_modules/lit/index.js new file mode 100644 index 00000000000..599d7d05d61 --- /dev/null +++ b/chromium/third_party/node/node_modules/lit/index.js @@ -0,0 +1,2 @@ +import"@lit/reactive-element";import"lit-html";export*from"lit-element/lit-element.js";export*from"lit-html/is-server.js"; +//# sourceMappingURL=index.js.map diff --git a/chromium/third_party/node/node_modules/lit/static-html.d.ts b/chromium/third_party/node/node_modules/lit/static-html.d.ts new file mode 100644 index 00000000000..210c5b0487b --- /dev/null +++ b/chromium/third_party/node/node_modules/lit/static-html.d.ts @@ -0,0 +1,7 @@ +/** + * @license + * Copyright 2021 Google LLC + * SPDX-License-Identifier: BSD-3-Clause + */ +export * from 'lit-html/static.js'; +//# sourceMappingURL=static-html.d.ts.map
\ No newline at end of file |