@rxdi/lit-html 0.7.157 → 0.7.158

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

@@ -1,64 +0,0 @@
-"use strict";
-/**
- * @license
- * Copyright 2017 Google LLC
- * SPDX-License-Identifier: BSD-3-Clause
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.unsafeHTML = exports.UnsafeHTMLDirective = void 0;
-const lit_html_1 = require("../lit-html");
-const directive_1 = require("../directive");
-const HTML_RESULT = 1;
-class UnsafeHTMLDirective extends directive_1.Directive {
-    constructor(partInfo) {
-        super(partInfo);
-        this._value = lit_html_1.nothing;
-        if (partInfo.type !== directive_1.PartType.CHILD) {
-            throw new Error(`${this.constructor.directiveName}() can only be used in child bindings`);
-        }
-    }
-    render(value) {
-        if (value === lit_html_1.nothing || value == null) {
-            this._templateResult = undefined;
-            return (this._value = value);
-        }
-        if (value === lit_html_1.noChange) {
-            return value;
-        }
-        if (typeof value != 'string') {
-            throw new Error(`${this.constructor.directiveName}() called with a non-string value`);
-        }
-        if (value === this._value) {
-            return this._templateResult;
-        }
-        this._value = value;
-        const strings = [value];
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        strings.raw = strings;
-        // WARNING: impersonating a TemplateResult like this is extremely
-        // dangerous. Third-party directives should not do this.
-        return (this._templateResult = {
-            // Cast to a known set of integers that satisfy ResultType so that we
-            // don't have to export ResultType and possibly encourage this pattern.
-            // This property needs to remain unminified.
-            ['_$litType$']: this.constructor
-                .resultType,
-            strings,
-            values: [],
-        });
-    }
-}
-exports.UnsafeHTMLDirective = UnsafeHTMLDirective;
-UnsafeHTMLDirective.directiveName = 'unsafeHTML';
-UnsafeHTMLDirective.resultType = HTML_RESULT;
-/**
- * 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.
- */
-exports.unsafeHTML = (0, directive_1.directive)(UnsafeHTMLDirective);

package/dist/lit-html/directives/unsafe-svg.d.ts

@@ -1,26 +0,0 @@
-/**
- * @license
- * Copyright 2017 Google LLC
- * SPDX-License-Identifier: BSD-3-Clause
- */
-import { UnsafeHTMLDirective } from './unsafe-html';
-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").noChange | typeof import("../lit-html").nothing) => import("../directive").DirectiveResult<typeof UnsafeSVGDirective>;
-/**
- * The type of the class that powers this directive. Necessary for naming the
- * directive's return type.
- */
-export type { UnsafeSVGDirective };

package/dist/lit-html/directives/unsafe-svg.js

@@ -1,26 +0,0 @@
-"use strict";
-/**
- * @license
- * Copyright 2017 Google LLC
- * SPDX-License-Identifier: BSD-3-Clause
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.unsafeSVG = void 0;
-const directive_1 = require("../directive");
-const unsafe_html_1 = require("./unsafe-html");
-const SVG_RESULT = 2;
-class UnsafeSVGDirective extends unsafe_html_1.UnsafeHTMLDirective {
-}
-UnsafeSVGDirective.directiveName = 'unsafeSVG';
-UnsafeSVGDirective.resultType = SVG_RESULT;
-/**
- * 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.
- */
-exports.unsafeSVG = (0, directive_1.directive)(UnsafeSVGDirective);

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

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

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

