chrome-devtools-frontend 1.0.943709 → 1.0.945329

package/front_end/third_party/lit-html/package/development/async-directive.js

@@ -3,124 +3,9 @@
  * 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
- * disconnect (or reconnect) a tree, the `_$setChildPartConnected` 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 `_$setDirectiveConnected` 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
- * `_$setChildPartConnected()`, 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._$setChildPartConnected()` 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
- * `isConnectd: true` down the tree, signaling which callback to run.
- */
 import { isSingleExpression } from './directive-helpers.js';
 import { Directive, PartType } from './directive.js';
-import { noChange, } from './lit-html.js';
-
 export { directive } from './directive.js';
-
 const DEV_MODE = true;
 /**
  * Recursively walks down the tree of Parts/TemplateInstances/Directives to set
@@ -129,23 +14,24 @@ const DEV_MODE = true;
  *
  * @return True if there were children to disconnect; false otherwise
  */
-const setChildrenConnected = (parent, isConnected) => {
+const notifyChildrenConnectedChanged = (parent, isConnected) => {
     var _a, _b;
-    const children = parent._$disconnetableChildren;
+    const children = parent._$disconnectableChildren;
     if (children === undefined) {
         return false;
     }
     for (const obj of children) {
-        // The existence of `_$setDirectiveConnected` is used as a "brand" to
+        // The existence of `_$notifyDirectiveConnectionChanged` is used as a "brand" to
         // disambiguate AsyncDirectives from other DisconnectableChildren
         // (as opposed to using an instanceof check to know when to call it); the
         // redundancy of "Directive" in the API name is to avoid conflicting with
-        // `_$setChildPartConnected`, which exists `ChildParts` which are also in
+        // `_$notifyConnectionChanged`, which exists `ChildParts` which are also in
         // this list
         // Disconnect Directive (and any nested directives contained within)
-        (_b = (_a = obj)._$setDirectiveConnected) === null || _b === void 0 ? void 0 : _b.call(_a, isConnected, false);
+        // This property needs to remain unminified.
+        (_b = (_a = obj)['_$notifyDirectiveConnectionChanged']) === null || _b === void 0 ? void 0 : _b.call(_a, isConnected, false);
         // Disconnect Part/TemplateInstance
-        setChildrenConnected(obj, isConnected);
+        notifyChildrenConnectedChanged(obj, isConnected);
     }
     return true;
 };
@@ -161,7 +47,7 @@ const removeDisconnectableFromParent = (obj) => {
         if ((parent = obj._$parent) === undefined) {
             break;
         }
-        children = parent._$disconnetableChildren;
+        children = parent._$disconnectableChildren;
         children.delete(obj);
         obj = parent;
     } while ((children === null || children === void 0 ? void 0 : children.size) === 0);
@@ -170,9 +56,9 @@ const addDisconnectableToParent = (obj) => {
     // Climb the parent tree, creating a sparse tree of children needing
     // disconnection
     for (let parent; (parent = obj._$parent); obj = parent) {
-        let children = parent._$disconnetableChildren;
+        let children = parent._$disconnectableChildren;
         if (children === undefined) {
-            parent._$disconnetableChildren = children = new Set();
+            parent._$disconnectableChildren = children = new Set();
         }
         else if (children.has(obj)) {
             // Once we've reached a parent that already contains this child, we
@@ -191,7 +77,7 @@ const addDisconnectableToParent = (obj) => {
  * the core code when parts are moved between different parents.
  */
 function reparentDisconnectables(newParent) {
-    if (this._$disconnetableChildren !== undefined) {
+    if (this._$disconnectableChildren !== undefined) {
         removeDisconnectableFromParent(this);
         this._$parent = newParent;
         addDisconnectableToParent(this);
@@ -221,9 +107,9 @@ function reparentDisconnectables(newParent) {
  * core code when parts are cleared or the connection state is changed by the
  * user.
  */
-function setChildPartConnected(isConnected, isClearingValue = false, fromPartIndex = 0) {
+function notifyChildPartConnectedChanged(isConnected, isClearingValue = false, fromPartIndex = 0) {
     const value = this._$committedValue;
-    const children = this._$disconnetableChildren;
+    const children = this._$disconnectableChildren;
     if (children === undefined || children.size === 0) {
         return;
     }
@@ -233,7 +119,7 @@ function setChildPartConnected(isConnected, isClearingValue = false, fromPartInd
             // disconnected and removed from this ChildPart's disconnectable
             // children (starting at `fromPartIndex` in the case of truncation)
             for (let i = fromPartIndex; i < value.length; i++) {
-                setChildrenConnected(value[i], false);
+                notifyChildrenConnectedChanged(value[i], false);
                 removeDisconnectableFromParent(value[i]);
             }
         }
@@ -241,12 +127,12 @@ function setChildPartConnected(isConnected, isClearingValue = false, fromPartInd
             // TemplateInstance case: If the value has disconnectable children (will
             // only be in the case that it is a TemplateInstance), we disconnect it
             // and remove it from this ChildPart's disconnectable children
-            setChildrenConnected(value, false);
+            notifyChildrenConnectedChanged(value, false);
             removeDisconnectableFromParent(value);
         }
     }
     else {
-        setChildrenConnected(this, isConnected);
+        notifyChildrenConnectedChanged(this, isConnected);
     }
 }
 /**
@@ -256,28 +142,32 @@ const installDisconnectAPI = (obj) => {
     var _a, _b;
     var _c, _d;
     if (obj.type == PartType.CHILD) {
-        (_a = (_c = obj)._$setChildPartConnected) !== null && _a !== void 0 ? _a : (_c._$setChildPartConnected = setChildPartConnected);
+        (_a = (_c = obj)._$notifyConnectionChanged) !== null && _a !== void 0 ? _a : (_c._$notifyConnectionChanged = notifyChildPartConnectedChanged);
         (_b = (_d = obj)._$reparentDisconnectables) !== null && _b !== void 0 ? _b : (_d._$reparentDisconnectables = reparentDisconnectables);
     }
 };
 /**
  * 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.setDirectiveConnection(false)` on
