@thegetty/quire-cli 1.0.0-pre-release.0 → 1.0.0-pre-release.2

package/src/lib/quire/versions/1.0.0-pre-release.2/node_modules/lit-html/development/async-directive.js

@@ -1,246 +0,0 @@
-/**
- * @license
- * Copyright 2017 Google LLC
- * SPDX-License-Identifier: BSD-3-Clause
- */
-import { isSingleExpression } from './directive-helpers.js';
-import { Directive, PartType } from './directive.js';
-export * from './directive.js';
-const DEV_MODE = true;
-/**
- * Recursively walks down the tree of Parts/TemplateInstances/Directives to set
- * the connected state of directives and run `disconnected`/ `reconnected`
- * callbacks.
- *
- * @return True if there were children to disconnect; false otherwise
- */
-const notifyChildrenConnectedChanged = (parent, isConnected) => {
-    var _a, _b;
-    const children = parent._$disconnectableChildren;
-    if (children === undefined) {
-        return false;
-    }
-    for (const obj of children) {
-        // 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
-        // `_$notifyConnectionChanged`, which exists `ChildParts` which are also in
-        // this list
-        // Disconnect Directive (and any nested directives contained within)
-        // This property needs to remain unminified.
-        (_b = (_a = obj)['_$notifyDirectiveConnectionChanged']) === null || _b === void 0 ? void 0 : _b.call(_a, isConnected, false);
-        // Disconnect Part/TemplateInstance
-        notifyChildrenConnectedChanged(obj, isConnected);
-    }
-    return true;
-};
-/**
- * Removes the given child from its parent list of disconnectable children, and
- * if the parent list becomes empty as a result, removes the parent from its
- * parent, and so forth up the tree when that causes subsequent parent lists to
- * become empty.
- */
-const removeDisconnectableFromParent = (obj) => {
-    let parent, children;
-    do {
-        if ((parent = obj._$parent) === undefined) {
-            break;
-        }
-        children = parent._$disconnectableChildren;
-        children.delete(obj);
-        obj = parent;
-    } while ((children === null || children === void 0 ? void 0 : children.size) === 0);
-};
-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._$disconnectableChildren;
-        if (children === undefined) {
-            parent._$disconnectableChildren = children = new Set();
-        }
-        else if (children.has(obj)) {
-            // Once we've reached a parent that already contains this child, we
-            // can short-circuit
-            break;
-        }
-        children.add(obj);
-        installDisconnectAPI(parent);
-    }
-};
-/**
- * Changes the parent reference of the ChildPart, and updates the sparse tree of
- * Disconnectable children accordingly.
- *
- * Note, this method will be patched onto ChildPart instances and called from
- * the core code when parts are moved between different parents.
- */
-function reparentDisconnectables(newParent) {
-    if (this._$disconnectableChildren !== undefined) {
-        removeDisconnectableFromParent(this);
-        this._$parent = newParent;
-        addDisconnectableToParent(this);
-    }
-    else {
-        this._$parent = newParent;
-    }
-}
-/**
- * Sets the connected state on any directives contained within the committed
- * value of this part (i.e. within a TemplateInstance or iterable of
- * ChildParts) and runs their `disconnected`/`reconnected`s, as well as within
- * any directives stored on the ChildPart (when `valueOnly` is false).
- *
- * `isClearingValue` should be passed as `true` on a top-level part that is
- * clearing itself, and not as a result of recursively disconnecting directives
- * as part of a `clear` operation higher up the tree. This both ensures that any
- * directive on this ChildPart that produced a value that caused the clear
- * operation is not disconnected, and also serves as a performance optimization
- * to avoid needless bookkeeping when a subtree is going away; when clearing a
- * subtree, only the top-most part need to remove itself from the parent.
- *
- * `fromPartIndex` is passed only in the case of a partial `_clear` running as a
- * result of truncating an iterable.
- *
- * Note, this method will be patched onto ChildPart instances and called from the
- * core code when parts are cleared or the connection state is changed by the
- * user.
- */
-function notifyChildPartConnectedChanged(isConnected, isClearingValue = false, fromPartIndex = 0) {
-    const value = this._$committedValue;
-    const children = this._$disconnectableChildren;
-    if (children === undefined || children.size === 0) {
-        return;
-    }
-    if (isClearingValue) {
-        if (Array.isArray(value)) {
-            // Iterable case: Any ChildParts created by the iterable should be
-            // 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++) {
-                notifyChildrenConnectedChanged(value[i], false);
-                removeDisconnectableFromParent(value[i]);
-            }
-        }
-        else if (value != null) {
-            // 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
-            notifyChildrenConnectedChanged(value, false);
-            removeDisconnectableFromParent(value);
-        }
-    }
-    else {
-        notifyChildrenConnectedChanged(this, isConnected);
-    }
-}
-/**
- * Patches disconnection API onto ChildParts.
- */
-const installDisconnectAPI = (obj) => {
-    var _a, _b;
-    var _c, _d;
-    if (obj.type == PartType.CHILD) {
-        (_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.setConnected(false)` on
- * a part that was previously rendered containing the directive (as happens
- * when e.g. a LitElement disconnects from the DOM).
- *
- * If `part.setConnected(true)` is subsequently called on a
- * containing part, the directive's `reconnected` method will be called prior
- * to its next `update`/`render` callbacks. When implementing `disconnected`,
- * `reconnected` should also be implemented to be compatible with reconnection.
- *
- * Note that updates may occur while the directive is disconnected. As such,
- * directives should generally check the `this.isConnected` flag during
- * render/update to determine whether it is safe to subscribe to resources
- * that may prevent garbage collection.
- */
-export class AsyncDirective extends Directive {
-    constructor() {
-        super(...arguments);
-        // @internal
-        this._$disconnectableChildren = undefined;
-    }
-    /**
-     * Initialize the part with internal fields
-     * @param part
-     * @param parent
-     * @param attributeIndex
-     */
-    _$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
-     * `setChildrenConnected` helper function when recursively changing the
-     * connection state of a tree (in which case `shouldRemoveFromParent` should
-     * be false).
-     *
-     * @param isConnected
-     * @param isClearingDirective - True when the directive itself is being
-     *     removed; false when the tree is being disconnected
-     * @internal
-     */
-    ['_$notifyDirectiveConnectionChanged'](isConnected, isClearingDirective = true) {
-        var _a, _b;
-        if (isConnected !== this.isConnected) {
-            this.isConnected = isConnected;
-            if (isConnected) {
-                (_a = this.reconnected) === null || _a === void 0 ? void 0 : _a.call(this);
-            }
-            else {
-                (_b = this.disconnected) === null || _b === void 0 ? void 0 : _b.call(this);
-            }
-        }
-        if (isClearingDirective) {
-            notifyChildrenConnectedChanged(this, isConnected);
-            removeDisconnectableFromParent(this);
-        }
-    }
-    /**
-     * Sets the value of the directive's Part outside the normal `update`/`render`
-     * lifecycle of a directive.
-     *
-     * This method should not be called synchronously from a directive's `update`
-     * or `render`.
-     *
-     * @param directive The directive to update
-     * @param value The value to set
-     */
-    setValue(value) {
-        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);
-        }
-    }
-    /**
-     * User callbacks for implementing logic to release any resources/subscriptions
-     * that may have been retained by this directive. Since directives may also be
-     * re-connected, `reconnected` should also be implemented to restore the
-     * working state of the directive prior to the next render.
-     */
-    disconnected() { }
-    reconnected() { }
-}
-//# sourceMappingURL=async-directive.js.map

package/src/lib/quire/versions/1.0.0-pre-release.2/node_modules/lit-html/development/async-directive.js.map

@@ -1 +0,0 @@
-{"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 * `isConnected: 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 * 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/src/lib/quire/versions/1.0.0-pre-release.2/node_modules/lit-html/development/directive-helpers.d.ts

@@ -1,106 +0,0 @@
-/**
- * @license
- * Copyright 2020 Google LLC
- * SPDX-License-Identifier: BSD-3-Clause
- */
-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 Primitive;
-export declare const TemplateResultType: {
-    readonly HTML: 1;
-    readonly SVG: 2;
-};
-export declare type TemplateResultType = typeof TemplateResultType[keyof typeof TemplateResultType];
-/**
- * Tests if a value is a TemplateResult.
- */
-export declare const isTemplateResult: (value: unknown, type?: TemplateResultType) => value is TemplateResult<1 | 2>;
-/**
- * Tests if a value is a DirectiveResult.
- */
-export declare const isDirectiveResult: (value: unknown) => value is DirectiveResult<DirectiveClass>;
-/**
- * Retrieves the Directive class for a DirectiveResult
- */
-export declare const getDirectiveClass: (value: unknown) => DirectiveClass | undefined;
-/**
- * Tests whether a part has only a single-expression with no strings to
- * interpolate between.
- *
- * Only AttributePart and PropertyPart can have multiple expressions.
- * Multi-expression parts have a `strings` property and single-expression
- * parts do not.
- */
-export declare const isSingleExpression: (part: PartInfo) => boolean;
-/**
- * Inserts a ChildPart into the given container ChildPart's DOM, either at the
- * end of the container ChildPart, or before the optional `refPart`.
- *
- * This does not add the part to the containerPart's committed value. That must
- * be done by callers.
- *
- * @param containerPart Part within which to add the new ChildPart
- * @param refPart Part before which to add the new ChildPart; when omitted the
- *     part added to the end of the `containerPart`
- * @param part Part to insert, or undefined to create a new part
- */
-export declare const insertPart: (containerPart: import("./lit-html.js").ChildPart, refPart?: import("./lit-html.js").ChildPart | undefined, part?: import("./lit-html.js").ChildPart | undefined) => import("./lit-html.js").ChildPart;
-/**
- * Sets the value of a Part.
- *
- * Note that this should only be used to set/update the value of user-created
- * parts (i.e. those created using `insertPart`); it should not be used
- * by directives to set the value of the directive's container part. Directives
- * should return a value from `update`/`render` to update their part state.
- *
- * For directives that require setting their part value asynchronously, they
- * should extend `AsyncDirective` and call `this.setValue()`.
- *
- * @param part Part to set
- * @param value Value to set
- * @param index For `AttributePart`s, the index to set
- * @param directiveParent Used internally; should not be set by user
- */
-export declare const setChildPartValue: <T extends import("./lit-html.js").ChildPart>(part: T, value: unknown, directiveParent?: DirectiveParent) => T;
-/**
- * Sets the committed value of a ChildPart directly without triggering the
- * commit stage of the part.
- *
- * This is useful in cases where a directive needs to update the part such
- * that the next update detects a value change or not. When value is omitted,
- * the next update will be guaranteed to be detected as a change.
- *
- * @param part
- * @param value
- */
-export declare const setCommittedValue: (part: Part, value?: unknown) => unknown;
-/**
- * Returns the committed value of a ChildPart.
- *
- * The committed value is used for change detection and efficient updates of
- * the part. It can differ from the value set by the template or directive in
- * cases where the template value is transformed before being commited.
- *
- * - `TemplateResult`s are committed as a `TemplateInstance`
- * - Iterables are committed as `Array<ChildPart>`
- * - All other types are committed as the template value or value returned or
- *   set by a directive.
- *
- * @param part
- */
-export declare const getCommittedValue: (part: import("./lit-html.js").ChildPart) => unknown;
-/**
- * Removes a ChildPart from the DOM, including any of its content.
- *
- * @param part The Part to remove
- */
-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/src/lib/quire/versions/1.0.0-pre-release.2/node_modules/lit-html/development/directive-helpers.d.ts.map

@@ -1 +0,0 @@
-{"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,SACP,kBAAkB,mCAK6B,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/src/lib/quire/versions/1.0.0-pre-release.2/node_modules/lit-html/development/directive-helpers.js

@@ -1,176 +0,0 @@
-/**
- * @license
- * Copyright 2020 Google LLC
- * SPDX-License-Identifier: BSD-3-Clause
- */
-var _a, _b;
-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) &&
-    ((_b = window.ShadyDOM) === null || _b === void 0 ? void 0 : _b.noPatch) === true
-    ? window.ShadyDOM.wrap
-    : (node) => node;
-/**
- * Tests if a value is a primitive value.
- *
- * See https://tc39.github.io/ecma262/#sec-typeof-operator
- */
-export const isPrimitive = (value) => value === null || (typeof value != 'object' && typeof value != 'function');
-export const TemplateResultType = {
-    HTML: 1,
-    SVG: 2,
-};
-/**
- * Tests if a value is a TemplateResult.
- */
-export const isTemplateResult = (value, type) => type === undefined
-    ? // This property needs to remain unminified.
-        (value === null || value === void 0 ? void 0 : value['_$litType$']) !== undefined
-    : (value === null || value === void 0 ? void 0 : value['_$litType$']) === type;
-/**
- * Tests if a value is a DirectiveResult.
- */
-export const isDirectiveResult = (value) => 
-// This property needs to remain unminified.
-(value === null || value === void 0 ? void 0 : value['_$litDirective$']) !== undefined;
-/**
- * Retrieves the Directive class for a DirectiveResult
- */
-export const getDirectiveClass = (value) => 
-// This property needs to remain unminified.
-value === null || value === void 0 ? void 0 : value['_$litDirective$'];
-/**
- * Tests whether a part has only a single-expression with no strings to
- * interpolate between.
- *
- * Only AttributePart and PropertyPart can have multiple expressions.
- * Multi-expression parts have a `strings` property and single-expression
- * parts do not.
- */
-export const isSingleExpression = (part) => part.strings === undefined;
-const createMarker = () => document.createComment('');
-/**
- * Inserts a ChildPart into the given container ChildPart's DOM, either at the
- * end of the container ChildPart, or before the optional `refPart`.
- *
- * This does not add the part to the containerPart's committed value. That must
- * be done by callers.
- *
- * @param containerPart Part within which to add the new ChildPart
- * @param refPart Part before which to add the new ChildPart; when omitted the
- *     part added to the end of the `containerPart`
- * @param part Part to insert, or undefined to create a new part
- */
-export const insertPart = (containerPart, refPart, part) => {
-    var _a;
-    const container = wrap(containerPart._$startNode).parentNode;
-    const refNode = refPart === undefined ? containerPart._$endNode : refPart._$startNode;
-    if (part === undefined) {
-        const startNode = wrap(container).insertBefore(createMarker(), refNode);
-        const endNode = wrap(container).insertBefore(createMarker(), refNode);
-        part = new ChildPart(startNode, endNode, containerPart, containerPart.options);
-    }
-    else {
-        const endNode = wrap(part._$endNode).nextSibling;
-        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
-            // `_$parent` reference after unlinking from its current parent, that
-            // 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;
-            while (start !== endNode) {
-                const n = wrap(start).nextSibling;
-                wrap(container).insertBefore(start, refNode);
-                start = n;
-            }
-        }
-    }
-    return part;
-};
-/**
- * Sets the value of a Part.
- *
- * Note that this should only be used to set/update the value of user-created
- * parts (i.e. those created using `insertPart`); it should not be used
- * by directives to set the value of the directive's container part. Directives
- * should return a value from `update`/`render` to update their part state.
- *
- * For directives that require setting their part value asynchronously, they
- * should extend `AsyncDirective` and call `this.setValue()`.
- *
- * @param part Part to set
- * @param value Value to set
- * @param index For `AttributePart`s, the index to set
- * @param directiveParent Used internally; should not be set by user
- */
-export const setChildPartValue = (part, value, directiveParent = part) => {
-    part._$setValue(value, directiveParent);
-    return part;
-};
-// A sentinal value that can never appear as a part value except when set by
-// live(). Used to force a dirty-check to fail and cause a re-render.
-const RESET_VALUE = {};
-/**
- * Sets the committed value of a ChildPart directly without triggering the
- * commit stage of the part.
- *
- * This is useful in cases where a directive needs to update the part such
- * that the next update detects a value change or not. When value is omitted,
- * the next update will be guaranteed to be detected as a change.
- *
- * @param part
- * @param value
- */
-export const setCommittedValue = (part, value = RESET_VALUE) => (part._$committedValue = value);
-/**
- * Returns the committed value of a ChildPart.
- *
- * The committed value is used for change detection and efficient updates of
- * the part. It can differ from the value set by the template or directive in
- * cases where the template value is transformed before being commited.
- *
- * - `TemplateResult`s are committed as a `TemplateInstance`
- * - Iterables are committed as `Array<ChildPart>`
- * - All other types are committed as the template value or value returned or
- *   set by a directive.
- *
- * @param part
- */
-export const getCommittedValue = (part) => part._$committedValue;
-/**
- * Removes a ChildPart from the DOM, including any of its content.
- *
- * @param part The Part to remove
- */
-export const removePart = (part) => {
-    var _a;
-    (_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) {
-        const n = wrap(start).nextSibling;
-        wrap(start).remove();
-        start = n;
-    }
-};
-export const clearPart = (part) => {
-    part._$clear();
-};
-//# sourceMappingURL=directive-helpers.js.map

package/src/lib/quire/versions/1.0.0-pre-release.2/node_modules/lit-html/development/directive-helpers.js.map

@@ -1 +0,0 @@
-{"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"]}