@rxdi/lit-html 0.7.157 → 0.7.158

package/dist/lit-html/directives/async-append.d.ts

@@ -1,38 +0,0 @@
-/**
- * @license
- * Copyright 2017 Google LLC
- * SPDX-License-Identifier: BSD-3-Clause
- */
-import { ChildPart } from '../lit-html';
-import { DirectiveParameters, PartInfo } from '../directive';
-import { AsyncReplaceDirective } from './async-replace';
-declare class AsyncAppendDirective extends AsyncReplaceDirective {
-    private __childPart;
-    constructor(partInfo: PartInfo);
-    update(part: ChildPart, params: DirectiveParameters<this>): symbol;
-    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) => unknown) => import("../directive").DirectiveResult<typeof AsyncAppendDirective>;
-/**
- * The type of the class that powers this directive. Necessary for naming the
- * directive's return type.
- */
-export type { AsyncAppendDirective };

package/dist/lit-html/directives/async-append.js

@@ -1,55 +0,0 @@
-"use strict";
-/**
- * @license
- * Copyright 2017 Google LLC
- * SPDX-License-Identifier: BSD-3-Clause
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.asyncAppend = void 0;
-const directive_1 = require("../directive");
-const async_replace_1 = require("./async-replace");
-const directive_helpers_1 = require("../directive-helpers");
-class AsyncAppendDirective extends async_replace_1.AsyncReplaceDirective {
-    // Override AsyncReplace to narrow the allowed part type to ChildPart only
-    constructor(partInfo) {
-        super(partInfo);
-        if (partInfo.type !== directive_1.PartType.CHILD) {
-            throw new Error('asyncAppend can only be used in child expressions');
-        }
-    }
-    // Override AsyncReplace to save the part since we need to append into it
-    update(part, params) {
-        this.__childPart = part;
-        return super.update(part, params);
-    }
-    // Override AsyncReplace to append rather than replace
-    commitValue(value, index) {
-        // When we get the first value, clear the part. This lets the
-        // previous value display until we can replace it.
-        if (index === 0) {
-            (0, directive_helpers_1.clearPart)(this.__childPart);
-        }
-        // Create and insert a new part and set its value to the next value
-        const newPart = (0, directive_helpers_1.insertPart)(this.__childPart);
-        (0, directive_helpers_1.setChildPartValue)(newPart, value);
-    }
-}
-/**
- * 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.
- */
-exports.asyncAppend = (0, directive_1.directive)(AsyncAppendDirective);

package/dist/lit-html/directives/async-replace.d.ts

@@ -1,39 +0,0 @@
-/**
- * @license
- * Copyright 2017 Google LLC
- * SPDX-License-Identifier: BSD-3-Clause
- */
-import { ChildPart } from '../lit-html';
-import { DirectiveParameters } from '../directive';
-import { AsyncDirective } from '../async-directive';
-declare 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>): symbol;
-    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>) => import("../directive").DirectiveResult<typeof AsyncReplaceDirective>;
-export {};

package/dist/lit-html/directives/async-replace.js