- * a part that was previously rendered containing the directive.
+ * 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.setDirectiveConnection(true)` is subsequently called on a
+ * 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 class AsyncDirective extends Directive {
     constructor() {
         super(...arguments);
-        this.isConnected = true;
-        this._pendingValue = noChange;
         // @internal
-        this._$disconnetableChildren = undefined;
+        this._$disconnectableChildren = undefined;
     }
     /**
      * Initialize the part with internal fields
@@ -288,7 +178,9 @@ export class AsyncDirective extends Directive {
     _$initialize(part, parent, attributeIndex) {
         super._$initialize(part, parent, attributeIndex);
         addDisconnectableToParent(this);
+        this.isConnected = part._$isConnected;
     }
+    // This property needs to remain unminified.
     /**
      * Called from the core code when a directive is going away from a part (in
      * which case `shouldRemoveFromParent` should be true), and from the
@@ -301,55 +193,21 @@ export class AsyncDirective extends Directive {
      *     removed; false when the tree is being disconnected
      * @internal
      */
-    _$setDirectiveConnected(isConnected, isClearingDirective = true) {
-        this._setConnected(isConnected);
-        if (isClearingDirective) {
-            setChildrenConnected(this, isConnected);
-            removeDisconnectableFromParent(this);
-        }
-    }
-    /**
-     * Private method used to set the connection state of the directive and call
-     * the respective `disconnected` or `reconnected` callback. Note thatsince
-     * `isConnected` defaults to true, we do not run `reconnected` on first
-     * render.
-     *
-     * If a call to `setValue` was made while disconnected, flush it to the part
-     * before reconnecting.
-     *
-     * @param isConnected
-     * @internal
-     */
-    _setConnected(isConnected) {
+    ['_$notifyDirectiveConnectionChanged'](isConnected, isClearingDirective = true) {
         var _a, _b;
         if (isConnected !== this.isConnected) {
+            this.isConnected = isConnected;
             if (isConnected) {
-                this.isConnected = true;
-                if (this._pendingValue !== noChange) {
-                    this.setValue(this._pendingValue);
-                    this._pendingValue = noChange;
-                }
                 (_a = this.reconnected) === null || _a === void 0 ? void 0 : _a.call(this);
             }
             else {
-                this.isConnected = false;
                 (_b = this.disconnected) === null || _b === void 0 ? void 0 : _b.call(this);
             }
         }
-    }
-    /**
-     * Override of the base `_resolve` method to ensure `reconnected` is run
-     * prior to the next render.
-     *
-     * @override
-     * @internal
-     */
-    _$resolve(part, props) {
-        if (!this.isConnected) {
-            throw new Error(`AsyncDirective ${this.constructor.name} was ` +
-                `rendered while its tree was disconnected.`);
+        if (isClearingDirective) {
+            notifyChildrenConnectedChanged(this, isConnected);
+            removeDisconnectableFromParent(this);
         }
-        return super._$resolve(part, props);
     }
     /**
      * Sets the value of the directive's Part outside the normal `update`/`render`
@@ -358,30 +216,22 @@ export class AsyncDirective extends Directive {
      * This method should not be called synchronously from a directive's `update`
      * or `render`.
      *
-     * If the method is called while the part is disconnected, the value will be
-     * queued until directive is reconnected.
-     *
      * @param directive The directive to update
      * @param value The value to set
      */
     setValue(value) {
-        if (this.isConnected) {
-            if (isSingleExpression(this.__part)) {
-                this.__part._$setValue(value, this);
-            }
-            else {
-                // this.__attributeIndex will be defined in this case, but
-                // assert it in dev mode
-                if (DEV_MODE && this.__attributeIndex === undefined) {
-                    throw new Error(`Expected this.__attributeIndex to be a number`);
-                }
-                const newValues = [...this.__part._$committedValue];
-                newValues[this.__attributeIndex] = value;
-                this.__part._$setValue(newValues, this, 0);
-            }
+        if (isSingleExpression(this.__part)) {
+            this.__part._$setValue(value, this);
         }
         else {
-            this._pendingValue = value;
+            // this.__attributeIndex will be defined in this case, but
+            // assert it in dev mode
+            if (DEV_MODE && this.__attributeIndex === undefined) {
+                throw new Error(`Expected this.__attributeIndex to be a number`);
+            }
+            const newValues = [...this.__part._$committedValue];
+            newValues[this.__attributeIndex] = value;
+            this.__part._$setValue(newValues, this, 0);
         }
     }
     /**

package/front_end/third_party/lit-html/package/development/async-directive.js.map

@@ -1 +1 @@
-{"version":3,"file":"async-directive.js","sourceRoot":"","sources":["../src/async-directive.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n * Copyright 2017 Google LLC\n * SPDX-License-Identifier: BSD-3-Clause\n */\n\n/**\n * Overview:\n *\n * This module is designed to add support for an async `setValue` API and\n * `disconnected` callback to directives with the least impact on the core\n * runtime or payload when that feature is not used.\n *\n * The strategy is to introduce a `AsyncDirective` subclass of\n * `Directive` that climbs the \"parent\" tree in its constructor to note which\n * branches of lit-html's \"logical tree\" of data structures contain such\n * directives and thus need to be crawled when a subtree is being cleared (or\n * manually disconnected) in order to run the `disconnected` callback.\n *\n * The \"nodes\" of the logical tree include Parts, TemplateInstances (for when a\n * TemplateResult is committed to a value of a ChildPart), and Directives; these\n * all implement a common interface called `DisconnectableChild`. Each has a\n * `_$parent` reference which is set during construction in the core code, and a\n * `_$disconnectableChildren` field which is initially undefined.\n *\n * The sparse tree created by means of the `AsyncDirective` constructor\n * crawling up the `_$parent` tree and placing a `_$disconnectableChildren` Set\n * on each parent that includes each child that contains a\n * `AsyncDirective` directly or transitively via its children. In order\n * disconnect (or reconnect) a tree, the `_$setChildPartConnected` API is patched\n * onto ChildParts as a directive climbs the parent tree, which is called by the\n * core when clearing a part if it exists. When called, that method iterates\n * over the sparse tree of Set<DisconnectableChildren> built up by\n * AsyncDirectives, and calls `_$setDirectiveConnected` on any\n * directives that are encountered in that tree, running the required callbacks.\n *\n * A given \"logical tree\" of lit-html data-structures might look like this:\n *\n *  ChildPart(N1) _$dC=[D2,T3]\n *   ._directive\n *     AsyncDirective(D2)\n *   ._value // user value was TemplateResult\n *     TemplateInstance(T3) _$dC=[A4,A6,N10,N12]\n *      ._parts[]\n *        AttributePart(A4) _$dC=[D5]\n *         ._directives[]\n *           AsyncDirective(D5)\n *        AttributePart(A6) _$dC=[D7,D8]\n *         ._directives[]\n *           AsyncDirective(D7)\n *           Directive(D8) _$dC=[D9]\n *            ._directive\n *              AsyncDirective(D9)\n *        ChildPart(N10) _$dC=[D11]\n *         ._directive\n *           AsyncDirective(D11)\n *         ._value\n *           string\n *        ChildPart(N12) _$dC=[D13,N14,N16]\n *         ._directive\n *           AsyncDirective(D13)\n *         ._value // user value was iterable\n *           Array<ChildPart>\n *             ChildPart(N14) _$dC=[D15]\n *              ._value\n *                string\n *             ChildPart(N16) _$dC=[D17,T18]\n *              ._directive\n *                AsyncDirective(D17)\n *              ._value // user value was TemplateResult\n *                TemplateInstance(T18) _$dC=[A19,A21,N25]\n *                 ._parts[]\n *                   AttributePart(A19) _$dC=[D20]\n *                    ._directives[]\n *                      AsyncDirective(D20)\n *                   AttributePart(A21) _$dC=[22,23]\n *                    ._directives[]\n *                      AsyncDirective(D22)\n *                      Directive(D23) _$dC=[D24]\n *                       ._directive\n *                         AsyncDirective(D24)\n *                   ChildPart(N25) _$dC=[D26]\n *                    ._directive\n *                      AsyncDirective(D26)\n *                    ._value\n *                      string\n *\n * Example 1: The directive in ChildPart(N12) updates and returns `nothing`. The\n * ChildPart will _clear() itself, and so we need to disconnect the \"value\" of\n * the ChildPart (but not its directive). In this case, when `_clear()` calls\n * `_$setChildPartConnected()`, we don't iterate all of the\n * _$disconnectableChildren, rather we do a value-specific disconnection: i.e.\n * since the _value was an Array<ChildPart> (because an iterable had been\n * committed), we iterate the array of ChildParts (N14, N16) and run\n * `setConnected` on them (which does recurse down the full tree of\n * `_$disconnectableChildren` below it, and also removes N14 and N16 from N12's\n * `_$disconnectableChildren`). Once the values have been disconnected, we then\n * check whether the ChildPart(N12)'s list of `_$disconnectableChildren` is empty\n * (and would remove it from its parent TemplateInstance(T3) if so), but since\n * it would still contain its directive D13, it stays in the disconnectable\n * tree.\n *\n * Example 2: In the course of Example 1, `setConnected` will reach\n * ChildPart(N16); in this case the entire part is being disconnected, so we\n * simply iterate all of N16's `_$disconnectableChildren` (D17,T18) and\n * recursively run `setConnected` on them. Note that we only remove children\n * from `_$disconnectableChildren` for the top-level values being disconnected\n * on a clear; doing this bookkeeping lower in the tree is wasteful since it's\n * all being thrown away.\n *\n * Example 3: If the LitElement containing the entire tree above becomes\n * disconnected, it will run `childPart.setConnected()` (which calls\n * `childPart._$setChildPartConnected()` if it exists); in this case, we\n * recursively run `setConnected()` over the entire tree, without removing any\n * children from `_$disconnectableChildren`, since this tree is required to\n * re-connect the tree, which does the same operation, simply passing\n * `isConnectd: true` down the tree, signaling which callback to run.\n */\n\nimport {\n  AttributePart,\n  ChildPart,\n  Disconnectable,\n  noChange,\n  Part,\n} from './lit-html.js';\nimport {isSingleExpression} from './directive-helpers.js';\nimport {Directive, PartInfo, PartType} from './directive.js';\nexport {directive} from './directive.js';\n\nconst DEV_MODE = true;\n\n/**\n * Recursively walks down the tree of Parts/TemplateInstances/Directives to set\n * the connected state of directives and run `disconnected`/ `reconnected`\n * callbacks.\n *\n * @return True if there were children to disconnect; false otherwise\n */\nconst setChildrenConnected = (\n  parent: Disconnectable,\n  isConnected: boolean\n): boolean => {\n  const children = parent._$disconnetableChildren;\n  if (children === undefined) {\n    return false;\n  }\n  for (const obj of children) {\n    // The existence of `_$setDirectiveConnected` is used as a \"brand\" to\n    // disambiguate AsyncDirectives from other DisconnectableChildren\n    // (as opposed to using an instanceof check to know when to call it); the\n    // redundancy of \"Directive\" in the API name is to avoid conflicting with\n    // `_$setChildPartConnected`, which exists `ChildParts` which are also in\n    // this list\n    // Disconnect Directive (and any nested directives contained within)\n    (obj as AsyncDirective)._$setDirectiveConnected?.(isConnected, false);\n    // Disconnect Part/TemplateInstance\n    setChildrenConnected(obj, isConnected);\n  }\n  return true;\n};\n\n/**\n * Removes the given child from its parent list of disconnectable children, and\n * if the parent list becomes empty as a result, removes the parent from its\n * parent, and so forth up the tree when that causes subsequent parent lists to\n * become empty.\n */\nconst removeDisconnectableFromParent = (obj: Disconnectable) => {\n  let parent, children;\n  do {\n    if ((parent = obj._$parent) === undefined) {\n      break;\n    }\n    children = parent._$disconnetableChildren!;\n    children.delete(obj);\n    obj = parent;\n  } while (children?.size === 0);\n};\n\nconst addDisconnectableToParent = (obj: Disconnectable) => {\n  // Climb the parent tree, creating a sparse tree of children needing\n  // disconnection\n  for (let parent; (parent = obj._$parent); obj = parent) {\n    let children = parent._$disconnetableChildren;\n    if (children === undefined) {\n      parent._$disconnetableChildren = children = new Set();\n    } else if (children.has(obj)) {\n      // Once we've reached a parent that already contains this child, we\n      // can short-circuit\n      break;\n    }\n    children.add(obj);\n    installDisconnectAPI(parent);\n  }\n};\n\n/**\n * Changes the parent reference of the ChildPart, and updates the sparse tree of\n * Disconnectable children accordingly.\n *\n * Note, this method will be patched onto ChildPart instances and called from\n * the core code when parts are moved between different parents.\n */\nfunction reparentDisconnectables(this: ChildPart, newParent: Disconnectable) {\n  if (this._$disconnetableChildren !== undefined) {\n    removeDisconnectableFromParent(this);\n    this._$parent = newParent;\n    addDisconnectableToParent(this);\n  } else {\n    this._$parent = newParent;\n  }\n}\n\n/**\n * Sets the connected state on any directives contained within the committed\n * value of this part (i.e. within a TemplateInstance or iterable of\n * ChildParts) and runs their `disconnected`/`reconnected`s, as well as within\n * any directives stored on the ChildPart (when `valueOnly` is false).\n *\n * `isClearingValue` should be passed as `true` on a top-level part that is\n * clearing itself, and not as a result of recursively disconnecting directives\n * as part of a `clear` operation higher up the tree. This both ensures that any\n * directive on this ChildPart that produced a value that caused the clear\n * operation is not disconnected, and also serves as a performance optimization\n * to avoid needless bookkeeping when a subtree is going away; when clearing a\n * subtree, only the top-most part need to remove itself from the parent.\n *\n * `fromPartIndex` is passed only in the case of a partial `_clear` running as a\n * result of truncating an iterable.\n *\n * Note, this method will be patched onto ChildPart instances and called from the\n * core code when parts are cleared or the connection state is changed by the\n * user.\n */\nfunction setChildPartConnected(\n  this: ChildPart,\n  isConnected: boolean,\n  isClearingValue = false,\n  fromPartIndex = 0\n) {\n  const value = this._$committedValue;\n  const children = this._$disconnetableChildren;\n  if (children === undefined || children.size === 0) {\n    return;\n  }\n  if (isClearingValue) {\n    if (Array.isArray(value)) {\n      // Iterable case: Any ChildParts created by the iterable should be\n      // disconnected and removed from this ChildPart's disconnectable\n      // children (starting at `fromPartIndex` in the case of truncation)\n      for (let i = fromPartIndex; i < value.length; i++) {\n        setChildrenConnected(value[i], false);\n        removeDisconnectableFromParent(value[i]);\n      }\n    } else if (value != null) {\n      // TemplateInstance case: If the value has disconnectable children (will\n      // only be in the case that it is a TemplateInstance), we disconnect it\n      // and remove it from this ChildPart's disconnectable children\n      setChildrenConnected(value as Disconnectable, false);\n      removeDisconnectableFromParent(value as Disconnectable);\n    }\n  } else {\n    setChildrenConnected(this, isConnected);\n  }\n}\n\n/**\n * Patches disconnection API onto ChildParts.\n */\nconst installDisconnectAPI = (obj: Disconnectable) => {\n  if ((obj as ChildPart).type == PartType.CHILD) {\n    (obj as ChildPart)._$setChildPartConnected ??= setChildPartConnected;\n    (obj as ChildPart)._$reparentDisconnectables ??= reparentDisconnectables;\n  }\n};\n\n/**\n * An abstract `Directive` base class whose `disconnected` method will be\n * called when the part containing the directive is cleared as a result of\n * re-rendering, or when the user calls `part.setDirectiveConnection(false)` on\n * a part that was previously rendered containing the directive.\n *\n * If `part.setDirectiveConnection(true)` is subsequently called on a\n * containing part, the directive's `reconnected` method will be called prior\n * to its next `update`/`render` callbacks. When implementing `disconnected`,\n * `reconnected` should also be implemented to be compatible with reconnection.\n */\nexport abstract class AsyncDirective extends Directive {\n  isConnected = true;\n  private _pendingValue: unknown = noChange;\n  // @internal\n  _$disconnetableChildren?: Set<Disconnectable> = undefined;\n  /**\n   * Initialize the part with internal fields\n   * @param part\n   * @param parent\n   * @param attributeIndex\n   */\n  _$initialize(\n    part: Part,\n    parent: Disconnectable,\n    attributeIndex: number | undefined\n  ) {\n    super._$initialize(part, parent, attributeIndex);\n    addDisconnectableToParent(this);\n  }\n  /**\n   * Called from the core code when a directive is going away from a part (in\n   * which case `shouldRemoveFromParent` should be true), and from the\n   * `setChildrenConnected` helper function when recursively changing the\n   * connection state of a tree (in which case `shouldRemoveFromParent` should\n   * be false).\n   *\n   * @param isConnected\n   * @param isClearingDirective - True when the directive itself is being\n   *     removed; false when the tree is being disconnected\n   * @internal\n   */\n  _$setDirectiveConnected(isConnected: boolean, isClearingDirective = true) {\n    this._setConnected(isConnected);\n    if (isClearingDirective) {\n      setChildrenConnected(this, isConnected);\n      removeDisconnectableFromParent(this);\n    }\n  }\n  /**\n   * Private method used to set the connection state of the directive and call\n   * the respective `disconnected` or `reconnected` callback. Note thatsince\n   * `isConnected` defaults to true, we do not run `reconnected` on first\n   * render.\n   *\n   * If a call to `setValue` was made while disconnected, flush it to the part\n   * before reconnecting.\n   *\n   * @param isConnected\n   * @internal\n   */\n  private _setConnected(isConnected: boolean) {\n    if (isConnected !== this.isConnected) {\n      if (isConnected) {\n        this.isConnected = true;\n        if (this._pendingValue !== noChange) {\n          this.setValue(this._pendingValue);\n          this._pendingValue = noChange;\n        }\n        this.reconnected?.();\n      } else {\n        this.isConnected = false;\n        this.disconnected?.();\n      }\n    }\n  }\n\n  /**\n   * Override of the base `_resolve` method to ensure `reconnected` is run\n   * prior to the next render.\n   *\n   * @override\n   * @internal\n   */\n  _$resolve(part: Part, props: Array<unknown>): unknown {\n    if (!this.isConnected) {\n      throw new Error(\n        `AsyncDirective ${this.constructor.name} was ` +\n          `rendered while its tree was disconnected.`\n      );\n    }\n    return super._$resolve(part, props);\n  }\n\n  /**\n   * Sets the value of the directive's Part outside the normal `update`/`render`\n   * lifecycle of a directive.\n   *\n   * This method should not be called synchronously from a directive's `update`\n   * or `render`.\n   *\n   * If the method is called while the part is disconnected, the value will be\n   * queued until directive is reconnected.\n   *\n   * @param directive The directive to update\n   * @param value The value to set\n   */\n  setValue(value: unknown) {\n    if (this.isConnected) {\n      if (isSingleExpression((this.__part as unknown) as PartInfo)) {\n        this.__part._$setValue(value, this);\n      } else {\n        // this.__attributeIndex will be defined in this case, but\n        // assert it in dev mode\n        if (DEV_MODE && this.__attributeIndex === undefined) {\n          throw new Error(`Expected this.__attributeIndex to be a number`);\n        }\n        const newValues = [...(this.__part._$committedValue as Array<unknown>)];\n        newValues[this.__attributeIndex!] = value;\n        (this.__part as AttributePart)._$setValue(newValues, this, 0);\n      }\n    } else {\n      this._pendingValue = value;\n    }\n  }\n\n  /**\n   * User callbacks for implementing logic to release any resources/subscriptions\n   * that may have been retained by this directive. Since directives may also be\n   * re-connected, `reconnected` should also be implemented to restore the\n   * working state of the directive prior to the next render.\n   */\n  protected disconnected() {}\n  protected reconnected() {}\n}\n"]}
+{"version":3,"file":"async-directive.js","sourceRoot":"","sources":["../src/async-directive.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n * Copyright 2017 Google LLC\n * SPDX-License-Identifier: BSD-3-Clause\n */\n\n/**\n * Overview:\n *\n * This module is designed to add support for an async `setValue` API and\n * `disconnected` callback to directives with the least impact on the core\n * runtime or payload when that feature is not used.\n *\n * The strategy is to introduce a `AsyncDirective` subclass of\n * `Directive` that climbs the \"parent\" tree in its constructor to note which\n * branches of lit-html's \"logical tree\" of data structures contain such\n * directives and thus need to be crawled when a subtree is being cleared (or\n * manually disconnected) in order to run the `disconnected` callback.\n *\n * The \"nodes\" of the logical tree include Parts, TemplateInstances (for when a\n * TemplateResult is committed to a value of a ChildPart), and Directives; these\n * all implement a common interface called `DisconnectableChild`. Each has a\n * `_$parent` reference which is set during construction in the core code, and a\n * `_$disconnectableChildren` field which is initially undefined.\n *\n * The sparse tree created by means of the `AsyncDirective` constructor\n * crawling up the `_$parent` tree and placing a `_$disconnectableChildren` Set\n * on each parent that includes each child that contains a\n * `AsyncDirective` directly or transitively via its children. In order to\n * notify connection state changes and disconnect (or reconnect) a tree, the\n * `_$notifyConnectionChanged` API is patched onto ChildParts as a directive\n * climbs the parent tree, which is called by the core when clearing a part if\n * it exists. When called, that method iterates over the sparse tree of\n * Set<DisconnectableChildren> built up by AsyncDirectives, and calls\n * `_$notifyDirectiveConnectionChanged` on any directives that are encountered\n * in that tree, running the required callbacks.\n *\n * A given \"logical tree\" of lit-html data-structures might look like this:\n *\n *  ChildPart(N1) _$dC=[D2,T3]\n *   ._directive\n *     AsyncDirective(D2)\n *   ._value // user value was TemplateResult\n *     TemplateInstance(T3) _$dC=[A4,A6,N10,N12]\n *      ._parts[]\n *        AttributePart(A4) _$dC=[D5]\n *         ._directives[]\n *           AsyncDirective(D5)\n *        AttributePart(A6) _$dC=[D7,D8]\n *         ._directives[]\n *           AsyncDirective(D7)\n *           Directive(D8) _$dC=[D9]\n *            ._directive\n *              AsyncDirective(D9)\n *        ChildPart(N10) _$dC=[D11]\n *         ._directive\n *           AsyncDirective(D11)\n *         ._value\n *           string\n *        ChildPart(N12) _$dC=[D13,N14,N16]\n *         ._directive\n *           AsyncDirective(D13)\n *         ._value // user value was iterable\n *           Array<ChildPart>\n *             ChildPart(N14) _$dC=[D15]\n *              ._value\n *                string\n *             ChildPart(N16) _$dC=[D17,T18]\n *              ._directive\n *                AsyncDirective(D17)\n *              ._value // user value was TemplateResult\n *                TemplateInstance(T18) _$dC=[A19,A21,N25]\n *                 ._parts[]\n *                   AttributePart(A19) _$dC=[D20]\n *                    ._directives[]\n *                      AsyncDirective(D20)\n *                   AttributePart(A21) _$dC=[22,23]\n *                    ._directives[]\n *                      AsyncDirective(D22)\n *                      Directive(D23) _$dC=[D24]\n *                       ._directive\n *                         AsyncDirective(D24)\n *                   ChildPart(N25) _$dC=[D26]\n *                    ._directive\n *                      AsyncDirective(D26)\n *                    ._value\n *                      string\n *\n * Example 1: The directive in ChildPart(N12) updates and returns `nothing`. The\n * ChildPart will _clear() itself, and so we need to disconnect the \"value\" of\n * the ChildPart (but not its directive). In this case, when `_clear()` calls\n * `_$notifyConnectionChanged()`, we don't iterate all of the\n * _$disconnectableChildren, rather we do a value-specific disconnection: i.e.\n * since the _value was an Array<ChildPart> (because an iterable had been\n * committed), we iterate the array of ChildParts (N14, N16) and run\n * `setConnected` on them (which does recurse down the full tree of\n * `_$disconnectableChildren` below it, and also removes N14 and N16 from N12's\n * `_$disconnectableChildren`). Once the values have been disconnected, we then\n * check whether the ChildPart(N12)'s list of `_$disconnectableChildren` is empty\n * (and would remove it from its parent TemplateInstance(T3) if so), but since\n * it would still contain its directive D13, it stays in the disconnectable\n * tree.\n *\n * Example 2: In the course of Example 1, `setConnected` will reach\n * ChildPart(N16); in this case the entire part is being disconnected, so we\n * simply iterate all of N16's `_$disconnectableChildren` (D17,T18) and\n * recursively run `setConnected` on them. Note that we only remove children\n * from `_$disconnectableChildren` for the top-level values being disconnected\n * on a clear; doing this bookkeeping lower in the tree is wasteful since it's\n * all being thrown away.\n *\n * Example 3: If the LitElement containing the entire tree above becomes\n * disconnected, it will run `childPart.setConnected()` (which calls\n * `childPart._$notifyConnectionChanged()` if it exists); in this case, we\n * recursively run `setConnected()` over the entire tree, without removing any\n * children from `_$disconnectableChildren`, since this tree is required to\n * re-connect the tree, which does the same operation, simply passing\n * `isConnectd: true` down the tree, signaling which callback to run.\n */\n\nimport {AttributePart, ChildPart, Disconnectable, Part} from './lit-html.js';\nimport {isSingleExpression} from './directive-helpers.js';\nimport {Directive, PartInfo, PartType} from './directive.js';\nexport {directive} from './directive.js';\n\nconst DEV_MODE = true;\n\n/**\n * Recursively walks down the tree of Parts/TemplateInstances/Directives to set\n * the connected state of directives and run `disconnected`/ `reconnected`\n * callbacks.\n *\n * @return True if there were children to disconnect; false otherwise\n */\nconst notifyChildrenConnectedChanged = (\n  parent: Disconnectable,\n  isConnected: boolean\n): boolean => {\n  const children = parent._$disconnectableChildren;\n  if (children === undefined) {\n    return false;\n  }\n  for (const obj of children) {\n    // The existence of `_$notifyDirectiveConnectionChanged` is used as a \"brand\" to\n    // disambiguate AsyncDirectives from other DisconnectableChildren\n    // (as opposed to using an instanceof check to know when to call it); the\n    // redundancy of \"Directive\" in the API name is to avoid conflicting with\n    // `_$notifyConnectionChanged`, which exists `ChildParts` which are also in\n    // this list\n    // Disconnect Directive (and any nested directives contained within)\n    // This property needs to remain unminified.\n    (obj as AsyncDirective)['_$notifyDirectiveConnectionChanged']?.(\n      isConnected,\n      false\n    );\n    // Disconnect Part/TemplateInstance\n    notifyChildrenConnectedChanged(obj, isConnected);\n  }\n  return true;\n};\n\n/**\n * Removes the given child from its parent list of disconnectable children, and\n * if the parent list becomes empty as a result, removes the parent from its\n * parent, and so forth up the tree when that causes subsequent parent lists to\n * become empty.\n */\nconst removeDisconnectableFromParent = (obj: Disconnectable) => {\n  let parent, children;\n  do {\n    if ((parent = obj._$parent) === undefined) {\n      break;\n    }\n    children = parent._$disconnectableChildren!;\n    children.delete(obj);\n    obj = parent;\n  } while (children?.size === 0);\n};\n\nconst addDisconnectableToParent = (obj: Disconnectable) => {\n  // Climb the parent tree, creating a sparse tree of children needing\n  // disconnection\n  for (let parent; (parent = obj._$parent); obj = parent) {\n    let children = parent._$disconnectableChildren;\n    if (children === undefined) {\n      parent._$disconnectableChildren = children = new Set();\n    } else if (children.has(obj)) {\n      // Once we've reached a parent that already contains this child, we\n      // can short-circuit\n      break;\n    }\n    children.add(obj);\n    installDisconnectAPI(parent);\n  }\n};\n\n/**\n * Changes the parent reference of the ChildPart, and updates the sparse tree of\n * Disconnectable children accordingly.\n *\n * Note, this method will be patched onto ChildPart instances and called from\n * the core code when parts are moved between different parents.\n */\nfunction reparentDisconnectables(this: ChildPart, newParent: Disconnectable) {\n  if (this._$disconnectableChildren !== undefined) {\n    removeDisconnectableFromParent(this);\n    this._$parent = newParent;\n    addDisconnectableToParent(this);\n  } else {\n    this._$parent = newParent;\n  }\n}\n\n/**\n * Sets the connected state on any directives contained within the committed\n * value of this part (i.e. within a TemplateInstance or iterable of\n * ChildParts) and runs their `disconnected`/`reconnected`s, as well as within\n * any directives stored on the ChildPart (when `valueOnly` is false).\n *\n * `isClearingValue` should be passed as `true` on a top-level part that is\n * clearing itself, and not as a result of recursively disconnecting directives\n * as part of a `clear` operation higher up the tree. This both ensures that any\n * directive on this ChildPart that produced a value that caused the clear\n * operation is not disconnected, and also serves as a performance optimization\n * to avoid needless bookkeeping when a subtree is going away; when clearing a\n * subtree, only the top-most part need to remove itself from the parent.\n *\n * `fromPartIndex` is passed only in the case of a partial `_clear` running as a\n * result of truncating an iterable.\n *\n * Note, this method will be patched onto ChildPart instances and called from the\n * core code when parts are cleared or the connection state is changed by the\n * user.\n */\nfunction notifyChildPartConnectedChanged(\n  this: ChildPart,\n  isConnected: boolean,\n  isClearingValue = false,\n  fromPartIndex = 0\n) {\n  const value = this._$committedValue;\n  const children = this._$disconnectableChildren;\n  if (children === undefined || children.size === 0) {\n    return;\n  }\n  if (isClearingValue) {\n    if (Array.isArray(value)) {\n      // Iterable case: Any ChildParts created by the iterable should be\n      // disconnected and removed from this ChildPart's disconnectable\n      // children (starting at `fromPartIndex` in the case of truncation)\n      for (let i = fromPartIndex; i < value.length; i++) {\n        notifyChildrenConnectedChanged(value[i], false);\n        removeDisconnectableFromParent(value[i]);\n      }\n    } else if (value != null) {\n      // TemplateInstance case: If the value has disconnectable children (will\n      // only be in the case that it is a TemplateInstance), we disconnect it\n      // and remove it from this ChildPart's disconnectable children\n      notifyChildrenConnectedChanged(value as Disconnectable, false);\n      removeDisconnectableFromParent(value as Disconnectable);\n    }\n  } else {\n    notifyChildrenConnectedChanged(this, isConnected);\n  }\n}\n\n/**\n * Patches disconnection API onto ChildParts.\n */\nconst installDisconnectAPI = (obj: Disconnectable) => {\n  if ((obj as ChildPart).type == PartType.CHILD) {\n    (obj as ChildPart)._$notifyConnectionChanged ??=\n      notifyChildPartConnectedChanged;\n    (obj as ChildPart)._$reparentDisconnectables ??= reparentDisconnectables;\n  }\n};\n\n/**\n * An abstract `Directive` base class whose `disconnected` method will be\n * called when the part containing the directive is cleared as a result of\n * re-rendering, or when the user calls `part.setConnected(false)` on\n * a part that was previously rendered containing the directive (as happens\n * when e.g. a LitElement disconnects from the DOM).\n *\n * If `part.setConnected(true)` is subsequently called on a\n * containing part, the directive's `reconnected` method will be called prior\n * to its next `update`/`render` callbacks. When implementing `disconnected`,\n * `reconnected` should also be implemented to be compatible with reconnection.\n *\n * Note that updates may occur while the directive is disconnected. As such,\n * directives should generally check the `this.isConnected` flag during\n * render/update to determine whether it is safe to subscribe to resources\n * that may prevent garbage collection.\n */\nexport abstract class AsyncDirective extends Directive {\n  // As opposed to other Disconnectables, AsyncDirectives always get notified\n  // when the RootPart connection changes, so the public `isConnected`\n  // is a locally stored variable initialized via its part's getter and synced\n  // via `_$notifyDirectiveConnectionChanged`. This is cheaper than using\n  // the _$isConnected getter, which has to look back up the tree each time.\n  /**\n   * The connection state for this Directive.\n   */\n  isConnected!: boolean;\n\n  // @internal\n  override _$disconnectableChildren?: Set<Disconnectable> = undefined;\n  /**\n   * Initialize the part with internal fields\n   * @param part\n   * @param parent\n   * @param attributeIndex\n   */\n  override _$initialize(\n    part: Part,\n    parent: Disconnectable,\n    attributeIndex: number | undefined\n  ) {\n    super._$initialize(part, parent, attributeIndex);\n    addDisconnectableToParent(this);\n    this.isConnected = part._$isConnected;\n  }\n  // This property needs to remain unminified.\n  /**\n   * Called from the core code when a directive is going away from a part (in\n   * which case `shouldRemoveFromParent` should be true), and from the\n   * `setChildrenConnected` helper function when recursively changing the\n   * connection state of a tree (in which case `shouldRemoveFromParent` should\n   * be false).\n   *\n   * @param isConnected\n   * @param isClearingDirective - True when the directive itself is being\n   *     removed; false when the tree is being disconnected\n   * @internal\n   */\n  override ['_$notifyDirectiveConnectionChanged'](\n    isConnected: boolean,\n    isClearingDirective = true\n  ) {\n    if (isConnected !== this.isConnected) {\n      this.isConnected = isConnected;\n      if (isConnected) {\n        this.reconnected?.();\n      } else {\n        this.disconnected?.();\n      }\n    }\n    if (isClearingDirective) {\n      notifyChildrenConnectedChanged(this, isConnected);\n      removeDisconnectableFromParent(this);\n    }\n  }\n\n  /**\n   * Sets the value of the directive's Part outside the normal `update`/`render`\n   * lifecycle of a directive.\n   *\n   * This method should not be called synchronously from a directive's `update`\n   * or `render`.\n   *\n   * @param directive The directive to update\n   * @param value The value to set\n   */\n  setValue(value: unknown) {\n    if (isSingleExpression(this.__part as unknown as PartInfo)) {\n      this.__part._$setValue(value, this);\n    } else {\n      // this.__attributeIndex will be defined in this case, but\n      // assert it in dev mode\n      if (DEV_MODE && this.__attributeIndex === undefined) {\n        throw new Error(`Expected this.__attributeIndex to be a number`);\n      }\n      const newValues = [...(this.__part._$committedValue as Array<unknown>)];\n      newValues[this.__attributeIndex!] = value;\n      (this.__part as AttributePart)._$setValue(newValues, this, 0);\n    }\n  }\n\n  /**\n   * User callbacks for implementing logic to release any resources/subscriptions\n   * that may have been retained by this directive. Since directives may also be\n   * re-connected, `reconnected` should also be implemented to restore the\n   * working state of the directive prior to the next render.\n   */\n  protected disconnected() {}\n  protected reconnected() {}\n}\n"]}

package/front_end/third_party/lit-html/package/development/directive-helpers.d.ts

@@ -3,15 +3,15 @@
  * Copyright 2020 Google LLC
  * SPDX-License-Identifier: BSD-3-Clause
  */
-import { DirectiveClass, DirectiveResult, PartInfo } from './directive.js';
-import { DirectiveParent, Part, TemplateResult } from './lit-html.js';
-
+import { Part, DirectiveParent, TemplateResult } from './lit-html.js';
+import { DirectiveResult, DirectiveClass, PartInfo } from './directive.js';
+declare type Primitive = null | undefined | boolean | number | string | symbol | bigint;
 /**
  * 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 string | number | bigint | boolean | symbol | null | undefined;
+export declare const isPrimitive: (value: unknown) => value is Primitive;
 export declare const TemplateResultType: {
     readonly HTML: 1;
     readonly SVG: 2;
@@ -20,7 +20,7 @@ export declare type TemplateResultType = typeof TemplateResultType[keyof typeof
 /**
  * Tests if a value is a TemplateResult.
  */
-export declare const isTemplateResult: (value: unknown, type?: 1 | 2 | undefined) => value is TemplateResult<1 | 2>;
+export declare const isTemplateResult: (value: unknown, type?: TemplateResultType | undefined) => value is TemplateResult<1 | 2>;
 /**
  * Tests if a value is a DirectiveResult.
  */
@@ -102,4 +102,5 @@ export declare const getCommittedValue: (part: import("./lit-html.js").ChildPart
  */
 export declare const removePart: (part: import("./lit-html.js").ChildPart) => void;
 export declare const clearPart: (part: import("./lit-html.js").ChildPart) => void;
+export {};
 //# sourceMappingURL=directive-helpers.d.ts.map

package/front_end/third_party/lit-html/package/development/directive-helpers.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"directive-helpers.d.ts","sourceRoot":"","sources":["../src/directive-helpers.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAK,IAAI,EAAE,eAAe,EAAE,cAAc,EAAC,MAAM,eAAe,CAAC;AACxE,OAAO,EACL,eAAe,EACf,cAAc,EACd,QAAQ,EAET,MAAM,gBAAgB,CAAC;AAgBxB;;;;GAIG;AACH,eAAO,MAAM,WAAW,UAAW,OAAO,4EACkC,CAAC;AAE7E,eAAO,MAAM,kBAAkB;;;CAGrB,CAAC;AAEX,oBAAY,kBAAkB,GAAG,OAAO,kBAAkB,CAAC,MAAM,OAAO,kBAAkB,CAAC,CAAC;AAE5F;;GAEG;AACH,eAAO,MAAM,gBAAgB,UACpB,OAAO,6DAKoC,CAAC;AAErD;;GAEG;AACH,eAAO,MAAM,iBAAiB,UAAW,OAAO,6CACW,CAAC;AAE5D;;GAEG;AACH,eAAO,MAAM,iBAAiB,UAAW,OAAO,KAAG,cAAc,GAAG,SACvB,CAAC;AAE9C;;;;;;;GAOG;AACH,eAAO,MAAM,kBAAkB,SAAU,QAAQ,YACE,CAAC;AAIpD;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,UAAU,wMAyCtB,CAAC;AAEF;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,iBAAiB,gEAErB,OAAO,oBACG,eAAe,MAIjC,CAAC;AAMF;;;;;;;;;;GAUG;AACH,eAAO,MAAM,iBAAiB,SAAU,IAAI,UAAS,OAAO,YAC3B,CAAC;AAElC;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,iBAAiB,sDAA6C,CAAC;AAE5E;;;;GAIG;AACH,eAAO,MAAM,UAAU,mDAStB,CAAC;AAEF,eAAO,MAAM,SAAS,mDAErB,CAAC"}
+{"version":3,"file":"directive-helpers.d.ts","sourceRoot":"","sources":["../src/directive-helpers.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAO,IAAI,EAAE,eAAe,EAAE,cAAc,EAAC,MAAM,eAAe,CAAC;AAC1E,OAAO,EACL,eAAe,EACf,cAAc,EACd,QAAQ,EAET,MAAM,gBAAgB,CAAC;AACxB,aAAK,SAAS,GAAG,IAAI,GAAG,SAAS,GAAG,OAAO,GAAG,MAAM,GAAG,MAAM,GAAG,MAAM,GAAG,MAAM,CAAC;AAehF;;;;GAIG;AACH,eAAO,MAAM,WAAW,UAAW,OAAO,uBACkC,CAAC;AAE7E,eAAO,MAAM,kBAAkB;;;CAGrB,CAAC;AAEX,oBAAY,kBAAkB,GAC5B,OAAO,kBAAkB,CAAC,MAAM,OAAO,kBAAkB,CAAC,CAAC;AAE7D;;GAEG;AACH,eAAO,MAAM,gBAAgB,UACpB,OAAO,0EAMwC,CAAC;AAEzD;;GAEG;AACH,eAAO,MAAM,iBAAiB,UAAW,OAAO,6CAEe,CAAC;AAEhE;;GAEG;AACH,eAAO,MAAM,iBAAiB,UAAW,OAAO,KAAG,cAAc,GAAG,SAEnB,CAAC;AAElD;;;;;;;GAOG;AACH,eAAO,MAAM,kBAAkB,SAAU,QAAQ,YACE,CAAC;AAIpD;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,UAAU,wMAqDtB,CAAC;AAEF;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,iBAAiB,gEAErB,OAAO,oBACG,eAAe,MAIjC,CAAC;AAMF;;;;;;;;;;GAUG;AACH,eAAO,MAAM,iBAAiB,SAAU,IAAI,UAAS,OAAO,YAC3B,CAAC;AAElC;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,iBAAiB,sDAA6C,CAAC;AAE5E;;;;GAIG;AACH,eAAO,MAAM,UAAU,mDAStB,CAAC;AAEF,eAAO,MAAM,SAAS,mDAErB,CAAC"}

package/front_end/third_party/lit-html/package/development/directive-helpers.js

@@ -4,10 +4,11 @@
  * SPDX-License-Identifier: BSD-3-Clause
  */
 var _a, _b;
-import { _Σ } from './lit-html.js';
-const { _ChildPart: ChildPart } = _Σ;
+import { _$LH } from './lit-html.js';
+const { _ChildPart: ChildPart } = _$LH;
 const ENABLE_SHADYDOM_NOPATCH = true;
-const wrap = ENABLE_SHADYDOM_NOPATCH && ((_a = window.ShadyDOM) === null || _a === void 0 ? void 0 : _a.inUse) &&
+const wrap = ENABLE_SHADYDOM_NOPATCH &&
+    ((_a = window.ShadyDOM) === null || _a === void 0 ? void 0 : _a.inUse) &&
     ((_b = window.ShadyDOM) === null || _b === void 0 ? void 0 : _b.noPatch) === true
     ? window.ShadyDOM.wrap
     : (node) => node;
@@ -27,17 +28,22 @@ export const TemplateResultType = {
 export const isTemplateResult = (value, type) => {
     var _a, _b;
     return type === undefined
-        ? ((_a = value) === null || _a === void 0 ? void 0 : _a._$litType$) !== undefined
-        : ((_b = value) === null || _b === void 0 ? void 0 : _b._$litType$) === type;
+        ? // This property needs to remain unminified.
+            ((_a = value) === null || _a === void 0 ? void 0 : _a['_$litType$']) !== undefined
+        : ((_b = value) === null || _b === void 0 ? void 0 : _b['_$litType$']) === type;
 };
 /**
  * Tests if a value is a DirectiveResult.
  */
-export const isDirectiveResult = (value) => { var _a; return ((_a = value) === null || _a === void 0 ? void 0 : _a._$litDirective$) !== undefined; };
+export const isDirectiveResult = (value) => { var _a; 
+// This property needs to remain unminified.
+return ((_a = value) === null || _a === void 0 ? void 0 : _a['_$litDirective$']) !== undefined; };
 /**
  * Retrieves the Directive class for a DirectiveResult
  */
-export const getDirectiveClass = (value) => { var _a; return (_a = value) === null || _a === void 0 ? void 0 : _a._$litDirective$; };
+export const getDirectiveClass = (value) => { var _a; 
+// This property needs to remain unminified.
+return (_a = value) === null || _a === void 0 ? void 0 : _a['_$litDirective$']; };
 /**
  * Tests whether a part has only a single-expression with no strings to
  * interpolate between.
@@ -71,7 +77,8 @@ export const insertPart = (containerPart, refPart, part) => {
     }
     else {
         const endNode = wrap(part._$endNode).nextSibling;
-        const parentChanged = part._$parent !== containerPart;
+        const oldParent = part._$parent;
+        const parentChanged = oldParent !== containerPart;
         if (parentChanged) {
             (_a = part._$reparentDisconnectables) === null || _a === void 0 ? void 0 : _a.call(part, containerPart);
             // Note that although `_$reparentDisconnectables` updates the part's
@@ -79,6 +86,15 @@ export const insertPart = (containerPart, refPart, part) => {
             // method only exists if Disconnectables are present, so we need to
             // unconditionally set it here
             part._$parent = containerPart;
+            // Since the _$isConnected getter is somewhat costly, only
+            // read it once we know the subtree has directives that need
+            // to be notified
+            let newConnectionState;
+            if (part._$notifyConnectionChanged !== undefined &&
+                (newConnectionState = containerPart._$isConnected) !==
+                    oldParent._$isConnected) {
+                part._$notifyConnectionChanged(newConnectionState);
+            }
         }
         if (endNode !== refNode || parentChanged) {
             let start = part._$startNode;
@@ -148,7 +164,7 @@ export const getCommittedValue = (part) => part._$committedValue;
  */
 export const removePart = (part) => {
     var _a;
-    (_a = part._$setChildPartConnected) === null || _a === void 0 ? void 0 : _a.call(part, false, true);
+    (_a = part._$notifyConnectionChanged) === null || _a === void 0 ? void 0 : _a.call(part, false, true);
     let start = part._$startNode;
     const end = wrap(part._$endNode).nextSibling;
     while (start !== end) {

package/front_end/third_party/lit-html/package/development/directive-helpers.js.map

@@ -1 +1 @@
-{"version":3,"file":"directive-helpers.js","sourceRoot":"","sources":["../src/directive-helpers.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n * Copyright 2020 Google LLC\n * SPDX-License-Identifier: BSD-3-Clause\n */\n\nimport {_Σ, Part, DirectiveParent, TemplateResult} from './lit-html.js';\nimport {\n  DirectiveResult,\n  DirectiveClass,\n  PartInfo,\n  AttributePartInfo,\n} from './directive.js';\ntype Primitive = null | undefined | boolean | number | string | symbol | bigint;\n\nconst {_ChildPart: ChildPart} = _Σ;\n\ntype ChildPart = InstanceType<typeof ChildPart>;\n\nconst ENABLE_SHADYDOM_NOPATCH = true;\n\nconst wrap =\n  ENABLE_SHADYDOM_NOPATCH &&\n  window.ShadyDOM?.inUse &&\n  window.ShadyDOM?.noPatch === true\n    ? window.ShadyDOM!.wrap\n    : (node: Node) => node;\n\n/**\n * Tests if a value is a primitive value.\n *\n * See https://tc39.github.io/ecma262/#sec-typeof-operator\n */\nexport const isPrimitive = (value: unknown): value is Primitive =>\n  value === null || (typeof value != 'object' && typeof value != 'function');\n\nexport const TemplateResultType = {\n  HTML: 1,\n  SVG: 2,\n} as const;\n\nexport type TemplateResultType = typeof TemplateResultType[keyof typeof TemplateResultType];\n\n/**\n * Tests if a value is a TemplateResult.\n */\nexport const isTemplateResult = (\n  value: unknown,\n  type?: TemplateResultType\n): value is TemplateResult =>\n  type === undefined\n    ? (value as TemplateResult)?._$litType$ !== undefined\n    : (value as TemplateResult)?._$litType$ === type;\n\n/**\n * Tests if a value is a DirectiveResult.\n */\nexport const isDirectiveResult = (value: unknown): value is DirectiveResult =>\n  (value as DirectiveResult)?._$litDirective$ !== undefined;\n\n/**\n * Retrieves the Directive class for a DirectiveResult\n */\nexport const getDirectiveClass = (value: unknown): DirectiveClass | undefined =>\n  (value as DirectiveResult)?._$litDirective$;\n\n/**\n * Tests whether a part has only a single-expression with no strings to\n * interpolate between.\n *\n * Only AttributePart and PropertyPart can have multiple expressions.\n * Multi-expression parts have a `strings` property and single-expression\n * parts do not.\n */\nexport const isSingleExpression = (part: PartInfo) =>\n  (part as AttributePartInfo).strings === undefined;\n\nconst createMarker = () => document.createComment('');\n\n/**\n * Inserts a ChildPart into the given container ChildPart's DOM, either at the\n * end of the container ChildPart, or before the optional `refPart`.\n *\n * This does not add the part to the containerPart's committed value. That must\n * be done by callers.\n *\n * @param containerPart Part within which to add the new ChildPart\n * @param refPart Part before which to add the new ChildPart; when omitted the\n *     part added to the end of the `containerPart`\n * @param part Part to insert, or undefined to create a new part\n */\nexport const insertPart = (\n  containerPart: ChildPart,\n  refPart?: ChildPart,\n  part?: ChildPart\n): ChildPart => {\n  const container = wrap(containerPart._$startNode).parentNode!;\n\n  const refNode =\n    refPart === undefined ? containerPart._$endNode : refPart._$startNode;\n\n  if (part === undefined) {\n    const startNode = wrap(container).insertBefore(createMarker(), refNode);\n    const endNode = wrap(container).insertBefore(createMarker(), refNode);\n    part = new ChildPart(\n      startNode,\n      endNode,\n      containerPart,\n      containerPart.options\n    );\n  } else {\n    const endNode = wrap(part._$endNode!).nextSibling;\n    const parentChanged = part._$parent !== containerPart;\n    if (parentChanged) {\n      part._$reparentDisconnectables?.(containerPart);\n      // Note that although `_$reparentDisconnectables` updates the part's\n      // `_$parent` reference after unlinking from its current parent, that\n      // method only exists if Disconnectables are present, so we need to\n      // unconditionally set it here\n      part._$parent = containerPart;\n    }\n    if (endNode !== refNode || parentChanged) {\n      let start: Node | null = part._$startNode;\n      while (start !== endNode) {\n        const n: Node | null = wrap(start!).nextSibling;\n        wrap(container).insertBefore(start!, refNode);\n        start = n;\n      }\n    }\n  }\n\n  return part;\n};\n\n/**\n * Sets the value of a Part.\n *\n * Note that this should only be used to set/update the value of user-created\n * parts (i.e. those created using `insertPart`); it should not be used\n * by directives to set the value of the directive's container part. Directives\n * should return a value from `update`/`render` to update their part state.\n *\n * For directives that require setting their part value asynchronously, they\n * should extend `AsyncDirective` and call `this.setValue()`.\n *\n * @param part Part to set\n * @param value Value to set\n * @param index For `AttributePart`s, the index to set\n * @param directiveParent Used internally; should not be set by user\n */\nexport const setChildPartValue = <T extends ChildPart>(\n  part: T,\n  value: unknown,\n  directiveParent: DirectiveParent = part\n): T => {\n  part._$setValue(value, directiveParent);\n  return part;\n};\n\n// A sentinal value that can never appear as a part value except when set by\n// live(). Used to force a dirty-check to fail and cause a re-render.\nconst RESET_VALUE = {};\n\n/**\n * Sets the committed value of a ChildPart directly without triggering the\n * commit stage of the part.\n *\n * This is useful in cases where a directive needs to update the part such\n * that the next update detects a value change or not. When value is omitted,\n * the next update will be guaranteed to be detected as a change.\n *\n * @param part\n * @param value\n */\nexport const setCommittedValue = (part: Part, value: unknown = RESET_VALUE) =>\n  (part._$committedValue = value);\n\n/**\n * Returns the committed value of a ChildPart.\n *\n * The committed value is used for change detection and efficient updates of\n * the part. It can differ from the value set by the template or directive in\n * cases where the template value is transformed before being commited.\n *\n * - `TemplateResult`s are committed as a `TemplateInstance`\n * - Iterables are committed as `Array<ChildPart>`\n * - All other types are committed as the template value or value returned or\n *   set by a directive.\n *\n * @param part\n */\nexport const getCommittedValue = (part: ChildPart) => part._$committedValue;\n\n/**\n * Removes a ChildPart from the DOM, including any of its content.\n *\n * @param part The Part to remove\n */\nexport const removePart = (part: ChildPart) => {\n  part._$setChildPartConnected?.(false, true);\n  let start: ChildNode | null = part._$startNode;\n  const end: ChildNode | null = wrap(part._$endNode!).nextSibling;\n  while (start !== end) {\n    const n: ChildNode | null = wrap(start!).nextSibling;\n    (wrap(start!) as ChildNode).remove();\n    start = n;\n  }\n};\n\nexport const clearPart = (part: ChildPart) => {\n  part._$clear();\n};\n"]}
+{"version":3,"file":"directive-helpers.js","sourceRoot":"","sources":["../src/directive-helpers.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n * Copyright 2020 Google LLC\n * SPDX-License-Identifier: BSD-3-Clause\n */\n\nimport {_$LH, Part, DirectiveParent, TemplateResult} from './lit-html.js';\nimport {\n  DirectiveResult,\n  DirectiveClass,\n  PartInfo,\n  AttributePartInfo,\n} from './directive.js';\ntype Primitive = null | undefined | boolean | number | string | symbol | bigint;\n\nconst {_ChildPart: ChildPart} = _$LH;\n\ntype ChildPart = InstanceType<typeof ChildPart>;\n\nconst ENABLE_SHADYDOM_NOPATCH = true;\n\nconst wrap =\n  ENABLE_SHADYDOM_NOPATCH &&\n  window.ShadyDOM?.inUse &&\n  window.ShadyDOM?.noPatch === true\n    ? window.ShadyDOM!.wrap\n    : (node: Node) => node;\n\n/**\n * Tests if a value is a primitive value.\n *\n * See https://tc39.github.io/ecma262/#sec-typeof-operator\n */\nexport const isPrimitive = (value: unknown): value is Primitive =>\n  value === null || (typeof value != 'object' && typeof value != 'function');\n\nexport const TemplateResultType = {\n  HTML: 1,\n  SVG: 2,\n} as const;\n\nexport type TemplateResultType =\n  typeof TemplateResultType[keyof typeof TemplateResultType];\n\n/**\n * Tests if a value is a TemplateResult.\n */\nexport const isTemplateResult = (\n  value: unknown,\n  type?: TemplateResultType\n): value is TemplateResult =>\n  type === undefined\n    ? // This property needs to remain unminified.\n      (value as TemplateResult)?.['_$litType$'] !== undefined\n    : (value as TemplateResult)?.['_$litType$'] === type;\n\n/**\n * Tests if a value is a DirectiveResult.\n */\nexport const isDirectiveResult = (value: unknown): value is DirectiveResult =>\n  // This property needs to remain unminified.\n  (value as DirectiveResult)?.['_$litDirective$'] !== undefined;\n\n/**\n * Retrieves the Directive class for a DirectiveResult\n */\nexport const getDirectiveClass = (value: unknown): DirectiveClass | undefined =>\n  // This property needs to remain unminified.\n  (value as DirectiveResult)?.['_$litDirective$'];\n\n/**\n * Tests whether a part has only a single-expression with no strings to\n * interpolate between.\n *\n * Only AttributePart and PropertyPart can have multiple expressions.\n * Multi-expression parts have a `strings` property and single-expression\n * parts do not.\n */\nexport const isSingleExpression = (part: PartInfo) =>\n  (part as AttributePartInfo).strings === undefined;\n\nconst createMarker = () => document.createComment('');\n\n/**\n * Inserts a ChildPart into the given container ChildPart's DOM, either at the\n * end of the container ChildPart, or before the optional `refPart`.\n *\n * This does not add the part to the containerPart's committed value. That must\n * be done by callers.\n *\n * @param containerPart Part within which to add the new ChildPart\n * @param refPart Part before which to add the new ChildPart; when omitted the\n *     part added to the end of the `containerPart`\n * @param part Part to insert, or undefined to create a new part\n */\nexport const insertPart = (\n  containerPart: ChildPart,\n  refPart?: ChildPart,\n  part?: ChildPart\n): ChildPart => {\n  const container = wrap(containerPart._$startNode).parentNode!;\n\n  const refNode =\n    refPart === undefined ? containerPart._$endNode : refPart._$startNode;\n\n  if (part === undefined) {\n    const startNode = wrap(container).insertBefore(createMarker(), refNode);\n    const endNode = wrap(container).insertBefore(createMarker(), refNode);\n    part = new ChildPart(\n      startNode,\n      endNode,\n      containerPart,\n      containerPart.options\n    );\n  } else {\n    const endNode = wrap(part._$endNode!).nextSibling;\n    const oldParent = part._$parent;\n    const parentChanged = oldParent !== containerPart;\n    if (parentChanged) {\n      part._$reparentDisconnectables?.(containerPart);\n      // Note that although `_$reparentDisconnectables` updates the part's\n      // `_$parent` reference after unlinking from its current parent, that\n      // method only exists if Disconnectables are present, so we need to\n      // unconditionally set it here\n      part._$parent = containerPart;\n      // Since the _$isConnected getter is somewhat costly, only\n      // read it once we know the subtree has directives that need\n      // to be notified\n      let newConnectionState;\n      if (\n        part._$notifyConnectionChanged !== undefined &&\n        (newConnectionState = containerPart._$isConnected) !==\n          oldParent!._$isConnected\n      ) {\n        part._$notifyConnectionChanged(newConnectionState);\n      }\n    }\n    if (endNode !== refNode || parentChanged) {\n      let start: Node | null = part._$startNode;\n      while (start !== endNode) {\n        const n: Node | null = wrap(start!).nextSibling;\n        wrap(container).insertBefore(start!, refNode);\n        start = n;\n      }\n    }\n  }\n\n  return part;\n};\n\n/**\n * Sets the value of a Part.\n *\n * Note that this should only be used to set/update the value of user-created\n * parts (i.e. those created using `insertPart`); it should not be used\n * by directives to set the value of the directive's container part. Directives\n * should return a value from `update`/`render` to update their part state.\n *\n * For directives that require setting their part value asynchronously, they\n * should extend `AsyncDirective` and call `this.setValue()`.\n *\n * @param part Part to set\n * @param value Value to set\n * @param index For `AttributePart`s, the index to set\n * @param directiveParent Used internally; should not be set by user\n */\nexport const setChildPartValue = <T extends ChildPart>(\n  part: T,\n  value: unknown,\n  directiveParent: DirectiveParent = part\n): T => {\n  part._$setValue(value, directiveParent);\n  return part;\n};\n\n// A sentinal value that can never appear as a part value except when set by\n// live(). Used to force a dirty-check to fail and cause a re-render.\nconst RESET_VALUE = {};\n\n/**\n * Sets the committed value of a ChildPart directly without triggering the\n * commit stage of the part.\n *\n * This is useful in cases where a directive needs to update the part such\n * that the next update detects a value change or not. When value is omitted,\n * the next update will be guaranteed to be detected as a change.\n *\n * @param part\n * @param value\n */\nexport const setCommittedValue = (part: Part, value: unknown = RESET_VALUE) =>\n  (part._$committedValue = value);\n\n/**\n * Returns the committed value of a ChildPart.\n *\n * The committed value is used for change detection and efficient updates of\n * the part. It can differ from the value set by the template or directive in\n * cases where the template value is transformed before being commited.\n *\n * - `TemplateResult`s are committed as a `TemplateInstance`\n * - Iterables are committed as `Array<ChildPart>`\n * - All other types are committed as the template value or value returned or\n *   set by a directive.\n *\n * @param part\n */\nexport const getCommittedValue = (part: ChildPart) => part._$committedValue;\n\n/**\n * Removes a ChildPart from the DOM, including any of its content.\n *\n * @param part The Part to remove\n */\nexport const removePart = (part: ChildPart) => {\n  part._$notifyConnectionChanged?.(false, true);\n  let start: ChildNode | null = part._$startNode;\n  const end: ChildNode | null = wrap(part._$endNode!).nextSibling;\n  while (start !== end) {\n    const n: ChildNode | null = wrap(start!).nextSibling;\n    (wrap(start!) as ChildNode).remove();\n    start = n;\n  }\n};\n\nexport const clearPart = (part: ChildPart) => {\n  part._$clear();\n};\n"]}