chrome-devtools-frontend 1.0.943986 → 1.0.945579

package/front_end/third_party/lit-html/package/directives/async-replace.d.ts

@@ -3,18 +3,17 @@
  * Copyright 2017 Google LLC
  * SPDX-License-Identifier: BSD-3-Clause
  */
-import { AsyncDirective } from '../async-directive.js';
-import { DirectiveParameters } from '../directive.js';
 import { ChildPart, noChange } from '../lit-html.js';
-
+import { DirectiveParameters } from '../directive.js';
+import { AsyncDirective } from '../async-directive.js';
 declare type Mapper<T> = (v: T, index?: number) => unknown;
-declare class AsyncReplaceDirective extends AsyncDirective {
-    private _value?;
-    private _reconnectResolver?;
-    private _reconnectPromise?;
+export declare class AsyncReplaceDirective extends AsyncDirective {
+    private __value?;
+    private __weakThis;
+    private __pauser;
     render<T>(value: AsyncIterable<T>, _mapper?: Mapper<T>): symbol;
     update(_part: ChildPart, [value, mapper]: DirectiveParameters<this>): typeof noChange | undefined;
-    private __iterate;
+    protected commitValue(value: unknown, _index: number): void;
     disconnected(): void;
     reconnected(): void;
 }
@@ -23,7 +22,7 @@ declare class AsyncReplaceDirective extends AsyncDirective {
  * previous values with new values, so that only one value is ever rendered
  * at a time. This directive may be used in any expression type.
  *
- * Async iterables are objects with a [Symbol.asyncIterator] method, which
+ * Async iterables are objects with a `[Symbol.asyncIterator]` method, which
  * returns an iterator who's `next()` method returns a Promise. When a new
  * value is available, the Promise resolves and the value is rendered to the
  * Part controlled by the directive. If another value other than this
@@ -37,9 +36,5 @@ declare class AsyncReplaceDirective extends AsyncDirective {
  *     value. Useful for generating templates for each item in the iterable.
  */
 export declare const asyncReplace: (value: AsyncIterable<unknown>, _mapper?: Mapper<unknown> | undefined) => import("../directive.js").DirectiveResult<typeof AsyncReplaceDirective>;
-/**
- * The type of the class that powers this directive. Necessary for naming the
- * directive's return type.
- */
-export type { AsyncReplaceDirective };
+export {};
 //# sourceMappingURL=async-replace.d.ts.map

package/front_end/third_party/lit-html/package/directives/async-replace.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"async-replace.d.ts","sourceRoot":"","sources":["../../src/directives/async-replace.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAC,SAAS,EAAE,QAAQ,EAAC,MAAM,gBAAgB,CAAC;AACnD,OAAO,EAAY,mBAAmB,EAAC,MAAM,iBAAiB,CAAC;AAC/D,OAAO,EAAC,cAAc,EAAC,MAAM,uBAAuB,CAAC;AAErD,aAAK,MAAM,CAAC,CAAC,IAAI,CAAC,CAAC,EAAE,CAAC,EAAE,KAAK,CAAC,EAAE,MAAM,KAAK,OAAO,CAAC;AAEnD,cAAM,qBAAsB,SAAQ,cAAc;IAChD,OAAO,CAAC,MAAM,CAAC,CAAyB;IACxC,OAAO,CAAC,kBAAkB,CAAC,CAAa;IACxC,OAAO,CAAC,iBAAiB,CAAC,CAAgB;IAI1C,MAAM,CAAC,CAAC,EAAE,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,EAAE,OAAO,CAAC,EAAE,MAAM,CAAC,CAAC,CAAC;IAItD,MAAM,CAAC,KAAK,EAAE,SAAS,EAAE,CAAC,KAAK,EAAE,MAAM,CAAC,EAAE,mBAAmB,CAAC,IAAI,CAAC;YAarD,SAAS;IA4BvB,YAAY;IAOZ,WAAW;CAKZ;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,YAAY,mJAAmC,CAAC;AAE7D;;;GAGG;AACH,YAAY,EAAC,qBAAqB,EAAC,CAAC"}
+{"version":3,"file":"async-replace.d.ts","sourceRoot":"","sources":["../../src/directives/async-replace.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAC,SAAS,EAAE,QAAQ,EAAC,MAAM,gBAAgB,CAAC;AACnD,OAAO,EAAY,mBAAmB,EAAC,MAAM,iBAAiB,CAAC;AAC/D,OAAO,EAAC,cAAc,EAAC,MAAM,uBAAuB,CAAC;AAGrD,aAAK,MAAM,CAAC,CAAC,IAAI,CAAC,CAAC,EAAE,CAAC,EAAE,KAAK,CAAC,EAAE,MAAM,KAAK,OAAO,CAAC;AAEnD,qBAAa,qBAAsB,SAAQ,cAAc;IACvD,OAAO,CAAC,OAAO,CAAC,CAAyB;IACzC,OAAO,CAAC,UAAU,CAA2B;IAC7C,OAAO,CAAC,QAAQ,CAAgB;IAIhC,MAAM,CAAC,CAAC,EAAE,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,EAAE,OAAO,CAAC,EAAE,MAAM,CAAC,CAAC,CAAC;IAI7C,MAAM,CACb,KAAK,EAAE,SAAS,EAChB,CAAC,KAAK,EAAE,MAAM,CAAC,EAAE,mBAAmB,CAAC,IAAI,CAAC;IAqD5C,SAAS,CAAC,WAAW,CAAC,KAAK,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM;IAI3C,YAAY;IAKZ,WAAW;CAIrB;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,YAAY,mJAAmC,CAAC"}

package/front_end/third_party/lit-html/package/directives/async-replace.js

@@ -1,10 +1,7 @@
-import{AsyncDirective as e}from"../async-directive.js";
-import{directive as i}from"../directive.js";
-import{noChange as t}from"../lit-html.js";
-
+import{noChange as t}from"../lit-html.js";import{directive as i}from"../directive.js";import{AsyncDirective as s}from"../async-directive.js";import{PseudoWeakRef as r,Pauser as e,forAwaitOf as n}from"./private-async-helpers.js";
 /**
  * @license
  * Copyright 2017 Google LLC
  * SPDX-License-Identifier: BSD-3-Clause
- */const s=i(class extends e{render(i,e){return t}update(i,[e,s]){if(e!==this.vt)return this.vt=e,this.Σft(s),t}async Σft(t){let i=0;const{vt:e}=this;for await(let s of e){if(this.vt!==e)break;this.wt&&await this.wt,void 0!==t&&(s=t(s,i)),this.setValue(s),i++}}disconnected(){this.wt=new Promise((t=>this.yt=t))}reconnected(){this.wt=void 0,this.yt()}});export{s as asyncReplace};
+ */class o extends s{constructor(){super(...arguments),this._$CG=new r(this),this._$CK=new e}render(i,s){return t}update(i,[s,r]){if(this.isConnected||this.disconnected(),s===this._$CJ)return;this._$CJ=s;let e=0;const{_$CG:o,_$CK:h}=this;return n(s,(async t=>{for(;h.get();)await h.get();const i=o.deref();if(void 0!==i){if(i._$CJ!==s)return!1;void 0!==r&&(t=r(t,e)),i.commitValue(t,e),e++}return!0})),t}commitValue(t,i){this.setValue(t)}disconnected(){this._$CG.disconnect(),this._$CK.pause()}reconnected(){this._$CG.reconnect(this),this._$CK.resume()}}const h=i(o);export{o as AsyncReplaceDirective,h as asyncReplace};
 //# sourceMappingURL=async-replace.js.map

package/front_end/third_party/lit-html/package/directives/async-replace.js.map

@@ -1 +1 @@
-{"version":3,"file":"async-replace.js","sources":["../src/directives/async-replace.ts"],"sourcesContent":["/**\n * @license\n * Copyright 2017 Google LLC\n * SPDX-License-Identifier: BSD-3-Clause\n */\n\nimport {ChildPart, noChange} from '../lit-html.js';\nimport {directive, DirectiveParameters} from '../directive.js';\nimport {AsyncDirective} from '../async-directive.js';\n\ntype Mapper<T> = (v: T, index?: number) => unknown;\n\nclass AsyncReplaceDirective extends AsyncDirective {\n  private _value?: AsyncIterable<unknown>;\n  private _reconnectResolver?: () => void;\n  private _reconnectPromise?: Promise<void>;\n\n  // @ts-expect-error value not used, but we want a nice parameter for docs\n  // eslint-disable-next-line @typescript-eslint/no-unused-vars\n  render<T>(value: AsyncIterable<T>, _mapper?: Mapper<T>) {\n    return noChange;\n  }\n\n  update(_part: ChildPart, [value, mapper]: DirectiveParameters<this>) {\n    // If we've already set up this particular iterable, we don't need\n    // to do anything.\n    if (value === this._value) {\n      return;\n    }\n    this._value = value;\n    this.__iterate(mapper);\n    return noChange;\n  }\n\n  // Separate function to avoid an iffe in update; update can't be async\n  // because its return value must be `noChange`\n  private async __iterate(mapper?: Mapper<unknown>) {\n    let i = 0;\n    const {_value: value} = this;\n    for await (let v of value!) {\n      // Check to make sure that value is the still the current value of\n      // the part, and if not bail because a new value owns this part\n      if (this._value !== value) {\n        break;\n      }\n\n      // If we were disconnected, pause until reconnected\n      if (this._reconnectPromise) {\n        await this._reconnectPromise;\n      }\n\n      // As a convenience, because functional-programming-style\n      // transforms of iterables and async iterables requires a library,\n      // we accept a mapper function. This is especially convenient for\n      // rendering a template for each item.\n      if (mapper !== undefined) {\n        v = mapper(v, i);\n      }\n\n      this.setValue(v);\n      i++;\n    }\n  }\n\n  disconnected() {\n    // Pause iteration while disconnected\n    this._reconnectPromise = new Promise(\n      (resolve) => (this._reconnectResolver = resolve)\n    );\n  }\n\n  reconnected() {\n    // Resume iteration when reconnected\n    this._reconnectPromise = undefined;\n    this._reconnectResolver!();\n  }\n}\n\n/**\n * A directive that renders the items of an async iterable[1], replacing\n * previous values with new values, so that only one value is ever rendered\n * at a time. This directive may be used in any expression type.\n *\n * Async iterables are objects with a [Symbol.asyncIterator] method, which\n * returns an iterator who's `next()` method returns a Promise. When a new\n * value is available, the Promise resolves and the value is rendered to the\n * Part controlled by the directive. If another value other than this\n * directive has been set on the Part, the iterable will no longer be listened\n * to and new values won't be written to the Part.\n *\n * [1]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/for-await...of\n *\n * @param value An async iterable\n * @param mapper An optional function that maps from (value, index) to another\n *     value. Useful for generating templates for each item in the iterable.\n */\nexport const asyncReplace = directive(AsyncReplaceDirective);\n\n/**\n * The type of the class that powers this directive. Necessary for naming the\n * directive's return type.\n */\nexport type {AsyncReplaceDirective};\n"],"names":["asyncReplace","directive","AsyncDirective","[object Object]","value","_mapper","noChange","_part","mapper","this","_value","__iterate","i","vt","v","_reconnectPromise","undefined","setValue","Promise","resolve","_reconnectResolver"],"mappings":";;;;;SAgGaA,EAAeC,EApF5B,cAAoCC,EAOlCC,OAAUC,EAAyBC,GACjC,OAAOC,EAGTH,OAAOI,GAAmBH,EAAOI,IAG/B,GAAIJ,IAAUK,KAAKC,GAKnB,OAFAD,KAAKC,GAASN,EACdK,KAAKE,IAAUH,GACRF,EAKDH,UAAgBK,GACtB,IAAII,EAAI,EACR,MAAOC,GAAQT,GAASK,KACxB,UAAW,IAAIK,KAAKV,EAAQ,CAG1B,GAAIK,KAAKC,KAAWN,EAClB,MAIEK,KAAKM,UACDN,KAAKM,QAOEC,IAAXR,IACFM,EAAIN,EAAOM,EAAGF,IAGhBH,KAAKQ,SAASH,GACdF,KAIJT,eAEEM,KAAKM,GAAoB,IAAIG,SAC1BC,GAAaV,KAAKW,GAAqBD,IAI5ChB,cAEEM,KAAKM,QAAoBC,EACzBP,KAAKW"}
+{"version":3,"file":"async-replace.js","sources":["../src/directives/async-replace.ts"],"sourcesContent":["/**\n * @license\n * Copyright 2017 Google LLC\n * SPDX-License-Identifier: BSD-3-Clause\n */\n\nimport {ChildPart, noChange} from '../lit-html.js';\nimport {directive, DirectiveParameters} from '../directive.js';\nimport {AsyncDirective} from '../async-directive.js';\nimport {Pauser, PseudoWeakRef, forAwaitOf} from './private-async-helpers.js';\n\ntype Mapper<T> = (v: T, index?: number) => unknown;\n\nexport class AsyncReplaceDirective extends AsyncDirective {\n  private __value?: AsyncIterable<unknown>;\n  private __weakThis = new PseudoWeakRef(this);\n  private __pauser = new Pauser();\n\n  // @ts-expect-error value not used, but we want a nice parameter for docs\n  // eslint-disable-next-line @typescript-eslint/no-unused-vars\n  render<T>(value: AsyncIterable<T>, _mapper?: Mapper<T>) {\n    return noChange;\n  }\n\n  override update(\n    _part: ChildPart,\n    [value, mapper]: DirectiveParameters<this>\n  ) {\n    // If our initial render occurs while disconnected, ensure that the pauser\n    // and weakThis are in the disconnected state\n    if (!this.isConnected) {\n      this.disconnected();\n    }\n    // If we've already set up this particular iterable, we don't need\n    // to do anything.\n    if (value === this.__value) {\n      return;\n    }\n    this.__value = value;\n    let i = 0;\n    const {__weakThis: weakThis, __pauser: pauser} = this;\n    // Note, the callback avoids closing over `this` so that the directive\n    // can be gc'ed before the promise resolves; instead `this` is retrieved\n    // from `weakThis`, which can break the hard reference in the closure when\n    // the directive disconnects\n    forAwaitOf(value, async (v: unknown) => {\n      // The while loop here handles the case that the connection state\n      // thrashes, causing the pauser to resume and then get re-paused\n      while (pauser.get()) {\n        await pauser.get();\n      }\n      // If the callback gets here and there is no `this`, it means that the\n      // directive has been disconnected and garbage collected and we don't\n      // need to do anything else\n      const _this = weakThis.deref();\n      if (_this !== undefined) {\n        // Check to make sure that value is the still the current value of\n        // the part, and if not bail because a new value owns this part\n        if (_this.__value !== value) {\n          return false;\n        }\n\n        // As a convenience, because functional-programming-style\n        // transforms of iterables and async iterables requires a library,\n        // we accept a mapper function. This is especially convenient for\n        // rendering a template for each item.\n        if (mapper !== undefined) {\n          v = mapper(v, i);\n        }\n\n        _this.commitValue(v, i);\n        i++;\n      }\n      return true;\n    });\n    return noChange;\n  }\n\n  // Override point for AsyncAppend to append rather than replace\n  protected commitValue(value: unknown, _index: number) {\n    this.setValue(value);\n  }\n\n  override disconnected() {\n    this.__weakThis.disconnect();\n    this.__pauser.pause();\n  }\n\n  override reconnected() {\n    this.__weakThis.reconnect(this);\n    this.__pauser.resume();\n  }\n}\n\n/**\n * A directive that renders the items of an async iterable[1], replacing\n * previous values with new values, so that only one value is ever rendered\n * at a time. This directive may be used in any expression type.\n *\n * Async iterables are objects with a `[Symbol.asyncIterator]` method, which\n * returns an iterator who's `next()` method returns a Promise. When a new\n * value is available, the Promise resolves and the value is rendered to the\n * Part controlled by the directive. If another value other than this\n * directive has been set on the Part, the iterable will no longer be listened\n * to and new values won't be written to the Part.\n *\n * [1]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/for-await...of\n *\n * @param value An async iterable\n * @param mapper An optional function that maps from (value, index) to another\n *     value. Useful for generating templates for each item in the iterable.\n */\nexport const asyncReplace = directive(AsyncReplaceDirective);\n"],"names":["AsyncReplaceDirective","AsyncDirective","constructor","this","PseudoWeakRef","Pauser","render","value","_mapper","noChange","update","_part","mapper","isConnected","disconnected","__value","i","__weakThis","weakThis","__pauser","pauser","forAwaitOf","async","v","get","_this","deref","undefined","commitValue","_index","setValue","disconnect","pause","reconnected","reconnect","resume","asyncReplace","directive"],"mappings":";;;;;SAaaA,UAA8BC,EAA3CC,kCAEUC,UAAa,IAAIC,EAAcD,MAC/BA,UAAW,IAAIE,EAIvBC,OAAUC,EAAyBC,GACjC,OAAOC,EAGAC,OACPC,GACCJ,EAAOK,IASR,GALKT,KAAKU,aACRV,KAAKW,eAIHP,IAAUJ,KAAKY,KACjB,OAEFZ,KAAKY,KAAUR,EACf,IAAIS,EAAI,EACR,MAAOC,KAAYC,EAAUC,KAAUC,GAAUjB,KAmCjD,OA9BAkB,EAAWd,GAAOe,MAAOC,IAGvB,KAAOH,EAAOI,aACNJ,EAAOI,MAKf,MAAMC,EAAQP,EAASQ,QACvB,QAAcC,IAAVF,EAAqB,CAGvB,GAAIA,EAAMV,OAAYR,EACpB,OAAO,OAOMoB,IAAXf,IACFW,EAAIX,EAAOW,EAAGP,IAGhBS,EAAMG,YAAYL,EAAGP,GACrBA,IAEF,OAAO,KAEFP,EAICmB,YAAYrB,EAAgBsB,GACpC1B,KAAK2B,SAASvB,GAGPO,eACPX,KAAKc,KAAWc,aAChB5B,KAAKgB,KAASa,QAGPC,cACP9B,KAAKc,KAAWiB,UAAU/B,MAC1BA,KAAKgB,KAASgB,gBAsBLC,EAAeC,EAAUrC"}

package/front_end/third_party/lit-html/package/directives/cache.d.ts

@@ -3,9 +3,8 @@
  * Copyright 2017 Google LLC
  * SPDX-License-Identifier: BSD-3-Clause
  */
-import { Directive, DirectiveParameters, PartInfo } from '../directive.js';
 import { ChildPart } from '../lit-html.js';
-
+import { Directive, DirectiveParameters, PartInfo } from '../directive.js';
 declare class CacheDirective extends Directive {
     private _templateCache;
     private _value?;
@@ -19,7 +18,7 @@ declare class CacheDirective extends Directive {
  *
  * Example:
  *
- * ```
+ * ```js
  * let checked = false;
  *
  * html`

package/front_end/third_party/lit-html/package/directives/cache.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"cache.d.ts","sourceRoot":"","sources":["../../src/directives/cache.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAiB,SAAS,EAAkB,MAAM,gBAAgB,CAAC;AAC1E,OAAO,EAEL,SAAS,EACT,mBAAmB,EACnB,QAAQ,EACT,MAAM,iBAAiB,CAAC;AASzB,cAAM,cAAe,SAAQ,SAAS;IACpC,OAAO,CAAC,cAAc,CAAkD;IACxE,OAAO,CAAC,MAAM,CAAC,CAAiB;gBAEpB,QAAQ,EAAE,QAAQ;IAI9B,MAAM,CAAC,CAAC,EAAE,OAAO;IAMjB,MAAM,CAAC,aAAa,EAAE,SAAS,EAAE,CAAC,CAAC,CAAC,EAAE,mBAAmB,CAAC,IAAI,CAAC;CA+ChE;AAED;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,KAAK,kFAA4B,CAAC;AAE/C;;;GAGG;AACH,YAAY,EAAC,cAAc,EAAC,CAAC"}
+{"version":3,"file":"cache.d.ts","sourceRoot":"","sources":["../../src/directives/cache.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAEL,SAAS,EAIV,MAAM,gBAAgB,CAAC;AACxB,OAAO,EAEL,SAAS,EACT,mBAAmB,EACnB,QAAQ,EACT,MAAM,iBAAiB,CAAC;AASzB,cAAM,cAAe,SAAQ,SAAS;IACpC,OAAO,CAAC,cAAc,CAAiD;IACvE,OAAO,CAAC,MAAM,CAAC,CAAiB;gBAEpB,QAAQ,EAAE,QAAQ;IAI9B,MAAM,CAAC,CAAC,EAAE,OAAO;IAMR,MAAM,CAAC,aAAa,EAAE,SAAS,EAAE,CAAC,CAAC,CAAC,EAAE,mBAAmB,CAAC,IAAI,CAAC;CA8CzE;AAED;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,KAAK,kFAA4B,CAAC;AAE/C;;;GAGG;AACH,YAAY,EAAC,cAAc,EAAC,CAAC"}

package/front_end/third_party/lit-html/package/directives/cache.js

@@ -1,10 +1,7 @@
-import{clearPart as c,getCommittedValue as r,insertPart as n,isTemplateResult as o,setCommittedValue as h}from"../directive-helpers.js";
-import{directive as s,Directive as e}from"../directive.js";
-import{nothing as i,render as t}from"../lit-html.js";
-
+import{render as t,nothing as i}from"../lit-html.js";import{directive as s,Directive as e}from"../directive.js";import{isTemplateResult as o,getCommittedValue as r,setCommittedValue as h,insertPart as n,clearPart as c}from"../directive-helpers.js";
 /**
  * @license
  * Copyright 2017 Google LLC
  * SPDX-License-Identifier: BSD-3-Clause
- */const d=s(class extends e{constructor(t){super(t),this._t=new WeakMap}render(t){return[t]}update(s,[e]){if(o(this.vt)&&(!o(e)||this.vt.strings!==e.strings)){const e=r(s).pop();let o=this._t.get(this.vt.strings);if(void 0===o){const s=document.createDocumentFragment();o=t(i,s),this._t.set(this.vt.strings,o)}h(o,[e]),n(o,void 0,e),e.setConnected(!1)}if(o(e)){if(!o(this.vt)||this.vt.strings!==e.strings){const t=this._t.get(e.strings);if(void 0!==t){const i=r(t).pop();c(s),n(s,void 0,i),h(s,[i]),i.setConnected(!0)}}this.vt=e}else this.vt=void 0;return this.render(e)}});export{d as cache};
+ */const d=s(class extends e{constructor(t){super(t),this.tt=new WeakMap}render(t){return[t]}update(s,[e]){if(o(this.it)&&(!o(e)||this.it.strings!==e.strings)){const e=r(s).pop();let o=this.tt.get(this.it.strings);if(void 0===o){const s=document.createDocumentFragment();o=t(i,s),o.setConnected(!1),this.tt.set(this.it.strings,o)}h(o,[e]),n(o,void 0,e)}if(o(e)){if(!o(this.it)||this.it.strings!==e.strings){const t=this.tt.get(e.strings);if(void 0!==t){const i=r(t).pop();c(s),n(s,void 0,i),h(s,[i])}}this.it=e}else this.it=void 0;return this.render(e)}});export{d as cache};
 //# sourceMappingURL=cache.js.map

package/front_end/third_party/lit-html/package/directives/cache.js.map

@@ -1 +1 @@
-{"version":3,"file":"cache.js","sources":["../src/directives/cache.ts"],"sourcesContent":["/**\n * @license\n * Copyright 2017 Google LLC\n * SPDX-License-Identifier: BSD-3-Clause\n */\n\nimport {TemplateResult, ChildPart, render, nothing} from '../lit-html.js';\nimport {\n  directive,\n  Directive,\n  DirectiveParameters,\n  PartInfo,\n} from '../directive.js';\nimport {\n  clearPart,\n  getCommittedValue,\n  insertPart,\n  isTemplateResult,\n  setCommittedValue,\n} from '../directive-helpers.js';\n\nclass CacheDirective extends Directive {\n  private _templateCache = new WeakMap<TemplateStringsArray, ChildPart>();\n  private _value?: TemplateResult;\n\n  constructor(partInfo: PartInfo) {\n    super(partInfo);\n  }\n\n  render(v: unknown) {\n    // Return an array of the value to induce lit-html to create a ChildPart\n    // for the value that we can move into the cache.\n    return [v];\n  }\n\n  update(containerPart: ChildPart, [v]: DirectiveParameters<this>) {\n    // If the previous value is a TemplateResult and the new value is not,\n    // or is a different Template as the previous value, move the child part\n    // into the cache.\n    if (\n      isTemplateResult(this._value) &&\n      (!isTemplateResult(v) || this._value.strings !== v.strings)\n    ) {\n      // This is always an array because we return [v] in render()\n      const partValue = getCommittedValue(containerPart) as Array<ChildPart>;\n      const childPart = partValue.pop()!;\n      let cachedContainerPart = this._templateCache.get(this._value.strings);\n      if (cachedContainerPart === undefined) {\n        const fragment = document.createDocumentFragment();\n        cachedContainerPart = render(nothing, fragment);\n        this._templateCache.set(this._value.strings, cachedContainerPart);\n      }\n      // Move into cache\n      setCommittedValue(cachedContainerPart, [childPart]);\n      insertPart(cachedContainerPart, undefined, childPart);\n      childPart.setConnected(false);\n    }\n    // If the new value is a TemplateResult and the previous value is not,\n    // or is a different Template as the previous value, restore the child\n    // part from the cache.\n    if (isTemplateResult(v)) {\n      if (!isTemplateResult(this._value) || this._value.strings !== v.strings) {\n        const cachedContainerPart = this._templateCache.get(v.strings);\n        if (cachedContainerPart !== undefined) {\n          // Move the cached part back into the container part value\n          const partValue = getCommittedValue(\n            cachedContainerPart\n          ) as Array<ChildPart>;\n          const cachedPart = partValue.pop()!;\n          // Move cached part back into DOM\n          clearPart(containerPart);\n          insertPart(containerPart, undefined, cachedPart);\n          setCommittedValue(containerPart, [cachedPart]);\n          cachedPart.setConnected(true);\n        }\n      }\n      this._value = v;\n    } else {\n      this._value = undefined;\n    }\n    return this.render(v);\n  }\n}\n\n/**\n * Enables fast switching between multiple templates by caching the DOM nodes\n * and TemplateInstances produced by the templates.\n *\n * Example:\n *\n * ```\n * let checked = false;\n *\n * html`\n *   ${cache(checked ? html`input is checked` : html`input is not checked`)}\n * `\n * ```\n */\nexport const cache = directive(CacheDirective);\n\n/**\n * The type of the class that powers this directive. Necessary for naming the\n * directive's return type.\n */\nexport type {CacheDirective};\n"],"names":["cache","directive","Directive","[object Object]","partInfo","super","this","WeakMap","v","containerPart","isTemplateResult","_value","strings","childPart","getCommittedValue","pop","cachedContainerPart","_templateCache","get","undefined","fragment","document","createDocumentFragment","render","nothing","set","setCommittedValue","insertPart","setConnected","cachedPart","clearPart"],"mappings":";;;;;SAkGaA,EAAQC,EA7ErB,cAA6BC,EAI3BC,YAAYC,GACVC,MAAMD,GAJAE,QAAiB,IAAIC,QAO7BJ,OAAOK,GAGL,MAAO,CAACA,GAGVL,OAAOM,GAA2BD,IAIhC,GACEE,EAAiBJ,KAAKK,OACpBD,EAAiBF,IAAMF,KAAKK,GAAOC,UAAYJ,EAAEI,SACnD,CAEA,MACMC,EADYC,EAAkBL,GACRM,MAC5B,IAAIC,EAAsBV,KAAKW,GAAeC,IAAIZ,KAAKK,GAAOC,SAC9D,QAA4BO,IAAxBH,EAAmC,CACrC,MAAMI,EAAWC,SAASC,yBAC1BN,EAAsBO,EAAOC,EAASJ,GACtCd,KAAKW,GAAeQ,IAAInB,KAAKK,GAAOC,QAASI,GAG/CU,EAAkBV,EAAqB,CAACH,IACxCc,EAAWX,OAAqBG,EAAWN,GAC3CA,EAAUe,cAAa,GAKzB,GAAIlB,EAAiBF,GAAI,CACvB,IAAKE,EAAiBJ,KAAKK,KAAWL,KAAKK,GAAOC,UAAYJ,EAAEI,QAAS,CACvE,MAAMI,EAAsBV,KAAKW,GAAeC,IAAIV,EAAEI,SACtD,QAA4BO,IAAxBH,EAAmC,CAErC,MAGMa,EAHYf,EAChBE,GAE2BD,MAE7Be,EAAUrB,GACVkB,EAAWlB,OAAeU,EAAWU,GACrCH,EAAkBjB,EAAe,CAACoB,IAClCA,EAAWD,cAAa,IAG5BtB,KAAKK,GAASH,OAEdF,KAAKK,QAASQ,EAEhB,OAAOb,KAAKiB,OAAOf"}
+{"version":3,"file":"cache.js","sources":["../src/directives/cache.ts"],"sourcesContent":["/**\n * @license\n * Copyright 2017 Google LLC\n * SPDX-License-Identifier: BSD-3-Clause\n */\n\nimport {\n  TemplateResult,\n  ChildPart,\n  RootPart,\n  render,\n  nothing,\n} from '../lit-html.js';\nimport {\n  directive,\n  Directive,\n  DirectiveParameters,\n  PartInfo,\n} from '../directive.js';\nimport {\n  clearPart,\n  getCommittedValue,\n  insertPart,\n  isTemplateResult,\n  setCommittedValue,\n} from '../directive-helpers.js';\n\nclass CacheDirective extends Directive {\n  private _templateCache = new WeakMap<TemplateStringsArray, RootPart>();\n  private _value?: TemplateResult;\n\n  constructor(partInfo: PartInfo) {\n    super(partInfo);\n  }\n\n  render(v: unknown) {\n    // Return an array of the value to induce lit-html to create a ChildPart\n    // for the value that we can move into the cache.\n    return [v];\n  }\n\n  override update(containerPart: ChildPart, [v]: DirectiveParameters<this>) {\n    // If the previous value is a TemplateResult and the new value is not,\n    // or is a different Template as the previous value, move the child part\n    // into the cache.\n    if (\n      isTemplateResult(this._value) &&\n      (!isTemplateResult(v) || this._value.strings !== v.strings)\n    ) {\n      // This is always an array because we return [v] in render()\n      const partValue = getCommittedValue(containerPart) as Array<ChildPart>;\n      const childPart = partValue.pop()!;\n      let cachedContainerPart = this._templateCache.get(this._value.strings);\n      if (cachedContainerPart === undefined) {\n        const fragment = document.createDocumentFragment();\n        cachedContainerPart = render(nothing, fragment);\n        cachedContainerPart.setConnected(false);\n        this._templateCache.set(this._value.strings, cachedContainerPart);\n      }\n      // Move into cache\n      setCommittedValue(cachedContainerPart, [childPart]);\n      insertPart(cachedContainerPart, undefined, childPart);\n    }\n    // If the new value is a TemplateResult and the previous value is not,\n    // or is a different Template as the previous value, restore the child\n    // part from the cache.\n    if (isTemplateResult(v)) {\n      if (!isTemplateResult(this._value) || this._value.strings !== v.strings) {\n        const cachedContainerPart = this._templateCache.get(v.strings);\n        if (cachedContainerPart !== undefined) {\n          // Move the cached part back into the container part value\n          const partValue = getCommittedValue(\n            cachedContainerPart\n          ) as Array<ChildPart>;\n          const cachedPart = partValue.pop()!;\n          // Move cached part back into DOM\n          clearPart(containerPart);\n          insertPart(containerPart, undefined, cachedPart);\n          setCommittedValue(containerPart, [cachedPart]);\n        }\n      }\n      this._value = v;\n    } else {\n      this._value = undefined;\n    }\n    return this.render(v);\n  }\n}\n\n/**\n * Enables fast switching between multiple templates by caching the DOM nodes\n * and TemplateInstances produced by the templates.\n *\n * Example:\n *\n * ```js\n * let checked = false;\n *\n * html`\n *   ${cache(checked ? html`input is checked` : html`input is not checked`)}\n * `\n * ```\n */\nexport const cache = directive(CacheDirective);\n\n/**\n * The type of the class that powers this directive. Necessary for naming the\n * directive's return type.\n */\nexport type {CacheDirective};\n"],"names":["cache","directive","Directive","constructor","partInfo","super","this","WeakMap","render","v","update","containerPart","isTemplateResult","_value","strings","childPart","getCommittedValue","pop","cachedContainerPart","_templateCache","get","undefined","fragment","document","createDocumentFragment","nothing","setConnected","set","setCommittedValue","insertPart","cachedPart","clearPart"],"mappings":";;;;;SAuGaA,EAAQC,EA5ErB,cAA6BC,EAI3BC,YAAYC,GACVC,MAAMD,GAJAE,QAAiB,IAAIC,QAO7BC,OAAOC,GAGL,MAAO,CAACA,GAGDC,OAAOC,GAA2BF,IAIzC,GACEG,EAAiBN,KAAKO,OACpBD,EAAiBH,IAAMH,KAAKO,GAAOC,UAAYL,EAAEK,SACnD,CAEA,MACMC,EADYC,EAAkBL,GACRM,MAC5B,IAAIC,EAAsBZ,KAAKa,GAAeC,IAAId,KAAKO,GAAOC,SAC9D,QAA4BO,IAAxBH,EAAmC,CACrC,MAAMI,EAAWC,SAASC,yBAC1BN,EAAsBV,EAAOiB,EAASH,GACtCJ,EAAoBQ,cAAa,GACjCpB,KAAKa,GAAeQ,IAAIrB,KAAKO,GAAOC,QAASI,GAG/CU,EAAkBV,EAAqB,CAACH,IACxCc,EAAWX,OAAqBG,EAAWN,GAK7C,GAAIH,EAAiBH,GAAI,CACvB,IAAKG,EAAiBN,KAAKO,KAAWP,KAAKO,GAAOC,UAAYL,EAAEK,QAAS,CACvE,MAAMI,EAAsBZ,KAAKa,GAAeC,IAAIX,EAAEK,SACtD,QAA4BO,IAAxBH,EAAmC,CAErC,MAGMY,EAHYd,EAChBE,GAE2BD,MAE7Bc,EAAUpB,GACVkB,EAAWlB,OAAeU,EAAWS,GACrCF,EAAkBjB,EAAe,CAACmB,KAGtCxB,KAAKO,GAASJ,OAEdH,KAAKO,QAASQ,EAEhB,OAAOf,KAAKE,OAAOC"}

package/front_end/third_party/lit-html/package/directives/class-map.d.ts

@@ -3,9 +3,8 @@
  * Copyright 2018 Google LLC
  * SPDX-License-Identifier: BSD-3-Clause
  */
-import { Directive, DirectiveParameters, PartInfo } from '../directive.js';
 import { AttributePart, noChange } from '../lit-html.js';
-
+import { Directive, DirectiveParameters, PartInfo } from '../directive.js';
 /**
  * A key-value set of class names to truthy values.
  */
@@ -18,6 +17,7 @@ declare class ClassMapDirective extends Directive {
      * Used to unset existing values when a new ClassInfo object is applied.
      */
     private _previousClasses?;
+    private _staticClasses?;
     constructor(partInfo: PartInfo);
     render(classInfo: ClassInfo): string;
     update(part: AttributePart, [classInfo]: DirectiveParameters<this>): string | typeof noChange;

package/front_end/third_party/lit-html/package/directives/class-map.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"class-map.d.ts","sourceRoot":"","sources":["../../src/directives/class-map.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAC,aAAa,EAAE,QAAQ,EAAC,MAAM,gBAAgB,CAAC;AACvD,OAAO,EAEL,SAAS,EACT,mBAAmB,EACnB,QAAQ,EAET,MAAM,iBAAiB,CAAC;AAEzB;;GAEG;AACH,MAAM,WAAW,SAAS;IACxB,QAAQ,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,MAAM,CAAC;CACpD;AAED,cAAM,iBAAkB,SAAQ,SAAS;IACvC;;;OAGG;IACH,OAAO,CAAC,gBAAgB,CAAC,CAAc;gBAE3B,QAAQ,EAAE,QAAQ;IAc9B,MAAM,CAAC,SAAS,EAAE,SAAS;IAM3B,MAAM,CAAC,IAAI,EAAE,aAAa,EAAE,CAAC,SAAS,CAAC,EAAE,mBAAmB,CAAC,IAAI,CAAC;CAyCnE;AAED;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,QAAQ,+FAA+B,CAAC;AAErD;;;GAGG;AACH,YAAY,EAAC,iBAAiB,EAAC,CAAC"}
+{"version":3,"file":"class-map.d.ts","sourceRoot":"","sources":["../../src/directives/class-map.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAC,aAAa,EAAE,QAAQ,EAAC,MAAM,gBAAgB,CAAC;AACvD,OAAO,EAEL,SAAS,EACT,mBAAmB,EACnB,QAAQ,EAET,MAAM,iBAAiB,CAAC;AAEzB;;GAEG;AACH,MAAM,WAAW,SAAS;IACxB,QAAQ,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,MAAM,CAAC;CACpD;AAED,cAAM,iBAAkB,SAAQ,SAAS;IACvC;;;OAGG;IACH,OAAO,CAAC,gBAAgB,CAAC,CAAc;IACvC,OAAO,CAAC,cAAc,CAAC,CAAc;gBAEzB,QAAQ,EAAE,QAAQ;IAc9B,MAAM,CAAC,SAAS,EAAE,SAAS;IAWlB,MAAM,CAAC,IAAI,EAAE,aAAa,EAAE,CAAC,SAAS,CAAC,EAAE,mBAAmB,CAAC,IAAI,CAAC;CAoD5E;AAED;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,QAAQ,+FAA+B,CAAC;AAErD;;;GAGG;AACH,YAAY,EAAC,iBAAiB,EAAC,CAAC"}

package/front_end/third_party/lit-html/package/directives/class-map.js

@@ -1,9 +1,7 @@
-import{directive as s,Directive as r,PartType as i}from"../directive.js";
-import{noChange as t}from"../lit-html.js";
-
+import{noChange as t}from"../lit-html.js";import{directive as i,Directive as s,PartType as r}from"../directive.js";
 /**
  * @license
  * Copyright 2018 Google LLC
  * SPDX-License-Identifier: BSD-3-Clause
- */const e=s(class extends r{constructor(t){var s;if(super(t),t.type!==i.ATTRIBUTE||"class"!==t.name||(null===(s=t.strings)||void 0===s?void 0:s.length)>2)throw Error("`classMap()` can only be used in the `class` attribute and must be the only part in the attribute.")}render(t){return Object.keys(t).filter((s=>t[s])).join(" ")}update(s,[r]){if(void 0===this.bt){this.bt=new Set;for(const t in r)r[t]&&this.bt.add(t);return this.render(r)}const i=s.element.classList;this.bt.forEach((t=>{t in r||(i.remove(t),this.bt.delete(t))}));for(const t in r){const s=!!r[t];s!==this.bt.has(t)&&(s?(i.add(t),this.bt.add(t)):(i.remove(t),this.bt.delete(t)))}return t}});export{e as classMap};
+ */const o=i(class extends s{constructor(t){var i;if(super(t),t.type!==r.ATTRIBUTE||"class"!==t.name||(null===(i=t.strings)||void 0===i?void 0:i.length)>2)throw Error("`classMap()` can only be used in the `class` attribute and must be the only part in the attribute.")}render(t){return" "+Object.keys(t).filter((i=>t[i])).join(" ")+" "}update(i,[s]){var r,o;if(void 0===this.st){this.st=new Set,void 0!==i.strings&&(this.et=new Set(i.strings.join(" ").split(/\s/).filter((t=>""!==t))));for(const t in s)s[t]&&!(null===(r=this.et)||void 0===r?void 0:r.has(t))&&this.st.add(t);return this.render(s)}const e=i.element.classList;this.st.forEach((t=>{t in s||(e.remove(t),this.st.delete(t))}));for(const t in s){const i=!!s[t];i===this.st.has(t)||(null===(o=this.et)||void 0===o?void 0:o.has(t))||(i?(e.add(t),this.st.add(t)):(e.remove(t),this.st.delete(t)))}return t}});export{o as classMap};
 //# sourceMappingURL=class-map.js.map

package/front_end/third_party/lit-html/package/directives/class-map.js.map

@@ -1 +1 @@
-{"version":3,"file":"class-map.js","sources":["../src/directives/class-map.ts"],"sourcesContent":["/**\n * @license\n * Copyright 2018 Google LLC\n * SPDX-License-Identifier: BSD-3-Clause\n */\n\nimport {AttributePart, noChange} from '../lit-html.js';\nimport {\n  directive,\n  Directive,\n  DirectiveParameters,\n  PartInfo,\n  PartType,\n} from '../directive.js';\n\n/**\n * A key-value set of class names to truthy values.\n */\nexport interface ClassInfo {\n  readonly [name: string]: string | boolean | number;\n}\n\nclass ClassMapDirective extends Directive {\n  /**\n   * Stores the ClassInfo object applied to a given AttributePart.\n   * Used to unset existing values when a new ClassInfo object is applied.\n   */\n  private _previousClasses?: Set<string>;\n\n  constructor(partInfo: PartInfo) {\n    super(partInfo);\n    if (\n      partInfo.type !== PartType.ATTRIBUTE ||\n      partInfo.name !== 'class' ||\n      (partInfo.strings?.length as number) > 2\n    ) {\n      throw new Error(\n        '`classMap()` can only be used in the `class` attribute ' +\n          'and must be the only part in the attribute.'\n      );\n    }\n  }\n\n  render(classInfo: ClassInfo) {\n    return Object.keys(classInfo)\n      .filter((key) => classInfo[key])\n      .join(' ');\n  }\n\n  update(part: AttributePart, [classInfo]: DirectiveParameters<this>) {\n    // Remember dynamic classes on the first render\n    if (this._previousClasses === undefined) {\n      this._previousClasses = new Set();\n      for (const name in classInfo) {\n        if (classInfo[name]) {\n          this._previousClasses.add(name);\n        }\n      }\n      return this.render(classInfo);\n    }\n\n    const classList = part.element.classList;\n\n    // Remove old classes that no longer apply\n    // We use forEach() instead of for-of so that we don't require down-level\n    // iteration.\n    this._previousClasses.forEach((name) => {\n      if (!(name in classInfo)) {\n        classList.remove(name);\n        this._previousClasses!.delete(name);\n      }\n    });\n\n    // Add or remove classes based on their classMap value\n    for (const name in classInfo) {\n      // We explicitly want a loose truthy check of `value` because it seems\n      // more convenient that '' and 0 are skipped.\n      const value = !!classInfo[name];\n      if (value !== this._previousClasses.has(name)) {\n        if (value) {\n          classList.add(name);\n          this._previousClasses.add(name);\n        } else {\n          classList.remove(name);\n          this._previousClasses.delete(name);\n        }\n      }\n    }\n    return noChange;\n  }\n}\n\n/**\n * A directive that applies dynamic CSS classes.\n *\n * This must be used in the `class` attribute and must be the only part used in\n * the attribute. It takes each property in the `classInfo` argument and adds\n * the property name to the element's `classList` if the property value is\n * truthy; if the property value is falsey, the property name is removed from\n * the element's `class`.\n *\n * For example `{foo: bar}` applies the class `foo` if the value of `bar` is\n * truthy.\n *\n * @param classInfo\n */\nexport const classMap = directive(ClassMapDirective);\n\n/**\n * The type of the class that powers this directive. Necessary for naming the\n * directive's return type.\n */\nexport type {ClassMapDirective};\n"],"names":["classMap","directive","Directive","[object Object]","partInfo","super","type","PartType","ATTRIBUTE","name","strings","length","Error","classInfo","Object","keys","filter","key","join","part","undefined","this","_previousClasses","Set","add","render","classList","element","forEach","remove","delete","value","has","noChange"],"mappings":";;;;;SA0GaA,EAAWC,EApFxB,cAAgCC,EAO9BC,YAAYC,SAEV,GADAC,MAAMD,GAEJA,EAASE,OAASC,EAASC,WACT,UAAlBJ,EAASK,iBACRL,EAASM,8BAASC,QAAoB,EAEvC,MAAUC,MACR,sGAMNT,OAAOU,GACL,OAAOC,OAAOC,KAAKF,GAChBG,QAAQC,GAAQJ,EAAUI,KAC1BC,KAAK,KAGVf,OAAOgB,GAAsBN,IAE3B,QAA8BO,IAA1BC,KAAKC,GAAgC,CACvCD,KAAKC,GAAmB,IAAIC,IAC5B,IAAK,MAAMd,KAAQI,EACbA,EAAUJ,IACZY,KAAKC,GAAiBE,IAAIf,GAG9B,OAAOY,KAAKI,OAAOZ,GAGrB,MAAMa,EAAYP,EAAKQ,QAAQD,UAK/BL,KAAKC,GAAiBM,SAASnB,IACvBA,KAAQI,IACZa,EAAUG,OAAOpB,GACjBY,KAAKC,GAAkBQ,OAAOrB,OAKlC,IAAK,MAAMA,KAAQI,EAAW,CAG5B,MAAMkB,IAAUlB,EAAUJ,GACtBsB,IAAUV,KAAKC,GAAiBU,IAAIvB,KAClCsB,GACFL,EAAUF,IAAIf,GACdY,KAAKC,GAAiBE,IAAIf,KAE1BiB,EAAUG,OAAOpB,GACjBY,KAAKC,GAAiBQ,OAAOrB,KAInC,OAAOwB"}
+{"version":3,"file":"class-map.js","sources":["../src/directives/class-map.ts"],"sourcesContent":["/**\n * @license\n * Copyright 2018 Google LLC\n * SPDX-License-Identifier: BSD-3-Clause\n */\n\nimport {AttributePart, noChange} from '../lit-html.js';\nimport {\n  directive,\n  Directive,\n  DirectiveParameters,\n  PartInfo,\n  PartType,\n} from '../directive.js';\n\n/**\n * A key-value set of class names to truthy values.\n */\nexport interface ClassInfo {\n  readonly [name: string]: string | boolean | number;\n}\n\nclass ClassMapDirective extends Directive {\n  /**\n   * Stores the ClassInfo object applied to a given AttributePart.\n   * Used to unset existing values when a new ClassInfo object is applied.\n   */\n  private _previousClasses?: Set<string>;\n  private _staticClasses?: Set<string>;\n\n  constructor(partInfo: PartInfo) {\n    super(partInfo);\n    if (\n      partInfo.type !== PartType.ATTRIBUTE ||\n      partInfo.name !== 'class' ||\n      (partInfo.strings?.length as number) > 2\n    ) {\n      throw new Error(\n        '`classMap()` can only be used in the `class` attribute ' +\n          'and must be the only part in the attribute.'\n      );\n    }\n  }\n\n  render(classInfo: ClassInfo) {\n    // Add spaces to ensure separation from static classes\n    return (\n      ' ' +\n      Object.keys(classInfo)\n        .filter((key) => classInfo[key])\n        .join(' ') +\n      ' '\n    );\n  }\n\n  override update(part: AttributePart, [classInfo]: DirectiveParameters<this>) {\n    // Remember dynamic classes on the first render\n    if (this._previousClasses === undefined) {\n      this._previousClasses = new Set();\n      if (part.strings !== undefined) {\n        this._staticClasses = new Set(\n          part.strings\n            .join(' ')\n            .split(/\\s/)\n            .filter((s) => s !== '')\n        );\n      }\n      for (const name in classInfo) {\n        if (classInfo[name] && !this._staticClasses?.has(name)) {\n          this._previousClasses.add(name);\n        }\n      }\n      return this.render(classInfo);\n    }\n\n    const classList = part.element.classList;\n\n    // Remove old classes that no longer apply\n    // We use forEach() instead of for-of so that we don't require down-level\n    // iteration.\n    this._previousClasses.forEach((name) => {\n      if (!(name in classInfo)) {\n        classList.remove(name);\n        this._previousClasses!.delete(name);\n      }\n    });\n\n    // Add or remove classes based on their classMap value\n    for (const name in classInfo) {\n      // We explicitly want a loose truthy check of `value` because it seems\n      // more convenient that '' and 0 are skipped.\n      const value = !!classInfo[name];\n      if (\n        value !== this._previousClasses.has(name) &&\n        !this._staticClasses?.has(name)\n      ) {\n        if (value) {\n          classList.add(name);\n          this._previousClasses.add(name);\n        } else {\n          classList.remove(name);\n          this._previousClasses.delete(name);\n        }\n      }\n    }\n    return noChange;\n  }\n}\n\n/**\n * A directive that applies dynamic CSS classes.\n *\n * This must be used in the `class` attribute and must be the only part used in\n * the attribute. It takes each property in the `classInfo` argument and adds\n * the property name to the element's `classList` if the property value is\n * truthy; if the property value is falsey, the property name is removed from\n * the element's `class`.\n *\n * For example `{foo: bar}` applies the class `foo` if the value of `bar` is\n * truthy.\n *\n * @param classInfo\n */\nexport const classMap = directive(ClassMapDirective);\n\n/**\n * The type of the class that powers this directive. Necessary for naming the\n * directive's return type.\n */\nexport type {ClassMapDirective};\n"],"names":["classMap","directive","Directive","constructor","partInfo","super","type","PartType","ATTRIBUTE","name","strings","length","Error","render","classInfo","Object","keys","filter","key","join","update","part","undefined","this","_previousClasses","Set","_staticClasses","split","s","has","add","classList","element","forEach","remove","delete","value","noChange"],"mappings":";;;;;SA2HaA,EAAWC,EArGxB,cAAgCC,EAQ9BC,YAAYC,SAEV,GADAC,MAAMD,GAEJA,EAASE,OAASC,EAASC,WACT,UAAlBJ,EAASK,iBACRL,EAASM,8BAASC,QAAoB,EAEvC,MAAUC,MACR,sGAMNC,OAAOC,GAEL,MACE,IACAC,OAAOC,KAAKF,GACTG,QAAQC,GAAQJ,EAAUI,KAC1BC,KAAK,KACR,IAIKC,OAAOC,GAAsBP,YAEpC,QAA8BQ,IAA1BC,KAAKC,GAAgC,CACvCD,KAAKC,GAAmB,IAAIC,SACPH,IAAjBD,EAAKX,UACPa,KAAKG,GAAiB,IAAID,IACxBJ,EAAKX,QACFS,KAAK,KACLQ,MAAM,MACNV,QAAQW,GAAY,KAANA,MAGrB,IAAK,MAAMnB,KAAQK,EACbA,EAAUL,gBAAUc,KAAKG,yBAAgBG,IAAIpB,KAC/Cc,KAAKC,GAAiBM,IAAIrB,GAG9B,OAAOc,KAAKV,OAAOC,GAGrB,MAAMiB,EAAYV,EAAKW,QAAQD,UAK/BR,KAAKC,GAAiBS,SAASxB,IACvBA,KAAQK,IACZiB,EAAUG,OAAOzB,GACjBc,KAAKC,GAAkBW,OAAO1B,OAKlC,IAAK,MAAMA,KAAQK,EAAW,CAG5B,MAAMsB,IAAUtB,EAAUL,GAExB2B,IAAUb,KAAKC,GAAiBK,IAAIpB,eACnCc,KAAKG,yBAAgBG,IAAIpB,MAEtB2B,GACFL,EAAUD,IAAIrB,GACdc,KAAKC,GAAiBM,IAAIrB,KAE1BsB,EAAUG,OAAOzB,GACjBc,KAAKC,GAAiBW,OAAO1B,KAInC,OAAO4B"}

package/front_end/third_party/lit-html/package/directives/guard.d.ts

@@ -3,9 +3,8 @@
  * Copyright 2018 Google LLC
  * SPDX-License-Identifier: BSD-3-Clause
  */
-import { Directive, DirectiveParameters } from '../directive.js';
 import { Part } from '../lit-html.js';
-
+import { Directive, DirectiveParameters } from '../directive.js';
 declare class GuardDirective extends Directive {
     private _previousValue;
     render(_value: unknown, f: () => unknown): unknown;
@@ -28,6 +27,7 @@ declare class GuardDirective extends Directive {
  *   <div>
  *     ${guard([user.id, company.id], () => html`...`)}
  *   </div>
+ * `
  * ```
  *
  * In this case, the template only rerenders if either `user.id` or `company.id`
@@ -43,6 +43,7 @@ declare class GuardDirective extends Directive {
  *   <div>
  *     ${guard([immutableItems], () => immutableItems.map(i => html`${i}`))}
  *   </div>
+ * `
  * ```
  *
  * In this case, items are mapped over only when the array reference changes.

package/front_end/third_party/lit-html/package/directives/guard.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"guard.d.ts","sourceRoot":"","sources":["../../src/directives/guard.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAW,IAAI,EAAC,MAAM,gBAAgB,CAAC;AAC9C,OAAO,EAAY,SAAS,EAAE,mBAAmB,EAAC,MAAM,iBAAiB,CAAC;AAK1E,cAAM,cAAe,SAAQ,SAAS;IACpC,OAAO,CAAC,cAAc,CAAyB;IAE/C,MAAM,CAAC,MAAM,EAAE,OAAO,EAAE,CAAC,EAAE,MAAM,OAAO;IAIxC,MAAM,CAAC,KAAK,EAAE,IAAI,EAAE,CAAC,KAAK,EAAE,CAAC,CAAC,EAAE,mBAAmB,CAAC,IAAI,CAAC;CAqB1D;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AACH,eAAO,MAAM,KAAK,6BAlEiB,OAAO,qEAkEI,CAAC;AAE/C;;;GAGG;AACH,YAAY,EAAC,cAAc,EAAC,CAAC"}
+{"version":3,"file":"guard.d.ts","sourceRoot":"","sources":["../../src/directives/guard.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAW,IAAI,EAAC,MAAM,gBAAgB,CAAC;AAC9C,OAAO,EAAY,SAAS,EAAE,mBAAmB,EAAC,MAAM,iBAAiB,CAAC;AAK1E,cAAM,cAAe,SAAQ,SAAS;IACpC,OAAO,CAAC,cAAc,CAAyB;IAE/C,MAAM,CAAC,MAAM,EAAE,OAAO,EAAE,CAAC,EAAE,MAAM,OAAO;IAI/B,MAAM,CAAC,KAAK,EAAE,IAAI,EAAE,CAAC,KAAK,EAAE,CAAC,CAAC,EAAE,mBAAmB,CAAC,IAAI,CAAC;CAqBnE;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwCG;AACH,eAAO,MAAM,KAAK,6BApEiB,OAAO,qEAoEI,CAAC;AAE/C;;;GAGG;AACH,YAAY,EAAC,cAAc,EAAC,CAAC"}

package/front_end/third_party/lit-html/package/directives/guard.js

@@ -1,10 +1,8 @@
-import{directive as t,Directive as s}from"../directive.js";
-import{noChange as r}from"../lit-html.js";
-
+import{noChange as r}from"../lit-html.js";import{directive as t,Directive as s}from"../directive.js";
 /**
  * @license
  * Copyright 2018 Google LLC
  * SPDX-License-Identifier: BSD-3-Clause
  */
-const e={},i=t(class extends s{constructor(){super(...arguments),this.$t=e}render(r,t){return t()}update(t,[s,e]){if(Array.isArray(s)){if(Array.isArray(this.$t)&&this.$t.length===s.length&&s.every(((r,t)=>r===this.$t[t])))return r}else if(this.$t===s)return r;return this.$t=Array.isArray(s)?Array.from(s):s,this.render(s,e)}});export{i as guard};
+const e={},i=t(class extends s{constructor(){super(...arguments),this.ot=e}render(r,t){return t()}update(t,[s,e]){if(Array.isArray(s)){if(Array.isArray(this.ot)&&this.ot.length===s.length&&s.every(((r,t)=>r===this.ot[t])))return r}else if(this.ot===s)return r;return this.ot=Array.isArray(s)?Array.from(s):s,this.render(s,e)}});export{i as guard};
 //# sourceMappingURL=guard.js.map

package/front_end/third_party/lit-html/package/directives/guard.js.map

@@ -1 +1 @@
-{"version":3,"file":"guard.js","sources":["../src/directives/guard.ts"],"sourcesContent":["/**\n * @license\n * Copyright 2018 Google LLC\n * SPDX-License-Identifier: BSD-3-Clause\n */\n\nimport {noChange, Part} from '../lit-html.js';\nimport {directive, Directive, DirectiveParameters} from '../directive.js';\n\n// A sentinal that indicates guard() hasn't rendered anything yet\nconst initialValue = {};\n\nclass GuardDirective extends Directive {\n  private _previousValue: unknown = initialValue;\n\n  render(_value: unknown, f: () => unknown) {\n    return f();\n  }\n\n  update(_part: Part, [value, f]: DirectiveParameters<this>) {\n    if (Array.isArray(value)) {\n      // Dirty-check arrays by item\n      if (\n        Array.isArray(this._previousValue) &&\n        this._previousValue.length === value.length &&\n        value.every((v, i) => v === (this._previousValue as Array<unknown>)[i])\n      ) {\n        return noChange;\n      }\n    } else if (this._previousValue === value) {\n      // Dirty-check non-arrays by identity\n      return noChange;\n    }\n\n    // Copy the value if it's an array so that if it's mutated we don't forget\n    // what the previous values were.\n    this._previousValue = Array.isArray(value) ? Array.from(value) : value;\n    const r = this.render(value, f);\n    return r;\n  }\n}\n\n/**\n * Prevents re-render of a template function until a single value or an array of\n * values changes.\n *\n * Values are checked against previous values with strict equality (`===`), and\n * so the check won't detect nested property changes inside objects or arrays.\n * Arrays values have each item checked against the previous value at the same\n * index with strict equality. Nested arrays are also checked only by strict\n * equality.\n *\n * Example:\n *\n * ```js\n * html`\n *   <div>\n *     ${guard([user.id, company.id], () => html`...`)}\n *   </div>\n * ```\n *\n * In this case, the template only rerenders if either `user.id` or `company.id`\n * changes.\n *\n * guard() is useful with immutable data patterns, by preventing expensive work\n * until data updates.\n *\n * Example:\n *\n * ```js\n * html`\n *   <div>\n *     ${guard([immutableItems], () => immutableItems.map(i => html`${i}`))}\n *   </div>\n * ```\n *\n * In this case, items are mapped over only when the array reference changes.\n *\n * @param value the value to check before re-rendering\n * @param f the template function\n */\nexport const guard = directive(GuardDirective);\n\n/**\n * The type of the class that powers this directive. Necessary for naming the\n * directive's return type.\n */\nexport type {GuardDirective};\n"],"names":["initialValue","guard","directive","Directive","[object Object]","this","_value","f","_part","value","Array","isArray","_previousValue","length","every","v","i","noChange","from","render"],"mappings":";;;;;;AAUA,MAAMA,EAAe,GAuERC,EAAQC,EArErB,cAA6BC,EAA7BC,kCACUC,QAA0BL,EAElCI,OAAOE,EAAiBC,GACtB,OAAOA,IAGTH,OAAOI,GAAcC,EAAOF,IAC1B,GAAIG,MAAMC,QAAQF,IAEhB,GACEC,MAAMC,QAAQN,KAAKO,KACnBP,KAAKO,GAAeC,SAAWJ,EAAMI,QACrCJ,EAAMK,OAAM,CAACC,EAAGC,IAAMD,IAAOV,KAAKO,GAAkCI,KAEpE,OAAOC,OAEJ,GAAIZ,KAAKO,KAAmBH,EAEjC,OAAOQ,EAOT,OAFAZ,KAAKO,GAAiBF,MAAMC,QAAQF,GAASC,MAAMQ,KAAKT,GAASA,EACvDJ,KAAKc,OAAOV,EAAOF"}
+{"version":3,"file":"guard.js","sources":["../src/directives/guard.ts"],"sourcesContent":["/**\n * @license\n * Copyright 2018 Google LLC\n * SPDX-License-Identifier: BSD-3-Clause\n */\n\nimport {noChange, Part} from '../lit-html.js';\nimport {directive, Directive, DirectiveParameters} from '../directive.js';\n\n// A sentinal that indicates guard() hasn't rendered anything yet\nconst initialValue = {};\n\nclass GuardDirective extends Directive {\n  private _previousValue: unknown = initialValue;\n\n  render(_value: unknown, f: () => unknown) {\n    return f();\n  }\n\n  override update(_part: Part, [value, f]: DirectiveParameters<this>) {\n    if (Array.isArray(value)) {\n      // Dirty-check arrays by item\n      if (\n        Array.isArray(this._previousValue) &&\n        this._previousValue.length === value.length &&\n        value.every((v, i) => v === (this._previousValue as Array<unknown>)[i])\n      ) {\n        return noChange;\n      }\n    } else if (this._previousValue === value) {\n      // Dirty-check non-arrays by identity\n      return noChange;\n    }\n\n    // Copy the value if it's an array so that if it's mutated we don't forget\n    // what the previous values were.\n    this._previousValue = Array.isArray(value) ? Array.from(value) : value;\n    const r = this.render(value, f);\n    return r;\n  }\n}\n\n/**\n * Prevents re-render of a template function until a single value or an array of\n * values changes.\n *\n * Values are checked against previous values with strict equality (`===`), and\n * so the check won't detect nested property changes inside objects or arrays.\n * Arrays values have each item checked against the previous value at the same\n * index with strict equality. Nested arrays are also checked only by strict\n * equality.\n *\n * Example:\n *\n * ```js\n * html`\n *   <div>\n *     ${guard([user.id, company.id], () => html`...`)}\n *   </div>\n * `\n * ```\n *\n * In this case, the template only rerenders if either `user.id` or `company.id`\n * changes.\n *\n * guard() is useful with immutable data patterns, by preventing expensive work\n * until data updates.\n *\n * Example:\n *\n * ```js\n * html`\n *   <div>\n *     ${guard([immutableItems], () => immutableItems.map(i => html`${i}`))}\n *   </div>\n * `\n * ```\n *\n * In this case, items are mapped over only when the array reference changes.\n *\n * @param value the value to check before re-rendering\n * @param f the template function\n */\nexport const guard = directive(GuardDirective);\n\n/**\n * The type of the class that powers this directive. Necessary for naming the\n * directive's return type.\n */\nexport type {GuardDirective};\n"],"names":["initialValue","guard","directive","Directive","constructor","this","render","_value","f","update","_part","value","Array","isArray","_previousValue","length","every","v","i","noChange","from"],"mappings":";;;;;;AAUA,MAAMA,EAAe,GAyERC,EAAQC,EAvErB,cAA6BC,EAA7BC,kCACUC,QAA0BL,EAElCM,OAAOC,EAAiBC,GACtB,OAAOA,IAGAC,OAAOC,GAAcC,EAAOH,IACnC,GAAII,MAAMC,QAAQF,IAEhB,GACEC,MAAMC,QAAQR,KAAKS,KACnBT,KAAKS,GAAeC,SAAWJ,EAAMI,QACrCJ,EAAMK,OAAM,CAACC,EAAGC,IAAMD,IAAOZ,KAAKS,GAAkCI,KAEpE,OAAOC,OAEJ,GAAId,KAAKS,KAAmBH,EAEjC,OAAOQ,EAOT,OAFAd,KAAKS,GAAiBF,MAAMC,QAAQF,GAASC,MAAMQ,KAAKT,GAASA,EACvDN,KAAKC,OAAOK,EAAOH"}

package/front_end/third_party/lit-html/package/directives/live.d.ts

@@ -3,9 +3,8 @@
  * Copyright 2020 Google LLC
  * SPDX-License-Identifier: BSD-3-Clause
  */
-import { Directive, DirectiveParameters, PartInfo } from '../directive.js';
 import { AttributePart } from '../lit-html.js';
-
+import { Directive, DirectiveParameters, PartInfo } from '../directive.js';
 declare class LiveDirective extends Directive {
     constructor(partInfo: PartInfo);
     render(value: unknown): unknown;
@@ -25,7 +24,9 @@ declare class LiveDirective extends Directive {
  * it alone. If this is not what you want--if you want to overwrite the DOM
  * value with the bound value no matter what--use the `live()` directive:
  *
- *     html`<input .value=${live(x)}>`
+ * ```js
+ * html`<input .value=${live(x)}>`
+ * ```
  *
  * `live()` performs a strict equality check agains the live DOM value, and if
  * the new value is equal to the live value, does nothing. This means that

package/front_end/third_party/lit-html/package/directives/live.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"live.d.ts","sourceRoot":"","sources":["../../src/directives/live.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAC,aAAa,EAAoB,MAAM,gBAAgB,CAAC;AAChE,OAAO,EAEL,SAAS,EACT,mBAAmB,EACnB,QAAQ,EAET,MAAM,iBAAiB,CAAC;AAGzB,cAAM,aAAc,SAAQ,SAAS;gBACvB,QAAQ,EAAE,QAAQ;IAkB9B,MAAM,CAAC,KAAK,EAAE,OAAO;IAIrB,MAAM,CAAC,IAAI,EAAE,aAAa,EAAE,CAAC,KAAK,CAAC,EAAE,mBAAmB,CAAC,IAAI,CAAC;CA6B/D;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,eAAO,MAAM,IAAI,qFAA2B,CAAC;AAE7C;;;GAGG;AACH,YAAY,EAAC,aAAa,EAAC,CAAC"}
+{"version":3,"file":"live.d.ts","sourceRoot":"","sources":["../../src/directives/live.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAC,aAAa,EAAoB,MAAM,gBAAgB,CAAC;AAChE,OAAO,EAEL,SAAS,EACT,mBAAmB,EACnB,QAAQ,EAET,MAAM,iBAAiB,CAAC;AAGzB,cAAM,aAAc,SAAQ,SAAS;gBACvB,QAAQ,EAAE,QAAQ;IAkB9B,MAAM,CAAC,KAAK,EAAE,OAAO;IAIZ,MAAM,CAAC,IAAI,EAAE,aAAa,EAAE,CAAC,KAAK,CAAC,EAAE,mBAAmB,CAAC,IAAI,CAAC;CA0BxE;AAED;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,eAAO,MAAM,IAAI,qFAA2B,CAAC;AAE7C;;;GAGG;AACH,YAAY,EAAC,aAAa,EAAC,CAAC"}

package/front_end/third_party/lit-html/package/directives/live.js

@@ -1,7 +1,4 @@
-import{isSingleExpression as o,setCommittedValue as s}from"../directive-helpers.js";
-import{directive as i,Directive as t,PartType as n}from"../directive.js";
-import{noChange as r,nothing as e}from"../lit-html.js";
-
+import{noChange as r,nothing as e}from"../lit-html.js";import{directive as i,Directive as t,PartType as n}from"../directive.js";import{isSingleExpression as o,setCommittedValue as s}from"../directive-helpers.js";
 /**
  * @license
  * Copyright 2020 Google LLC

package/front_end/third_party/lit-html/package/directives/live.js.map

@@ -1 +1 @@
-{"version":3,"file":"live.js","sources":["../src/directives/live.ts"],"sourcesContent":["/**\n * @license\n * Copyright 2020 Google LLC\n * SPDX-License-Identifier: BSD-3-Clause\n */\n\nimport {AttributePart, noChange, nothing} from '../lit-html.js';\nimport {\n  directive,\n  Directive,\n  DirectiveParameters,\n  PartInfo,\n  PartType,\n} from '../directive.js';\nimport {isSingleExpression, setCommittedValue} from '../directive-helpers.js';\n\nclass LiveDirective extends Directive {\n  constructor(partInfo: PartInfo) {\n    super(partInfo);\n    if (\n      !(\n        partInfo.type === PartType.PROPERTY ||\n        partInfo.type === PartType.ATTRIBUTE ||\n        partInfo.type === PartType.BOOLEAN_ATTRIBUTE\n      )\n    ) {\n      throw new Error(\n        'The `live` directive is not allowed on child or event bindings'\n      );\n    }\n    if (!isSingleExpression(partInfo)) {\n      throw new Error('`live` bindings can only contain a single expression');\n    }\n  }\n\n  render(value: unknown) {\n    return value;\n  }\n\n  update(part: AttributePart, [value]: DirectiveParameters<this>) {\n    if (value === noChange || value === nothing) {\n      return value;\n    }\n    const element = part.element;\n    const name = part.name;\n\n    // TODO (justinfagnani): This is essentially implementing a getLiveValue()\n    // method for each part type. Should that be moved into the AttributePart\n    // interface?\n    if (part.type === PartType.PROPERTY) {\n      // eslint-disable-next-line @typescript-eslint/no-explicit-any\n      if (value === (element as any)[name]) {\n        return noChange;\n      }\n    } else if (part.type === PartType.BOOLEAN_ATTRIBUTE) {\n      if (!!value === element.hasAttribute(name)) {\n        return noChange;\n      }\n    } else if (part.type === PartType.ATTRIBUTE) {\n      if (element.getAttribute(name) === String(value)) {\n        return noChange;\n      }\n    }\n    // Resets the part's value, causing its dirty-check to fail so that it\n    // always sets the value.\n    setCommittedValue(part);\n    return value;\n  }\n}\n\n/**\n * Checks binding values against live DOM values, instead of previously bound\n * values, when determining whether to update the value.\n *\n * This is useful for cases where the DOM value may change from outside of\n * lit-html, such as with a binding to an `<input>` element's `value` property,\n * a content editable elements text, or to a custom element that changes it's\n * own properties or attributes.\n *\n * In these cases if the DOM value changes, but the value set through lit-html\n * bindings hasn't, lit-html won't know to update the DOM value and will leave\n * it alone. If this is not what you want--if you want to overwrite the DOM\n * value with the bound value no matter what--use the `live()` directive:\n *\n *     html`<input .value=${live(x)}>`\n *\n * `live()` performs a strict equality check agains the live DOM value, and if\n * the new value is equal to the live value, does nothing. This means that\n * `live()` should not be used when the binding will cause a type conversion. If\n * you use `live()` with an attribute binding, make sure that only strings are\n * passed in, or the binding will update every render.\n */\nexport const live = directive(LiveDirective);\n\n/**\n * The type of the class that powers this directive. Necessary for naming the\n * directive's return type.\n */\nexport type {LiveDirective};\n"],"names":["live","directive","Directive","[object Object]","partInfo","super","type","PartType","PROPERTY","ATTRIBUTE","BOOLEAN_ATTRIBUTE","Error","isSingleExpression","value","part","noChange","nothing","element","name","hasAttribute","getAttribute","String","setCommittedValue"],"mappings":";;;;;SA4FaA,EAAOC,EA5EpB,cAA4BC,EAC1BC,YAAYC,GAEV,GADAC,MAAMD,GAGFA,EAASE,OAASC,EAASC,UAC3BJ,EAASE,OAASC,EAASE,WAC3BL,EAASE,OAASC,EAASG,kBAG7B,MAAUC,MACR,kEAGJ,IAAKC,EAAmBR,GACtB,MAAUO,MAAM,wDAIpBR,OAAOU,GACL,OAAOA,EAGTV,OAAOW,GAAsBD,IAC3B,GAAIA,IAAUE,GAAYF,IAAUG,EAClC,OAAOH,EAET,MAAMI,EAAUH,EAAKG,QACfC,EAAOJ,EAAKI,KAKlB,GAAIJ,EAAKR,OAASC,EAASC,UAEzB,GAAIK,IAAWI,EAAgBC,GAC7B,OAAOH,OAEJ,GAAID,EAAKR,OAASC,EAASG,mBAChC,KAAMG,IAAUI,EAAQE,aAAaD,GACnC,OAAOH,OAEJ,GAAID,EAAKR,OAASC,EAASE,WAC5BQ,EAAQG,aAAaF,KAAiBL,EAAPQ,GACjC,OAAON,EAMX,OADAO,EAAkBR,GACXD"}
+{"version":3,"file":"live.js","sources":["../src/directives/live.ts"],"sourcesContent":["/**\n * @license\n * Copyright 2020 Google LLC\n * SPDX-License-Identifier: BSD-3-Clause\n */\n\nimport {AttributePart, noChange, nothing} from '../lit-html.js';\nimport {\n  directive,\n  Directive,\n  DirectiveParameters,\n  PartInfo,\n  PartType,\n} from '../directive.js';\nimport {isSingleExpression, setCommittedValue} from '../directive-helpers.js';\n\nclass LiveDirective extends Directive {\n  constructor(partInfo: PartInfo) {\n    super(partInfo);\n    if (\n      !(\n        partInfo.type === PartType.PROPERTY ||\n        partInfo.type === PartType.ATTRIBUTE ||\n        partInfo.type === PartType.BOOLEAN_ATTRIBUTE\n      )\n    ) {\n      throw new Error(\n        'The `live` directive is not allowed on child or event bindings'\n      );\n    }\n    if (!isSingleExpression(partInfo)) {\n      throw new Error('`live` bindings can only contain a single expression');\n    }\n  }\n\n  render(value: unknown) {\n    return value;\n  }\n\n  override update(part: AttributePart, [value]: DirectiveParameters<this>) {\n    if (value === noChange || value === nothing) {\n      return value;\n    }\n    const element = part.element;\n    const name = part.name;\n\n    if (part.type === PartType.PROPERTY) {\n      // eslint-disable-next-line @typescript-eslint/no-explicit-any\n      if (value === (element as any)[name]) {\n        return noChange;\n      }\n    } else if (part.type === PartType.BOOLEAN_ATTRIBUTE) {\n      if (!!value === element.hasAttribute(name)) {\n        return noChange;\n      }\n    } else if (part.type === PartType.ATTRIBUTE) {\n      if (element.getAttribute(name) === String(value)) {\n        return noChange;\n      }\n    }\n    // Resets the part's value, causing its dirty-check to fail so that it\n    // always sets the value.\n    setCommittedValue(part);\n    return value;\n  }\n}\n\n/**\n * Checks binding values against live DOM values, instead of previously bound\n * values, when determining whether to update the value.\n *\n * This is useful for cases where the DOM value may change from outside of\n * lit-html, such as with a binding to an `<input>` element's `value` property,\n * a content editable elements text, or to a custom element that changes it's\n * own properties or attributes.\n *\n * In these cases if the DOM value changes, but the value set through lit-html\n * bindings hasn't, lit-html won't know to update the DOM value and will leave\n * it alone. If this is not what you want--if you want to overwrite the DOM\n * value with the bound value no matter what--use the `live()` directive:\n *\n * ```js\n * html`<input .value=${live(x)}>`\n * ```\n *\n * `live()` performs a strict equality check agains the live DOM value, and if\n * the new value is equal to the live value, does nothing. This means that\n * `live()` should not be used when the binding will cause a type conversion. If\n * you use `live()` with an attribute binding, make sure that only strings are\n * passed in, or the binding will update every render.\n */\nexport const live = directive(LiveDirective);\n\n/**\n * The type of the class that powers this directive. Necessary for naming the\n * directive's return type.\n */\nexport type {LiveDirective};\n"],"names":["live","directive","Directive","constructor","partInfo","super","type","PartType","PROPERTY","ATTRIBUTE","BOOLEAN_ATTRIBUTE","Error","isSingleExpression","render","value","update","part","noChange","nothing","element","name","hasAttribute","getAttribute","String","setCommittedValue"],"mappings":";;;;;SA2FaA,EAAOC,EA3EpB,cAA4BC,EAC1BC,YAAYC,GAEV,GADAC,MAAMD,GAGFA,EAASE,OAASC,EAASC,UAC3BJ,EAASE,OAASC,EAASE,WAC3BL,EAASE,OAASC,EAASG,kBAG7B,MAAUC,MACR,kEAGJ,IAAKC,EAAmBR,GACtB,MAAUO,MAAM,wDAIpBE,OAAOC,GACL,OAAOA,EAGAC,OAAOC,GAAsBF,IACpC,GAAIA,IAAUG,GAAYH,IAAUI,EAClC,OAAOJ,EAET,MAAMK,EAAUH,EAAKG,QACfC,EAAOJ,EAAKI,KAElB,GAAIJ,EAAKV,OAASC,EAASC,UAEzB,GAAIM,IAAWK,EAAgBC,GAC7B,OAAOH,OAEJ,GAAID,EAAKV,OAASC,EAASG,mBAChC,KAAMI,IAAUK,EAAQE,aAAaD,GACnC,OAAOH,OAEJ,GAAID,EAAKV,OAASC,EAASE,WAC5BU,EAAQG,aAAaF,KAAiBN,EAAPS,GACjC,OAAON,EAMX,OADAO,EAAkBR,GACXF"}

package/front_end/third_party/lit-html/package/directives/private-async-helpers.d.ts

@@ -0,0 +1,58 @@
+/**
+ * @license
+ * Copyright 2021 Google LLC
+ * SPDX-License-Identifier: BSD-3-Clause
+ */
+/**
+ * Helper to iterate an AsyncIterable in its own closure.
+ * @param iterable The iterable to iterate
+ * @param callback The callback to call for each value. If the callback returns
+ * `false`, the loop will be broken.
+ */
+export declare const forAwaitOf: <T>(iterable: AsyncIterable<T>, callback: (value: T) => Promise<boolean>) => Promise<void>;
+/**
+ * Holds a reference to an instance that can be disconnected and reconnected,
+ * so that a closure over the ref (e.g. in a then function to a promise) does
+ * not strongly hold a ref to the instance. Approximates a WeakRef but must
+ * be manually connected & disconnected to the backing instance.
+ */
+export declare class PseudoWeakRef<T> {
+    private _ref?;
+    constructor(ref: T);
+    /**
+     * Disassociates the ref with the backing instance.
+     */
+    disconnect(): void;
+    /**
+     * Reassociates the ref with the backing instance.
+     */
+    reconnect(ref: T): void;
+    /**
+     * Retrieves the backing instance (will be undefined when disconnected)
+     */
+    deref(): T | undefined;
+}
+/**
+ * A helper to pause and resume waiting on a condition in an async function
+ */
+export declare class Pauser {
+    private _promise?;
+    private _resolve?;
+    /**
+     * When paused, returns a promise to be awaited; when unpaused, returns
+     * undefined. Note that in the microtask between the pauser being resumed
+     * an an await of this promise resolving, the pauser could be paused again,
+     * hence callers should check the promise in a loop when awaiting.
+     * @returns A promise to be awaited when paused or undefined
+     */
+    get(): Promise<void> | undefined;
+    /**
+     * Creates a promise to be awaited
+     */
+    pause(): void;
+    /**
+     * Resolves the promise which may be awaited
+     */
+    resume(): void;
+}
+//# sourceMappingURL=private-async-helpers.d.ts.map

package/front_end/third_party/lit-html/package/directives/private-async-helpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"private-async-helpers.d.ts","sourceRoot":"","sources":["../../src/directives/private-async-helpers.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAMH;;;;;GAKG;AACH,eAAO,MAAM,UAAU,0DAEG,QAAQ,OAAO,CAAC,kBAOzC,CAAC;AAEF;;;;;GAKG;AACH,qBAAa,aAAa,CAAC,CAAC;IAC1B,OAAO,CAAC,IAAI,CAAC,CAAI;gBACL,GAAG,EAAE,CAAC;IAGlB;;OAEG;IACH,UAAU;IAGV;;OAEG;IACH,SAAS,CAAC,GAAG,EAAE,CAAC;IAGhB;;OAEG;IACH,KAAK;CAGN;AAED;;GAEG;AACH,qBAAa,MAAM;IACjB,OAAO,CAAC,QAAQ,CAAC,CAA4B;IAC7C,OAAO,CAAC,QAAQ,CAAC,CAAyB;IAC1C;;;;;;OAMG;IACH,GAAG;IAGH;;OAEG;IACH,KAAK;IAGL;;OAEG;IACH,MAAM;CAIP"}

package/front_end/third_party/lit-html/package/directives/private-async-helpers.js

@@ -0,0 +1,7 @@
+/**
+ * @license
+ * Copyright 2021 Google LLC
+ * SPDX-License-Identifier: BSD-3-Clause
+ */
+const t=async(t,s)=>{for await(const i of t)if(!1===await s(i))return};class s{constructor(t){this.U=t}disconnect(){this.U=void 0}reconnect(t){this.U=t}deref(){return this.U}}class i{constructor(){this.Y=void 0,this.q=void 0}get(){return this.Y}pause(){var t;null!==(t=this.Y)&&void 0!==t||(this.Y=new Promise((t=>this.q=t)))}resume(){var t;null===(t=this.q)||void 0===t||t.call(this),this.Y=this.q=void 0}}export{i as Pauser,s as PseudoWeakRef,t as forAwaitOf};
+//# sourceMappingURL=private-async-helpers.js.map

package/front_end/third_party/lit-html/package/directives/private-async-helpers.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"private-async-helpers.js","sources":["../src/directives/private-async-helpers.ts"],"sourcesContent":["/**\n * @license\n * Copyright 2021 Google LLC\n * SPDX-License-Identifier: BSD-3-Clause\n */\n\n// Note, this module is not included in package exports so that it's private to\n// our first-party directives. If it ends up being useful, we can open it up and\n// export it.\n\n/**\n * Helper to iterate an AsyncIterable in its own closure.\n * @param iterable The iterable to iterate\n * @param callback The callback to call for each value. If the callback returns\n * `false`, the loop will be broken.\n */\nexport const forAwaitOf = async <T>(\n  iterable: AsyncIterable<T>,\n  callback: (value: T) => Promise<boolean>\n) => {\n  for await (const v of iterable) {\n    if ((await callback(v)) === false) {\n      return;\n    }\n  }\n};\n\n/**\n * Holds a reference to an instance that can be disconnected and reconnected,\n * so that a closure over the ref (e.g. in a then function to a promise) does\n * not strongly hold a ref to the instance. Approximates a WeakRef but must\n * be manually connected & disconnected to the backing instance.\n */\nexport class PseudoWeakRef<T> {\n  private _ref?: T;\n  constructor(ref: T) {\n    this._ref = ref;\n  }\n  /**\n   * Disassociates the ref with the backing instance.\n   */\n  disconnect() {\n    this._ref = undefined;\n  }\n  /**\n   * Reassociates the ref with the backing instance.\n   */\n  reconnect(ref: T) {\n    this._ref = ref;\n  }\n  /**\n   * Retrieves the backing instance (will be undefined when disconnected)\n   */\n  deref() {\n    return this._ref;\n  }\n}\n\n/**\n * A helper to pause and resume waiting on a condition in an async function\n */\nexport class Pauser {\n  private _promise?: Promise<void> = undefined;\n  private _resolve?: () => void = undefined;\n  /**\n   * When paused, returns a promise to be awaited; when unpaused, returns\n   * undefined. Note that in the microtask between the pauser being resumed\n   * an an await of this promise resolving, the pauser could be paused again,\n   * hence callers should check the promise in a loop when awaiting.\n   * @returns A promise to be awaited when paused or undefined\n   */\n  get() {\n    return this._promise;\n  }\n  /**\n   * Creates a promise to be awaited\n   */\n  pause() {\n    this._promise ??= new Promise((resolve) => (this._resolve = resolve));\n  }\n  /**\n   * Resolves the promise which may be awaited\n   */\n  resume() {\n    this._resolve?.();\n    this._promise = this._resolve = undefined;\n  }\n}\n"],"names":["forAwaitOf","async","iterable","callback","v","PseudoWeakRef","constructor","ref","this","_ref","disconnect","undefined","reconnect","deref","Pauser","get","_promise","pause","Promise","resolve","_resolve","resume"],"mappings":";;;;;MAgBaA,EAAaC,MACxBC,EACAC,KAEA,UAAW,MAAMC,KAAKF,EACpB,IAA4B,UAAjBC,EAASC,GAClB,cAWOC,EAEXC,YAAYC,GACVC,KAAKC,EAAOF,EAKdG,aACEF,KAAKC,OAAOE,EAKdC,UAAUL,GACRC,KAAKC,EAAOF,EAKdM,QACE,OAAOL,KAAKC,SAOHK,EAAbR,cACUE,YAA2BG,EAC3BH,YAAwBG,EAQhCI,MACE,OAAOP,KAAKQ,EAKdC,wBACET,KAAKQ,iBAALR,KAAKQ,EAAa,IAAIE,SAASC,GAAaX,KAAKY,EAAWD,KAK9DE,yBACEb,KAAKY,uBAALZ,MACAA,KAAKQ,EAAWR,KAAKY,OAAWT"}

package/front_end/third_party/lit-html/package/directives/ref.d.ts

@@ -3,13 +3,15 @@
  * Copyright 2020 Google LLC
  * SPDX-License-Identifier: BSD-3-Clause
  */
-import { AsyncDirective } from '../async-directive.js';
 import { ElementPart } from '../lit-html.js';
-
+import { AsyncDirective } from '../async-directive.js';
 /**
  * Creates a new Ref object, which is container for a reference to an element.
  */
 export declare const createRef: <T = Element>() => Ref<T>;
+/**
+ * An object that holds a ref value.
+ */
 declare class Ref<T = Element> {
     /**
      * The current Element value of the ref, or else `undefined` if the ref is no
@@ -17,6 +19,7 @@ declare class Ref<T = Element> {
      */
     readonly value?: T;
 }
+export type { Ref };
 export declare type RefOrCallback = Ref | ((el: Element | undefined) => void);
 declare class RefDirective extends AsyncDirective {
     private _element?;
@@ -43,16 +46,16 @@ declare class RefDirective extends AsyncDirective {
  * removed in a subsequent render, it will first be called with `undefined`,
  * followed by another call with the new element it was rendered to (if any).
  *
- * @example
- *
- *    // Using Ref object
- *    const inputRef = createRef();
- *    render(html`<input ${ref(inputRef)}>`, container);
- *    inputRef.value.focus();
+ * ```js
+ * // Using Ref object
+ * const inputRef = createRef();
+ * render(html`<input ${ref(inputRef)}>`, container);
+ * inputRef.value.focus();
  *
- *    // Using callback
- *    const callback = (inputElement) => inputElement.focus();
- *    render(html`<input ${ref(callback)}>`, container);
+ * // Using callback
+ * const callback = (inputElement) => inputElement.focus();
+ * render(html`<input ${ref(callback)}>`, container);
+ * ```
  */
 export declare const ref: (_ref: RefOrCallback) => import("../directive.js").DirectiveResult<typeof RefDirective>;
 /**

package/front_end/third_party/lit-html/package/directives/ref.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ref.d.ts","sourceRoot":"","sources":["../../src/directives/ref.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,OAAO,EAAU,WAAW,EAAC,MAAM,gBAAgB,CAAC;AACpD,OAAO,EAAY,cAAc,EAAC,MAAM,uBAAuB,CAAC;AAEhE;;GAEG;AACH,eAAO,MAAM,SAAS,2BAAkC,CAAC;AAEzD,cAAM,GAAG,CAAC,CAAC,GAAG,OAAO;IACnB;;;OAGG;IACH,QAAQ,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC;CACpB;AAcD,oBAAY,aAAa,GAAG,GAAG,GAAG,CAAC,CAAC,EAAE,EAAE,OAAO,GAAG,SAAS,KAAK,IAAI,CAAC,CAAC;AAEtE,cAAM,YAAa,SAAQ,cAAc;IACvC,OAAO,CAAC,QAAQ,CAAC,CAAU;IAC3B,OAAO,CAAC,IAAI,CAAC,CAAgB;IAC7B,OAAO,CAAC,QAAQ,CAAU;IAE1B,MAAM,CAAC,IAAI,EAAE,aAAa;IAI1B,MAAM,CAAC,IAAI,EAAE,WAAW,EAAE,CAAC,GAAG,CAAC,EAAE,UAAU,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;IAiB3D,OAAO,CAAC,eAAe;IAqBvB,OAAO,KAAK,kBAAkB,GAI7B;IAED,YAAY;IAUZ,WAAW;CAKZ;AAED;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,eAAO,MAAM,GAAG,yFAA0B,CAAC;AAE3C;;;GAGG;AACH,YAAY,EAAC,YAAY,EAAC,CAAC"}
+{"version":3,"file":"ref.d.ts","sourceRoot":"","sources":["../../src/directives/ref.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,OAAO,EAAU,WAAW,EAAC,MAAM,gBAAgB,CAAC;AACpD,OAAO,EAAY,cAAc,EAAC,MAAM,uBAAuB,CAAC;AAEhE;;GAEG;AACH,eAAO,MAAM,SAAS,2BAAkC,CAAC;AAEzD;;GAEG;AACH,cAAM,GAAG,CAAC,CAAC,GAAG,OAAO;IACnB;;;OAGG;IACH,QAAQ,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC;CACpB;AAED,YAAY,EAAC,GAAG,EAAC,CAAC;AAYlB,oBAAY,aAAa,GAAG,GAAG,GAAG,CAAC,CAAC,EAAE,EAAE,OAAO,GAAG,SAAS,KAAK,IAAI,CAAC,CAAC;AAEtE,cAAM,YAAa,SAAQ,cAAc;IACvC,OAAO,CAAC,QAAQ,CAAC,CAAU;IAC3B,OAAO,CAAC,IAAI,CAAC,CAAgB;IAC7B,OAAO,CAAC,QAAQ,CAAU;IAE1B,MAAM,CAAC,IAAI,EAAE,aAAa;IAIjB,MAAM,CAAC,IAAI,EAAE,WAAW,EAAE,CAAC,GAAG,CAAC,EAAE,UAAU,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;IAiBpE,OAAO,CAAC,eAAe;IAqBvB,OAAO,KAAK,kBAAkB,GAI7B;IAEQ,YAAY;IAUZ,WAAW;CAKrB;AAED;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,eAAO,MAAM,GAAG,yFAA0B,CAAC;AAE3C;;;GAGG;AACH,YAAY,EAAC,YAAY,EAAC,CAAC"}

package/front_end/third_party/lit-html/package/directives/ref.js

@@ -1,10 +1,7 @@
-import{AsyncDirective as s}from"../async-directive.js";
-import{directive as i}from"../directive.js";
-import{nothing as t}from"../lit-html.js";
-
+import{nothing as t}from"../lit-html.js";import{AsyncDirective as i}from"../async-directive.js";import{directive as s}from"../directive.js";
 /**
  * @license
  * Copyright 2020 Google LLC
  * SPDX-License-Identifier: BSD-3-Clause
- */const e=()=>new o;class o{}const h=new WeakMap,n=i(class extends s{render(i){return t}update(i,[s]){var e;const o=s!==this.gt;return o&&void 0!==this.gt&&this.xt(void 0),(o||this.Tt!==this.Et)&&(this.gt=s,this.At=null===(e=i.options)||void 0===e?void 0:e.host,this.xt(this.Et=i.element)),t}xt(t){"function"==typeof this.gt?(void 0!==h.get(this.gt)&&this.gt.call(this.At,void 0),h.set(this.gt,t),void 0!==t&&this.gt.call(this.At,t)):this.gt.value=t}get Tt(){var t;return"function"==typeof this.gt?h.get(this.gt):null===(t=this.gt)||void 0===t?void 0:t.value}disconnected(){this.Tt===this.Et&&this.xt(void 0)}reconnected(){this.xt(this.Et)}});export{e as createRef,n as ref};
+ */const e=()=>new o;class o{}const h=new WeakMap,n=s(class extends i{render(i){return t}update(i,[s]){var e;const o=s!==this.U;return o&&void 0!==this.U&&this.nt(void 0),(o||this.rt!==this.lt)&&(this.U=s,this.ht=null===(e=i.options)||void 0===e?void 0:e.host,this.nt(this.lt=i.element)),t}nt(t){"function"==typeof this.U?(void 0!==h.get(this.U)&&this.U.call(this.ht,void 0),h.set(this.U,t),void 0!==t&&this.U.call(this.ht,t)):this.U.value=t}get rt(){var t;return"function"==typeof this.U?h.get(this.U):null===(t=this.U)||void 0===t?void 0:t.value}disconnected(){this.rt===this.lt&&this.nt(void 0)}reconnected(){this.nt(this.lt)}});export{e as createRef,n as ref};
 //# sourceMappingURL=ref.js.map

package/front_end/third_party/lit-html/package/directives/ref.js.map

@@ -1 +1 @@
-{"version":3,"file":"ref.js","sources":["../src/directives/ref.ts"],"sourcesContent":["/**\n * @license\n * Copyright 2020 Google LLC\n * SPDX-License-Identifier: BSD-3-Clause\n */\nimport {nothing, ElementPart} from '../lit-html.js';\nimport {directive, AsyncDirective} from '../async-directive.js';\n\n/**\n * Creates a new Ref object, which is container for a reference to an element.\n */\nexport const createRef = <T = Element>() => new Ref<T>();\n\nclass Ref<T = Element> {\n  /**\n   * The current Element value of the ref, or else `undefined` if the ref is no\n   * longer rendered.\n   */\n  readonly value?: T;\n}\n\ninterface RefInternal {\n  value: Element | undefined;\n}\n\n// When callbacks are used for refs, this map tracks the last value the callback\n// was called with, for ensuring a directive doesn't clear the ref if the ref\n// has already been rendered to a new spot\nconst lastElementForCallback: WeakMap<\n  Function,\n  Element | undefined\n> = new WeakMap();\n\nexport type RefOrCallback = Ref | ((el: Element | undefined) => void);\n\nclass RefDirective extends AsyncDirective {\n  private _element?: Element;\n  private _ref?: RefOrCallback;\n  private _context: unknown;\n\n  render(_ref: RefOrCallback) {\n    return nothing;\n  }\n\n  update(part: ElementPart, [ref]: Parameters<this['render']>) {\n    const refChanged = ref !== this._ref;\n    if (refChanged && this._ref !== undefined) {\n      // The ref passed to the directive has changed;\n      // unset the previous ref's value\n      this._updateRefValue(undefined);\n    }\n    if (refChanged || this._lastElementForRef !== this._element) {\n      // We either got a new ref or this is the first render;\n      // store the ref/element & update the ref value\n      this._ref = ref;\n      this._context = part.options?.host;\n      this._updateRefValue((this._element = part.element));\n    }\n    return nothing;\n  }\n\n  private _updateRefValue(element: Element | undefined) {\n    if (typeof this._ref === 'function') {\n      // If the current ref was called with a previous value, call with\n      // `undefined`; We do this to ensure callbacks are called in a consistent\n      // way regardless of whether a ref might be moving up in the tree (in\n      // which case it would otherwise be called with the new value before the\n      // previous one unsets it) and down in the tree (where it would be unset\n      // before being set)\n      if (lastElementForCallback.get(this._ref) !== undefined) {\n        this._ref.call(this._context, undefined);\n      }\n      lastElementForCallback.set(this._ref, element);\n      // Call the ref with the new element value\n      if (element !== undefined) {\n        this._ref.call(this._context, element);\n      }\n    } else {\n      (this._ref as RefInternal)!.value = element;\n    }\n  }\n\n  private get _lastElementForRef() {\n    return typeof this._ref === 'function'\n      ? lastElementForCallback.get(this._ref)\n      : this._ref?.value;\n  }\n\n  disconnected() {\n    // Only clear the box if our element is still the one in it (i.e. another\n    // directive instance hasn't rendered its element to it before us); that\n    // only happens in the event of the directive being cleared (not via manual\n    // disconnection)\n    if (this._lastElementForRef === this._element) {\n      this._updateRefValue(undefined);\n    }\n  }\n\n  reconnected() {\n    // If we were manually disconnected, we can safely put our element back in\n    // the box, since no rendering could have occurred to change its state\n    this._updateRefValue(this._element);\n  }\n}\n\n/**\n * Sets the value of a Ref object or calls a ref callback with the element it's\n * bound to.\n *\n * A Ref object acts as a container for a reference to an element. A ref\n * callback is a function that takes an element as its only argument.\n *\n * The ref directive sets the value of the Ref object or calls the ref callback\n * during rendering, if the referenced element changed.\n *\n * Note: If a ref callback is rendered to a different element position or is\n * removed in a subsequent render, it will first be called with `undefined`,\n * followed by another call with the new element it was rendered to (if any).\n *\n * @example\n *\n *    // Using Ref object\n *    const inputRef = createRef();\n *    render(html`<input ${ref(inputRef)}>`, container);\n *    inputRef.value.focus();\n *\n *    // Using callback\n *    const callback = (inputElement) => inputElement.focus();\n *    render(html`<input ${ref(callback)}>`, container);\n */\nexport const ref = directive(RefDirective);\n\n/**\n * The type of the class that powers this directive. Necessary for naming the\n * directive's return type.\n */\nexport type {RefDirective};\n"],"names":["createRef","Ref","lastElementForCallback","WeakMap","ref","directive","AsyncDirective","[object Object]","_ref","nothing","part","refChanged","this","undefined","_updateRefValue","_lastElementForRef","_element","_context","options","host","element","get","call","set","value","Tt"],"mappings":";;;;;SAWaA,EAAY,IAAmB,IAAIC,EAEhD,MAAMA,GAeN,MAAMC,EAGF,IAAIC,QAmGKC,EAAMC,EA/FnB,cAA2BC,EAKzBC,OAAOC,GACL,OAAOC,EAGTF,OAAOG,GAAoBN,UACzB,MAAMO,EAAaP,IAAQQ,KAAKJ,GAahC,OAZIG,QAA4BE,IAAdD,KAAKJ,IAGrBI,KAAKE,QAAgBD,IAEnBF,GAAcC,KAAKG,KAAuBH,KAAKI,MAGjDJ,KAAKJ,GAAOJ,EACZQ,KAAKK,aAAWP,EAAKQ,8BAASC,KAC9BP,KAAKE,GAAiBF,KAAKI,GAAWN,EAAKU,UAEtCX,EAGDF,GAAgBa,GACG,mBAAdR,KAAKJ,SAOgCK,IAA1CX,EAAuBmB,IAAIT,KAAKJ,KAClCI,KAAKJ,GAAKc,KAAKV,KAAKK,QAAUJ,GAEhCX,EAAuBqB,IAAIX,KAAKJ,GAAMY,QAEtBP,IAAZO,GACFR,KAAKJ,GAAKc,KAAKV,KAAKK,GAAUG,IAG/BR,KAAKJ,GAAsBgB,MAAQJ,EAIxCK,eACE,MAA4B,mBAAdb,KAAKJ,GACfN,EAAuBmB,IAAIT,KAAKJ,cAChCI,KAAKJ,yBAAMgB,MAGjBjB,eAKMK,KAAKG,KAAuBH,KAAKI,IACnCJ,KAAKE,QAAgBD,GAIzBN,cAGEK,KAAKE,GAAgBF,KAAKI"}
+{"version":3,"file":"ref.js","sources":["../src/directives/ref.ts"],"sourcesContent":["/**\n * @license\n * Copyright 2020 Google LLC\n * SPDX-License-Identifier: BSD-3-Clause\n */\nimport {nothing, ElementPart} from '../lit-html.js';\nimport {directive, AsyncDirective} from '../async-directive.js';\n\n/**\n * Creates a new Ref object, which is container for a reference to an element.\n */\nexport const createRef = <T = Element>() => new Ref<T>();\n\n/**\n * An object that holds a ref value.\n */\nclass Ref<T = Element> {\n  /**\n   * The current Element value of the ref, or else `undefined` if the ref is no\n   * longer rendered.\n   */\n  readonly value?: T;\n}\n\nexport type {Ref};\n\ninterface RefInternal {\n  value: Element | undefined;\n}\n\n// When callbacks are used for refs, this map tracks the last value the callback\n// was called with, for ensuring a directive doesn't clear the ref if the ref\n// has already been rendered to a new spot\nconst lastElementForCallback: WeakMap<Function, Element | undefined> =\n  new WeakMap();\n\nexport type RefOrCallback = Ref | ((el: Element | undefined) => void);\n\nclass RefDirective extends AsyncDirective {\n  private _element?: Element;\n  private _ref?: RefOrCallback;\n  private _context: unknown;\n\n  render(_ref: RefOrCallback) {\n    return nothing;\n  }\n\n  override update(part: ElementPart, [ref]: Parameters<this['render']>) {\n    const refChanged = ref !== this._ref;\n    if (refChanged && this._ref !== undefined) {\n      // The ref passed to the directive has changed;\n      // unset the previous ref's value\n      this._updateRefValue(undefined);\n    }\n    if (refChanged || this._lastElementForRef !== this._element) {\n      // We either got a new ref or this is the first render;\n      // store the ref/element & update the ref value\n      this._ref = ref;\n      this._context = part.options?.host;\n      this._updateRefValue((this._element = part.element));\n    }\n    return nothing;\n  }\n\n  private _updateRefValue(element: Element | undefined) {\n    if (typeof this._ref === 'function') {\n      // If the current ref was called with a previous value, call with\n      // `undefined`; We do this to ensure callbacks are called in a consistent\n      // way regardless of whether a ref might be moving up in the tree (in\n      // which case it would otherwise be called with the new value before the\n      // previous one unsets it) and down in the tree (where it would be unset\n      // before being set)\n      if (lastElementForCallback.get(this._ref) !== undefined) {\n        this._ref.call(this._context, undefined);\n      }\n      lastElementForCallback.set(this._ref, element);\n      // Call the ref with the new element value\n      if (element !== undefined) {\n        this._ref.call(this._context, element);\n      }\n    } else {\n      (this._ref as RefInternal)!.value = element;\n    }\n  }\n\n  private get _lastElementForRef() {\n    return typeof this._ref === 'function'\n      ? lastElementForCallback.get(this._ref)\n      : this._ref?.value;\n  }\n\n  override disconnected() {\n    // Only clear the box if our element is still the one in it (i.e. another\n    // directive instance hasn't rendered its element to it before us); that\n    // only happens in the event of the directive being cleared (not via manual\n    // disconnection)\n    if (this._lastElementForRef === this._element) {\n      this._updateRefValue(undefined);\n    }\n  }\n\n  override reconnected() {\n    // If we were manually disconnected, we can safely put our element back in\n    // the box, since no rendering could have occurred to change its state\n    this._updateRefValue(this._element);\n  }\n}\n\n/**\n * Sets the value of a Ref object or calls a ref callback with the element it's\n * bound to.\n *\n * A Ref object acts as a container for a reference to an element. A ref\n * callback is a function that takes an element as its only argument.\n *\n * The ref directive sets the value of the Ref object or calls the ref callback\n * during rendering, if the referenced element changed.\n *\n * Note: If a ref callback is rendered to a different element position or is\n * removed in a subsequent render, it will first be called with `undefined`,\n * followed by another call with the new element it was rendered to (if any).\n *\n * ```js\n * // Using Ref object\n * const inputRef = createRef();\n * render(html`<input ${ref(inputRef)}>`, container);\n * inputRef.value.focus();\n *\n * // Using callback\n * const callback = (inputElement) => inputElement.focus();\n * render(html`<input ${ref(callback)}>`, container);\n * ```\n */\nexport const ref = directive(RefDirective);\n\n/**\n * The type of the class that powers this directive. Necessary for naming the\n * directive's return type.\n */\nexport type {RefDirective};\n"],"names":["createRef","Ref","lastElementForCallback","WeakMap","ref","directive","AsyncDirective","render","_ref","nothing","update","part","refChanged","this","undefined","_updateRefValue","_lastElementForRef","_element","_context","options","host","element","get","call","set","value","disconnected","reconnected"],"mappings":";;;;;SAWaA,EAAY,IAAmB,IAAIC,EAKhD,MAAMA,GAiBN,MAAMC,EACJ,IAAIC,QAmGOC,EAAMC,EA/FnB,cAA2BC,EAKzBC,OAAOC,GACL,OAAOC,EAGAC,OAAOC,GAAoBP,UAClC,MAAMQ,EAAaR,IAAQS,KAAKL,EAahC,OAZII,QAA4BE,IAAdD,KAAKL,GAGrBK,KAAKE,QAAgBD,IAEnBF,GAAcC,KAAKG,KAAuBH,KAAKI,MAGjDJ,KAAKL,EAAOJ,EACZS,KAAKK,aAAWP,EAAKQ,8BAASC,KAC9BP,KAAKE,GAAiBF,KAAKI,GAAWN,EAAKU,UAEtCZ,EAGDM,GAAgBM,GACG,mBAAdR,KAAKL,QAOgCM,IAA1CZ,EAAuBoB,IAAIT,KAAKL,IAClCK,KAAKL,EAAKe,KAAKV,KAAKK,QAAUJ,GAEhCZ,EAAuBsB,IAAIX,KAAKL,EAAMa,QAEtBP,IAAZO,GACFR,KAAKL,EAAKe,KAAKV,KAAKK,GAAUG,IAG/BR,KAAKL,EAAsBiB,MAAQJ,EAI5BL,eACV,MAA4B,mBAAdH,KAAKL,EACfN,EAAuBoB,IAAIT,KAAKL,aAChCK,KAAKL,wBAAMiB,MAGRC,eAKHb,KAAKG,KAAuBH,KAAKI,IACnCJ,KAAKE,QAAgBD,GAIhBa,cAGPd,KAAKE,GAAgBF,KAAKI"}