@@ -1,112 +0,0 @@
-"use strict";
-/**
- * @license
- * Copyright 2017 Google LLC
- * SPDX-License-Identifier: BSD-3-Clause
- */
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.asyncReplace = exports.AsyncReplaceDirective = void 0;
-const lit_html_1 = require("../lit-html");
-const directive_1 = require("../directive");
-const async_directive_1 = require("../async-directive");
-const private_async_helpers_1 = require("./private-async-helpers");
-class AsyncReplaceDirective extends async_directive_1.AsyncDirective {
-    constructor() {
-        super(...arguments);
-        this.__weakThis = new private_async_helpers_1.PseudoWeakRef(this);
-        this.__pauser = new private_async_helpers_1.Pauser();
-    }
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    render(value, _mapper) {
-        return lit_html_1.noChange;
-    }
-    update(_part, [value, mapper]) {
-        // If our initial render occurs while disconnected, ensure that the pauser
-        // and weakThis are in the disconnected state
-        if (!this.isConnected) {
-            this.disconnected();
-        }
-        // If we've already set up this particular iterable, we don't need
-        // to do anything.
-        if (value === this.__value) {
-            return;
-        }
-        this.__value = value;
-        let i = 0;
-        const { __weakThis: weakThis, __pauser: pauser } = this;
-        // Note, the callback avoids closing over `this` so that the directive
-        // can be gc'ed before the promise resolves; instead `this` is retrieved
-        // from `weakThis`, which can break the hard reference in the closure when
-        // the directive disconnects
-        (0, private_async_helpers_1.forAwaitOf)(value, (v) => __awaiter(this, void 0, void 0, function* () {
-            // The while loop here handles the case that the connection state
-            // thrashes, causing the pauser to resume and then get re-paused
-            while (pauser.get()) {
-                yield pauser.get();
-            }
-            // If the callback gets here and there is no `this`, it means that the
-            // directive has been disconnected and garbage collected and we don't
-            // need to do anything else
-            const _this = weakThis.deref();
-            if (_this !== undefined) {
-                // Check to make sure that value is the still the current value of
-                // the part, and if not bail because a new value owns this part
-                if (_this.__value !== value) {
-                    return false;
-                }
-                // As a convenience, because functional-programming-style
-                // transforms of iterables and async iterables requires a library,
-                // we accept a mapper function. This is especially convenient for
-                // rendering a template for each item.
-                if (mapper !== undefined) {
-                    v = mapper(v, i);
-                }
-                _this.commitValue(v, i);
-                i++;
-            }
-            return true;
-        }));
-        return lit_html_1.noChange;
-    }
-    // Override point for AsyncAppend to append rather than replace
-    commitValue(value, _index) {
-        this.setValue(value);
-    }
-    disconnected() {
-        this.__weakThis.disconnect();
-        this.__pauser.pause();
-    }
-    reconnected() {
-        this.__weakThis.reconnect(this);
-        this.__pauser.resume();
-    }
-}
-exports.AsyncReplaceDirective = AsyncReplaceDirective;
-/**
- * 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.
- */
-exports.asyncReplace = (0, directive_1.directive)(AsyncReplaceDirective);

package/dist/lit-html/directives/cache.d.ts

@@ -1,34 +0,0 @@
-/**
- * @license
- * Copyright 2017 Google LLC
- * SPDX-License-Identifier: BSD-3-Clause
- */
-import { ChildPart } from '../lit-html';
-import { Directive, DirectiveParameters, PartInfo } from '../directive';
-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").DirectiveResult<typeof CacheDirective>;
-/**
- * The type of the class that powers this directive. Necessary for naming the
- * directive's return type.
- */
-export type { CacheDirective };

package/dist/lit-html/directives/cache.js