@@ -1,137 +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.until = exports.UntilDirective = void 0;
-const lit_html_1 = require("../lit-html");
-const directive_1 = require("../directive");
-const directive_helpers_1 = require("../directive-helpers");
-const async_directive_1 = require("../async-directive");
-const private_async_helpers_1 = require("./private-async-helpers");
-const isPromise = (x) => {
-    return !(0, directive_helpers_1.isPrimitive)(x) && typeof x.then === 'function';
-};
-// Effectively infinity, but a SMI.
-const _infinity = 0x3fffffff;
-class UntilDirective extends async_directive_1.AsyncDirective {
-    constructor() {
-        super(...arguments);
-        this.__lastRenderedIndex = _infinity;
-        this.__values = [];
-        this.__weakThis = new private_async_helpers_1.PseudoWeakRef(this);
-        this.__pauser = new private_async_helpers_1.Pauser();
-    }
-    render(...args) {
-        var _a;
-        return (_a = args.find((x) => !isPromise(x))) !== null && _a !== void 0 ? _a : lit_html_1.noChange;
-    }
-    update(_part, args) {
-        const previousValues = this.__values;
-        let previousLength = previousValues.length;
-        this.__values = args;
-        const weakThis = this.__weakThis;
-        const pauser = this.__pauser;
-        // If our initial render occurs while disconnected, ensure that the pauser
-        // and weakThis are in the disconnected state
-        if (!this.isConnected) {
-            this.disconnected();
-        }
-        for (let i = 0; i < args.length; i++) {
-            // If we've rendered a higher-priority value already, stop.
-            if (i > this.__lastRenderedIndex) {
-                break;
-            }
-            const value = args[i];
-            // Render non-Promise values immediately
-            if (!isPromise(value)) {
-                this.__lastRenderedIndex = i;
-                // Since a lower-priority value will never overwrite a higher-priority
-                // synchronous value, we can stop processing now.
-                return value;
-            }
-            // If this is a Promise we've already handled, skip it.
-            if (i < previousLength && value === previousValues[i]) {
-                continue;
-            }
-            // We have a Promise that we haven't seen before, so priorities may have
-            // changed. Forget what we rendered before.
-            this.__lastRenderedIndex = _infinity;
-            previousLength = 0;
-            // 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
-            Promise.resolve(value).then((result) => __awaiter(this, void 0, void 0, function* () {
-                // If we're disconnected, wait until we're (maybe) reconnected
-                // 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) {
-                    const index = _this.__values.indexOf(value);
-                    // If state.values doesn't contain the value, we've re-rendered without
-                    // the value, so don't render it. Then, only render if the value is
-                    // higher-priority than what's already been rendered.
-                    if (index > -1 && index < _this.__lastRenderedIndex) {
-                        _this.__lastRenderedIndex = index;
-                        _this.setValue(result);
-                    }
-                }
-            }));
-        }
-        return lit_html_1.noChange;
-    }
-    disconnected() {
-        this.__weakThis.disconnect();
-        this.__pauser.pause();
-    }
-    reconnected() {
-        this.__weakThis.reconnect(this);
-        this.__pauser.resume();
-    }
-}
-exports.UntilDirective = UntilDirective;
-/**
- * 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>`)}`
- * ```
- */
-exports.until = (0, directive_1.directive)(UntilDirective);
-/**
- * The type of the class that powers this directive. Necessary for naming the
- * directive's return type.
- */
-// export type {UntilDirective};

package/dist/lit-html/experimental-hydrate.d.ts

@@ -1,50 +0,0 @@
-/**
- * @license
- * Copyright 2019 Google LLC
- * SPDX-License-Identifier: BSD-3-Clause
- */
-import type { TemplateResult } from './lit-html';
-import { RenderOptions } from './lit-html';
-/**
- * hydrate() operates on a container with server-side rendered content and
- * restores the client side data structures needed for lit-html updates such as
- * TemplateInstances and Parts. After calling `hydrate`, lit-html will behave as
- * if it initially rendered the DOM, and any subsequent updates will update
- * efficiently, the same as if lit-html had rendered the DOM on the client.
- *
- * hydrate() must be called on DOM that adheres the to lit-ssr structure for
- * parts. ChildParts must be represented with both a start and end comment
- * marker, and ChildParts that contain a TemplateInstance must have the template
- * digest written into the comment data.
- *
- * Since render() encloses its output in a ChildPart, there must always be a root
- * ChildPart.
- *
- * Example (using for # ... for annotations in HTML)
- *
- * Given this input:
- *
- *   html`<div class=${x}>${y}</div>`
- *
- * The SSR DOM is:
- *
- *   <!--lit-part AEmR7W+R0Ak=-->  # Start marker for the root ChildPart created
- *                                 # by render(). Includes the digest of the
- *                                 # template
- *   <div class="TEST_X">
- *     <!--lit-node 0--> # Indicates there are attribute bindings here
- *                           # The number is the depth-first index of the parent
- *                           # node in the template.
- *     <!--lit-part-->  # Start marker for the ${x} expression
- *     TEST_Y
- *     <!--/lit-part-->  # End marker for the ${x} expression
- *   </div>
- *
- *   <!--/lit-part-->  # End marker for the root ChildPart
- *
- * @param rootValue
- * @param container
- * @param userOptions
- */
-export declare const hydrate: (rootValue: unknown, container: Element | DocumentFragment, options?: Partial<RenderOptions>) => void;
-export declare const digestForTemplateResult: (templateResult: TemplateResult) => string;

