{
  "version": 3,
  "sources": ["../../node_modules/lit-html/src/directive.ts", "../../node_modules/lit-html/src/directive-helpers.ts", "../../node_modules/lit-html/src/async-directive.ts", "../../node_modules/@open-wc/lit-helpers/src/spread.ts"],
  "sourcesContent": ["/**\n * @license\n * Copyright 2017 Google LLC\n * SPDX-License-Identifier: BSD-3-Clause\n */\n\nimport {Disconnectable, Part} from './lit-html.js';\n\nexport {\n  AttributePart,\n  BooleanAttributePart,\n  ChildPart,\n  ElementPart,\n  EventPart,\n  Part,\n  PropertyPart,\n} from './lit-html.js';\n\nexport interface DirectiveClass {\n  new (part: PartInfo): Directive;\n}\n\n/**\n * This utility type extracts the signature of a directive class's render()\n * method so we can use it for the type of the generated directive function.\n */\nexport type DirectiveParameters<C extends Directive> = Parameters<C['render']>;\n\n/**\n * A generated directive function doesn't evaluate the directive, but just\n * returns a DirectiveResult object that captures the arguments.\n */\nexport interface DirectiveResult<C extends DirectiveClass = DirectiveClass> {\n  /**\n   * This property needs to remain unminified.\n   * @internal\n   */\n  ['_$litDirective$']: C;\n  /** @internal */\n  values: DirectiveParameters<InstanceType<C>>;\n}\n\nexport const PartType = {\n  ATTRIBUTE: 1,\n  CHILD: 2,\n  PROPERTY: 3,\n  BOOLEAN_ATTRIBUTE: 4,\n  EVENT: 5,\n  ELEMENT: 6,\n} as const;\n\nexport type PartType = (typeof PartType)[keyof typeof PartType];\n\nexport interface ChildPartInfo {\n  readonly type: typeof PartType.CHILD;\n}\n\nexport interface AttributePartInfo {\n  readonly type:\n    | typeof PartType.ATTRIBUTE\n    | typeof PartType.PROPERTY\n    | typeof PartType.BOOLEAN_ATTRIBUTE\n    | typeof PartType.EVENT;\n  readonly strings?: ReadonlyArray<string>;\n  readonly name: string;\n  readonly tagName: string;\n}\n\nexport interface ElementPartInfo {\n  readonly type: typeof PartType.ELEMENT;\n}\n\n/**\n * Information about the part a directive is bound to.\n *\n * This is useful for checking that a directive is attached to a valid part,\n * such as with directive that can only be used on attribute bindings.\n */\nexport type PartInfo = ChildPartInfo | AttributePartInfo | ElementPartInfo;\n\n/**\n * Creates a user-facing directive function from a Directive class. This\n * function has the same parameters as the directive's render() method.\n */\nexport const directive =\n  <C extends DirectiveClass>(c: C) =>\n  (...values: DirectiveParameters<InstanceType<C>>): DirectiveResult<C> => ({\n    // This property needs to remain unminified.\n    ['_$litDirective$']: c,\n    values,\n  });\n\n/**\n * Base class for creating custom directives. Users should extend this class,\n * implement `render` and/or `update`, and then pass their subclass to\n * `directive`.\n */\nexport abstract class Directive implements Disconnectable {\n  //@internal\n  __part!: Part;\n  //@internal\n  __attributeIndex: number | undefined;\n  //@internal\n  __directive?: Directive;\n\n  //@internal\n  _$parent!: Disconnectable;\n\n  // These will only exist on the AsyncDirective subclass\n  //@internal\n  _$disconnectableChildren?: Set<Disconnectable>;\n  // This property needs to remain unminified.\n  //@internal\n  ['_$notifyDirectiveConnectionChanged']?(isConnected: boolean): void;\n\n  constructor(_partInfo: PartInfo) {}\n\n  // See comment in Disconnectable interface for why this is a getter\n  get _$isConnected() {\n    return this._$parent._$isConnected;\n  }\n\n  /** @internal */\n  _$initialize(\n    part: Part,\n    parent: Disconnectable,\n    attributeIndex: number | undefined,\n  ) {\n    this.__part = part;\n    this._$parent = parent;\n    this.__attributeIndex = attributeIndex;\n  }\n  /** @internal */\n  _$resolve(part: Part, props: Array<unknown>): unknown {\n    return this.update(part, props);\n  }\n\n  abstract render(...props: Array<unknown>): unknown;\n\n  update(_part: Part, props: Array<unknown>): unknown {\n    return this.render(...props);\n  }\n}\n", "/**\n * @license\n * Copyright 2020 Google LLC\n * SPDX-License-Identifier: BSD-3-Clause\n */\n\nimport {\n  _$LH,\n  Part,\n  DirectiveParent,\n  CompiledTemplateResult,\n  MaybeCompiledTemplateResult,\n  UncompiledTemplateResult,\n} 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  MATHML: 3,\n} as const;\n\nexport type TemplateResultType =\n  (typeof TemplateResultType)[keyof typeof TemplateResultType];\n\ntype IsTemplateResult = {\n  (val: unknown): val is MaybeCompiledTemplateResult;\n  <T extends TemplateResultType>(\n    val: unknown,\n    type: T,\n  ): val is UncompiledTemplateResult<T>;\n};\n\n/**\n * Tests if a value is a TemplateResult or a CompiledTemplateResult.\n */\nexport const isTemplateResult: IsTemplateResult = (\n  value: unknown,\n  type?: TemplateResultType,\n): value is UncompiledTemplateResult =>\n  type === undefined\n    ? // This property needs to remain unminified.\n      (value as UncompiledTemplateResult)?.['_$litType$'] !== undefined\n    : (value as UncompiledTemplateResult)?.['_$litType$'] === type;\n\n/**\n * Tests if a value is a CompiledTemplateResult.\n */\nexport const isCompiledTemplateResult = (\n  value: unknown,\n): value is CompiledTemplateResult => {\n  return (value as CompiledTemplateResult)?.['_$litType$']?.h != null;\n};\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 sentinel 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 committed.\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", "/**\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", null],
  "mappings": "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",
  "names": ["PartType", "ATTRIBUTE", "CHILD", "PROPERTY", "BOOLEAN_ATTRIBUTE", "EVENT", "ELEMENT", "directive", "c", "values", "_$litDirective$", "Directive", "_partInfo", "_$isConnected", "this", "_$parent", "part", "parent", "attributeIndex", "__part", "__attributeIndex", "props", "update", "_part", "render", "_ChildPart", "ChildPart", "_$LH", "isPrimitive", "value", "TemplateResultType", "HTML", "SVG", "MATHML", "isTemplateResult", "type", "isCompiledTemplateResult", "h", "getDirectiveClass", "value", "isSingleExpression", "part", "strings", "notifyChildrenConnectedChanged", "parent", "isConnected", "children", "_$disconnectableChildren", "obj", "removeDisconnectableFromParent", "_$parent", "delete", "size", "addDisconnectableToParent", "Set", "has", "add", "installDisconnectAPI", "reparentDisconnectables", "newParent", "this", "notifyChildPartConnectedChanged", "isClearingValue", "fromPartIndex", "value", "_$committedValue", "Array", "isArray", "i", "length", "type", "PartType", "CHILD", "_$notifyConnectionChanged", "_$reparentDisconnectables", "AsyncDirective", "Directive", "constructor", "part", "attributeIndex", "super", "_$initialize", "_$isConnected", "isClearingDirective", "reconnected", "disconnected", "isSingleExpression", "__part", "_$setValue", "newValues", "__attributeIndex", "SpreadPropsDirective", "$t", "_spreadData", "D", "part", "spreadData", "_a", "data", "prevData", "element", "key", "value", "spreadProps", "e", "SpreadEventsDirective", "eventName", "eventValue", "event", "eventData", "name", "spreadEvents", "SpreadDirective", "spread"]
}