@@ -1,80 +0,0 @@
-"use strict";
-/**
- * @license
- * Copyright 2017 Google LLC
- * SPDX-License-Identifier: BSD-3-Clause
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.cache = void 0;
-const lit_html_1 = require("../lit-html");
-const directive_1 = require("../directive");
-const directive_helpers_1 = require("../directive-helpers");
-class CacheDirective extends directive_1.Directive {
-    constructor(partInfo) {
-        super(partInfo);
-        this._templateCache = new WeakMap();
-    }
-    render(v) {
-        // Return an array of the value to induce lit-html to create a ChildPart
-        // for the value that we can move into the cache.
-        return [v];
-    }
-    update(containerPart, [v]) {
-        // If the previous value is a TemplateResult and the new value is not,
-        // or is a different Template as the previous value, move the child part
-        // into the cache.
-        if ((0, directive_helpers_1.isTemplateResult)(this._value) &&
-            (!(0, directive_helpers_1.isTemplateResult)(v) || this._value.strings !== v.strings)) {
-            // This is always an array because we return [v] in render()
-            const partValue = (0, directive_helpers_1.getCommittedValue)(containerPart);
-            const childPart = partValue.pop();
-            let cachedContainerPart = this._templateCache.get(this._value.strings);
-            if (cachedContainerPart === undefined) {
-                const fragment = document.createDocumentFragment();
-                cachedContainerPart = (0, lit_html_1.render)(lit_html_1.nothing, fragment);
-                cachedContainerPart.setConnected(false);
-                this._templateCache.set(this._value.strings, cachedContainerPart);
-            }
-            // Move into cache
-            (0, directive_helpers_1.setCommittedValue)(cachedContainerPart, [childPart]);
-            (0, directive_helpers_1.insertPart)(cachedContainerPart, undefined, childPart);
-        }
-        // If the new value is a TemplateResult and the previous value is not,
-        // or is a different Template as the previous value, restore the child
-        // part from the cache.
-        if ((0, directive_helpers_1.isTemplateResult)(v)) {
-            if (!(0, directive_helpers_1.isTemplateResult)(this._value) || this._value.strings !== v.strings) {
-                const cachedContainerPart = this._templateCache.get(v.strings);
-                if (cachedContainerPart !== undefined) {
-                    // Move the cached part back into the container part value
-                    const partValue = (0, directive_helpers_1.getCommittedValue)(cachedContainerPart);
-                    const cachedPart = partValue.pop();
-                    // Move cached part back into DOM
-                    (0, directive_helpers_1.clearPart)(containerPart);
-                    (0, directive_helpers_1.insertPart)(containerPart, undefined, cachedPart);
-                    (0, directive_helpers_1.setCommittedValue)(containerPart, [cachedPart]);
-                }
-            }
-            this._value = v;
-        }
-        else {
-            this._value = undefined;
-        }
-        return this.render(v);
-    }
-}
-/**
- * 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`)}
- * `
- * ```
- */
-exports.cache = (0, directive_1.directive)(CacheDirective);

package/dist/lit-html/directives/class-map.d.ts

@@ -1,44 +0,0 @@
-/**
- * @license
- * Copyright 2018 Google LLC
- * SPDX-License-Identifier: BSD-3-Clause
- */
-import { AttributePart, noChange } from '../lit-html';
-import { Directive, DirectiveParameters, PartInfo } from '../directive';
-/**
- * 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").DirectiveResult<typeof ClassMapDirective>;
-/**
- * The type of the class that powers this directive. Necessary for naming the
- * directive's return type.
- */
-export type { ClassMapDirective };

package/dist/lit-html/directives/class-map.js

@@ -1,92 +0,0 @@
-"use strict";
-/**
- * @license
- * Copyright 2018 Google LLC
- * SPDX-License-Identifier: BSD-3-Clause
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.classMap = void 0;
-const lit_html_1 = require("../lit-html");
-const directive_1 = require("../directive");
-class ClassMapDirective extends directive_1.Directive {
-    constructor(partInfo) {
-        var _a;
-        super(partInfo);
-        if (partInfo.type !== directive_1.PartType.ATTRIBUTE ||
-            partInfo.name !== 'class' ||
-            ((_a = partInfo.strings) === null || _a === void 0 ? void 0 : _a.length) > 2) {
-            throw new Error('`classMap()` can only be used in the `class` attribute ' +
-                'and must be the only part in the attribute.');
-        }
-    }
-    render(classInfo) {
-        // Add spaces to ensure separation from static classes
-        return (' ' +
-            Object.keys(classInfo)
-                .filter((key) => classInfo[key])
-                .join(' ') +
-            ' ');
-    }
-    update(part, [classInfo]) {
-        var _a, _b;
-        // Remember dynamic classes on the first render
-        if (this._previousClasses === undefined) {
-            this._previousClasses = new Set();
-            if (part.strings !== undefined) {
-                this._staticClasses = new Set(part.strings
-                    .join(' ')
-                    .split(/\s/)
-                    .filter((s) => s !== ''));
-            }
-            for (const name in classInfo) {
-                if (classInfo[name] && !((_a = this._staticClasses) === null || _a === void 0 ? void 0 : _a.has(name))) {
-                    this._previousClasses.add(name);
-                }
-            }
-            return this.render(classInfo);
-        }
-        const classList = part.element.classList;
-        // Remove old classes that no longer apply
-        // We use forEach() instead of for-of so that we don't require down-level
-        // iteration.
-        this._previousClasses.forEach((name) => {
-            if (!(name in classInfo)) {
-                classList.remove(name);
-                this._previousClasses.delete(name);
-            }
-        });
-        // Add or remove classes based on their classMap value
-        for (const name in classInfo) {
-            // We explicitly want a loose truthy check of `value` because it seems
-            // more convenient that '' and 0 are skipped.
-            const value = !!classInfo[name];
-            if (value !== this._previousClasses.has(name) &&
-                !((_b = this._staticClasses) === null || _b === void 0 ? void 0 : _b.has(name))) {
-                if (value) {
-                    classList.add(name);
-                    this._previousClasses.add(name);
-                }
-                else {
-                    classList.remove(name);
-                    this._previousClasses.delete(name);
-                }
-            }
-        }
-        return lit_html_1.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
- */
-exports.classMap = (0, directive_1.directive)(ClassMapDirective);