package/dist/lit-html/experimental-hydrate.js

@@ -1,322 +0,0 @@
-"use strict";
-/**
- * @license
- * Copyright 2019 Google LLC
- * SPDX-License-Identifier: BSD-3-Clause
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.digestForTemplateResult = exports.hydrate = void 0;
-const lit_html_1 = require("./lit-html");
-const directive_1 = require("./directive");
-const directive_helpers_1 = require("./directive-helpers");
-const { _TemplateInstance: TemplateInstance, _isIterable: isIterable, _resolveDirective: resolveDirective, _ChildPart: ChildPart, _ElementPart: ElementPart, } = lit_html_1._$LH;
-/**
- * hydrate() operates on a container with server-side rendered content and
- * restores the client side data structures needed for lit-html updates such as
- * TemplateInstances and Parts. After calling `hydrate`, lit-html will behave as
- * if it initially rendered the DOM, and any subsequent updates will update
- * efficiently, the same as if lit-html had rendered the DOM on the client.
- *
- * hydrate() must be called on DOM that adheres the to lit-ssr structure for
- * parts. ChildParts must be represented with both a start and end comment
- * marker, and ChildParts that contain a TemplateInstance must have the template
- * digest written into the comment data.
- *
- * Since render() encloses its output in a ChildPart, there must always be a root
- * ChildPart.
- *
- * Example (using for # ... for annotations in HTML)
- *
- * Given this input:
- *
- *   html`<div class=${x}>${y}</div>`
- *
- * The SSR DOM is:
- *
- *   <!--lit-part AEmR7W+R0Ak=-->  # Start marker for the root ChildPart created
- *                                 # by render(). Includes the digest of the
- *                                 # template
- *   <div class="TEST_X">
- *     <!--lit-node 0--> # Indicates there are attribute bindings here
- *                           # The number is the depth-first index of the parent
- *                           # node in the template.
- *     <!--lit-part-->  # Start marker for the ${x} expression
- *     TEST_Y
- *     <!--/lit-part-->  # End marker for the ${x} expression
- *   </div>
- *
- *   <!--/lit-part-->  # End marker for the root ChildPart
- *
- * @param rootValue
- * @param container
- * @param userOptions
- */
-const hydrate = (rootValue, container, options = {}) => {
-    // TODO(kschaaf): Do we need a helper for _$litPart$ ("part for node")?
-    // This property needs to remain unminified.
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    if (container['_$litPart$'] !== undefined) {
-        throw new Error('container already contains a live render');
-    }
-    // Since render() creates a ChildPart to render into, we'll always have
-    // exactly one root part. We need to hold a reference to it so we can set
-    // it in the parts cache.
-    let rootPart = undefined;
-    // When we are in-between ChildPart markers, this is the current ChildPart.
-    // It's needed to be able to set the ChildPart's endNode when we see a
-    // close marker
-    let currentChildPart = undefined;
-    // Used to remember parent template state as we recurse into nested
-    // templates
-    const stack = [];
-    const walker = document.createTreeWalker(container, NodeFilter.SHOW_COMMENT, null, false);
-    let marker;
-    // Walk the DOM looking for part marker comments
-    while ((marker = walker.nextNode()) !== null) {
-        const markerText = marker.data;
-        if (markerText.startsWith('lit-part')) {
-            if (stack.length === 0 && rootPart !== undefined) {
-                throw new Error('there must be only one root part per container');
-            }
-            // Create a new ChildPart and push it onto the stack
-            currentChildPart = openChildPart(rootValue, marker, stack, options);
-            rootPart !== null && rootPart !== void 0 ? rootPart : (rootPart = currentChildPart);
-        }
-        else if (markerText.startsWith('lit-node')) {
-            // Create and hydrate attribute parts into the current ChildPart on the
-            // stack
-            createAttributeParts(marker, stack, options);
-            // Remove `defer-hydration` attribute, if any
-            const parent = marker.parentElement;
-            if (parent.hasAttribute('defer-hydration')) {
-                parent.removeAttribute('defer-hydration');
-            }
-        }
-        else if (markerText.startsWith('/lit-part')) {
-            // Close the current ChildPart, and pop the previous one off the stack
-            if (stack.length === 1 && currentChildPart !== rootPart) {
-                throw new Error('internal error');
-            }
-            currentChildPart = closeChildPart(marker, currentChildPart, stack);
-        }
-    }
-    console.assert(rootPart !== undefined, 'there should be exactly one root part in a render container');
-    // This property needs to remain unminified.
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    container['_$litPart$'] = rootPart;
-};
-exports.hydrate = hydrate;
-const openChildPart = (rootValue, marker, stack, options) => {
-    let value;
-    // We know the startNode now. We'll know the endNode when we get to
-    // the matching marker and set it in closeChildPart()
-    // TODO(kschaaf): Current constructor takes both nodes
-    let part;
-    if (stack.length === 0) {
-        part = new ChildPart(marker, null, undefined, options);
-        value = rootValue;
-    }
-    else {
-        const state = stack[stack.length - 1];
-        if (state.type === 'template-instance') {
-            part = new ChildPart(marker, null, state.instance, options);
-            state.instance._parts.push(part);
-            value = state.result.values[state.instancePartIndex++];
-            state.templatePartIndex++;
-        }
-        else if (state.type === 'iterable') {
-            part = new ChildPart(marker, null, state.part, options);
-            const result = state.iterator.next();
-            if (result.done) {
-                value = undefined;
-                state.done = true;
-                throw new Error('Unhandled shorter than expected iterable');
-            }
-            else {
-                value = result.value;
-            }
-            state.part._$committedValue.push(part);
-        }
-        else {
-            // state.type === 'leaf'
-            // TODO(kschaaf): This is unexpected, and likely a result of a primitive
-            // been rendered on the client when a TemplateResult was rendered on the
-            // server; this part will be hydrated but not used. We can detect it, but
-            // we need to decide what to do in this case. Note that this part won't be
-            // retained by any parent TemplateInstance, since a primitive had been
-            // rendered in its place.
-            // https://github.com/lit/lit/issues/1434
-            // throw new Error('Hydration value mismatch: Found a TemplateInstance' +
-            //  'where a leaf value was expected');
-            part = new ChildPart(marker, null, state.part, options);
-        }
-    }
-    // Initialize the ChildPart state depending on the type of value and push
-    // it onto the stack. This logic closely follows the ChildPart commit()
-    // cascade order:
-    // 1. directive
-    // 2. noChange
-    // 3. primitive (note strings must be handled before iterables, since they
-    //    are iterable)
-    // 4. TemplateResult
-    // 5. Node (not yet implemented, but fallback handling is fine)
-    // 6. Iterable
-    // 7. nothing (handled in fallback)
-    // 8. Fallback for everything else
-    value = resolveDirective(part, value);
-    if (value === lit_html_1.noChange) {
-        stack.push({ part, type: 'leaf' });
-    }
-    else if ((0, directive_helpers_1.isPrimitive)(value)) {
-        stack.push({ part, type: 'leaf' });
-        part._$committedValue = value;
-        // TODO(kschaaf): We can detect when a primitive is being hydrated on the
-        // client where a TemplateResult was rendered on the server, but we need to
-        // decide on a strategy for what to do next.
-        // https://github.com/lit/lit/issues/1434
-        // if (marker.data !== 'lit-part') {
-        //   throw new Error('Hydration value mismatch: Primitive found where TemplateResult expected');
-        // }
-    }
-    else if ((0, directive_helpers_1.isTemplateResult)(value)) {
-        // Check for a template result digest
-        const markerWithDigest = `lit-part ${(0, exports.digestForTemplateResult)(value)}`;
-        if (marker.data === markerWithDigest) {
-            const template = ChildPart.prototype._$getTemplate(value);
-            const instance = new TemplateInstance(template, part);
-            stack.push({
-                type: 'template-instance',
-                instance,
-                part,
-                templatePartIndex: 0,
-                instancePartIndex: 0,
-                result: value,
-            });
-            // For TemplateResult values, we set the part value to the
-            // generated TemplateInstance
-            part._$committedValue = instance;
-        }
-        else {
-            // TODO: if this isn't the server-rendered template, do we
-            // need to stop hydrating this subtree? Clear it? Add tests.
-            throw new Error('Hydration value mismatch: Unexpected TemplateResult rendered to part');
-        }
-    }
-    else if (isIterable(value)) {
-        // currentChildPart.value will contain an array of ChildParts
-        stack.push({
-            part: part,
-            type: 'iterable',
-            value,
-            iterator: value[Symbol.iterator](),
-            done: false,
-        });
-        part._$committedValue = [];
-    }
-    else {
-        // Fallback for everything else (nothing, Objects, Functions,
-        // etc.): we just initialize the part's value
-        // Note that `Node` value types are not currently supported during
-        // SSR, so that part of the cascade is missing.
-        stack.push({ part: part, type: 'leaf' });
-        part._$committedValue = value == null ? '' : value;
-    }
-    return part;
-};
-const closeChildPart = (marker, part, stack) => {
-    if (part === undefined) {
-        throw new Error('unbalanced part marker');
-    }
-    part._$endNode = marker;
-    const currentState = stack.pop();
-    if (currentState.type === 'iterable') {
-        if (!currentState.iterator.next().done) {
-            throw new Error('unexpected longer than expected iterable');
-        }
-    }
-    if (stack.length > 0) {
-        const state = stack[stack.length - 1];
-        return state.part;
-    }
-    else {
-        return undefined;
-    }
-};
-const createAttributeParts = (comment, stack, options) => {
-    var _a;
-    // Get the nodeIndex from DOM. We're only using this for an integrity
-    // check right now, we might not need it.
-    const match = /lit-node (\d+)/.exec(comment.data);
-    const nodeIndex = parseInt(match[1]);
-    // For void elements, the node the comment was referring to will be
-    // the previousSibling; for non-void elements, the comment is guaranteed
-    // to be the first child of the element (i.e. it won't have a previousSibling
-    // meaning it should use the parentElement)
-    const node = (_a = comment.previousSibling) !== null && _a !== void 0 ? _a : comment.parentElement;
-    const state = stack[stack.length - 1];
-    if (state.type === 'template-instance') {
-        const instance = state.instance;
-        // eslint-disable-next-line no-constant-condition
-        while (true) {
-            // If the next template part is in attribute-position on the current node,
-            // create the instance part for it and prime its state
-            const templatePart = instance._$template.parts[state.templatePartIndex];
-            if (templatePart === undefined ||
-                (templatePart.type !== directive_1.PartType.ATTRIBUTE &&
-                    templatePart.type !== directive_1.PartType.ELEMENT) ||
-                templatePart.index !== nodeIndex) {
-                break;
-            }
-            if (templatePart.type === directive_1.PartType.ATTRIBUTE) {
-                // The instance part is created based on the constructor saved in the
-                // template part
-                const instancePart = new templatePart.ctor(node, templatePart.name, templatePart.strings, state.instance, options);
-                const value = (0, directive_helpers_1.isSingleExpression)(instancePart)
-                    ? state.result.values[state.instancePartIndex]
-                    : state.result.values;
-                // Setting the attribute value primes committed value with the resolved
-                // directive value; we only then commit that value for event/property
-                // parts since those were not serialized, and pass `noCommit` for the
-                // others to avoid perf impact of touching the DOM unnecessarily
-                const noCommit = !(instancePart.type === directive_1.PartType.EVENT ||
-                    instancePart.type === directive_1.PartType.PROPERTY);
-                instancePart._$setValue(value, instancePart, state.instancePartIndex, noCommit);
-                state.instancePartIndex += templatePart.strings.length - 1;
-                instance._parts.push(instancePart);
-            }
-            else {
-                // templatePart.type === PartType.ELEMENT
-                const instancePart = new ElementPart(node, state.instance, options);
-                resolveDirective(instancePart, state.result.values[state.instancePartIndex++]);
-                instance._parts.push(instancePart);
-            }
-            state.templatePartIndex++;
-        }
-    }
-    else {
-        throw new Error('internal error');
-    }
-};
-// Number of 32 bit elements to use to create template digests
-const digestSize = 2;
-// We need to specify a digest to use across rendering environments. This is a
-// simple digest build from a DJB2-ish hash modified from:
-// https://github.com/darkskyapp/string-hash/blob/master/index
-// It has been changed to an array of hashes to add additional bits.
-// Goals:
-//  - Extremely low collision rate. We may not be able to detect collisions.
-//  - Extremely fast.
-//  - Extremely small code size.
-//  - Safe to include in HTML comment text or attribute value.
-//  - Easily specifiable and implementable in multiple languages.
-// We don't care about cryptographic suitability.
-const digestForTemplateResult = (templateResult) => {
-    const hashes = new Uint32Array(digestSize).fill(5381);
-    for (const s of templateResult.strings) {
-        for (let i = 0; i < s.length; i++) {
-            hashes[i % digestSize] = (hashes[i % digestSize] * 33) ^ s.charCodeAt(i);
-        }
-    }
-    return btoa(String.fromCharCode(...new Uint8Array(hashes.buffer)));
-};
-exports.digestForTemplateResult = digestForTemplateResult;