package/dist/lit-html/directives/guard.d.ts

@@ -1,59 +0,0 @@
-/**
- * @license
- * Copyright 2018 Google LLC
- * SPDX-License-Identifier: BSD-3-Clause
- */
-import { Part } from '../lit-html';
-import { Directive, DirectiveParameters } from '../directive';
-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").DirectiveResult<typeof GuardDirective>;
-/**
- * The type of the class that powers this directive. Necessary for naming the
- * directive's return type.
- */
-export type { GuardDirective };

package/dist/lit-html/directives/guard.js

@@ -1,82 +0,0 @@
-"use strict";
-/**
- * @license
- * Copyright 2018 Google LLC
- * SPDX-License-Identifier: BSD-3-Clause
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.guard = void 0;
-const lit_html_1 = require("../lit-html");
-const directive_1 = require("../directive");
-// A sentinal that indicates guard() hasn't rendered anything yet
-const initialValue = {};
-class GuardDirective extends directive_1.Directive {
-    constructor() {
-        super(...arguments);
-        this._previousValue = initialValue;
-    }
-    render(_value, f) {
-        return f();
-    }
-    update(_part, [value, f]) {
-        if (Array.isArray(value)) {
-            // Dirty-check arrays by item
-            if (Array.isArray(this._previousValue) &&
-                this._previousValue.length === value.length &&
-                value.every((v, i) => v === this._previousValue[i])) {
-                return lit_html_1.noChange;
-            }
-        }
-        else if (this._previousValue === value) {
-            // Dirty-check non-arrays by identity
-            return lit_html_1.noChange;
-        }
-        // Copy the value if it's an array so that if it's mutated we don't forget
-        // what the previous values were.
-        this._previousValue = Array.isArray(value) ? Array.from(value) : value;
-        const r = this.render(value, f);
-        return r;
-    }
-}
-/**
- * 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
- */
-exports.guard = (0, directive_1.directive)(GuardDirective);

package/dist/lit-html/directives/if-defined.d.ts

@@ -1,13 +0,0 @@
-/**
- * @license
- * Copyright 2018 Google LLC
- * SPDX-License-Identifier: BSD-3-Clause
- */
-import { nothing } from '../lit-html';
-/**
- * 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 | T;

package/dist/lit-html/directives/if-defined.js

@@ -1,17 +0,0 @@
-"use strict";
-/**
- * @license
- * Copyright 2018 Google LLC
- * SPDX-License-Identifier: BSD-3-Clause
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ifDefined = void 0;
-const lit_html_1 = require("../lit-html");
-/**
- * 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.
- */
-const ifDefined = (value) => value !== null && value !== void 0 ? value : lit_html_1.nothing;
-exports.ifDefined = ifDefined;