@thegetty/quire-cli 0.20.4 → 1.0.0-pre-release.1

package/src/lib/quire/versions/1.0.0-pre-release.2/node_modules/@lit/reactive-element/development/decorators/base.d.ts

@@ -0,0 +1,48 @@
+/**
+ * @license
+ * Copyright 2017 Google LLC
+ * SPDX-License-Identifier: BSD-3-Clause
+ */
+import { ReactiveElement } from '../reactive-element.js';
+export declare type Constructor<T> = {
+    new (...args: any[]): T;
+};
+export interface ClassDescriptor {
+    kind: 'class';
+    elements: ClassElement[];
+    finisher?: <T>(clazz: Constructor<T>) => void | Constructor<T>;
+}
+export interface ClassElement {
+    kind: 'field' | 'method';
+    key: PropertyKey;
+    placement: 'static' | 'prototype' | 'own';
+    initializer?: Function;
+    extras?: ClassElement[];
+    finisher?: <T>(clazz: Constructor<T>) => void | Constructor<T>;
+    descriptor?: PropertyDescriptor;
+}
+export declare const legacyPrototypeMethod: (descriptor: PropertyDescriptor, proto: Object, name: PropertyKey) => void;
+export declare const standardPrototypeMethod: (descriptor: PropertyDescriptor, element: ClassElement) => {
+    kind: string;
+    placement: string;
+    key: PropertyKey;
+    descriptor: PropertyDescriptor;
+};
+/**
+ * Helper for decorating a property that is compatible with both TypeScript
+ * and Babel decorators. The optional `finisher` can be used to perform work on
+ * the class. The optional `descriptor` should return a PropertyDescriptor
+ * to install for the given property.
+ *
+ * @param finisher {function} Optional finisher method; receives the element
+ * constructor and property key as arguments and has no return value.
+ * @param descriptor {function} Optional descriptor method; receives the
+ * property key as an argument and returns a property descriptor to define for
+ * the given property.
+ * @returns {ClassElement|void}
+ */
+export declare const decorateProperty: ({ finisher, descriptor, }: {
+    finisher?: ((ctor: typeof ReactiveElement, property: PropertyKey) => void) | null | undefined;
+    descriptor?: ((property: PropertyKey) => PropertyDescriptor) | undefined;
+}) => (protoOrDescriptor: ReactiveElement | ClassElement, name?: PropertyKey) => void | any;
+//# sourceMappingURL=base.d.ts.map

package/src/lib/quire/versions/1.0.0-pre-release.2/node_modules/@lit/reactive-element/development/decorators/base.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"base.d.ts","sourceRoot":"","sources":["../../src/decorators/base.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAC,eAAe,EAAC,MAAM,wBAAwB,CAAC;AAEvD,oBAAY,WAAW,CAAC,CAAC,IAAI;IAE3B,KAAK,GAAG,IAAI,EAAE,GAAG,EAAE,GAAG,CAAC,CAAC;CACzB,CAAC;AAGF,MAAM,WAAW,eAAe;IAC9B,IAAI,EAAE,OAAO,CAAC;IACd,QAAQ,EAAE,YAAY,EAAE,CAAC;IACzB,QAAQ,CAAC,EAAE,CAAC,CAAC,EAAE,KAAK,EAAE,WAAW,CAAC,CAAC,CAAC,KAAK,IAAI,GAAG,WAAW,CAAC,CAAC,CAAC,CAAC;CAChE;AAGD,MAAM,WAAW,YAAY;IAC3B,IAAI,EAAE,OAAO,GAAG,QAAQ,CAAC;IACzB,GAAG,EAAE,WAAW,CAAC;IACjB,SAAS,EAAE,QAAQ,GAAG,WAAW,GAAG,KAAK,CAAC;IAC1C,WAAW,CAAC,EAAE,QAAQ,CAAC;IACvB,MAAM,CAAC,EAAE,YAAY,EAAE,CAAC;IACxB,QAAQ,CAAC,EAAE,CAAC,CAAC,EAAE,KAAK,EAAE,WAAW,CAAC,CAAC,CAAC,KAAK,IAAI,GAAG,WAAW,CAAC,CAAC,CAAC,CAAC;IAC/D,UAAU,CAAC,EAAE,kBAAkB,CAAC;CACjC;AAED,eAAO,MAAM,qBAAqB,eACpB,kBAAkB,SACvB,MAAM,QACP,WAAW,SAGlB,CAAC;AAEF,eAAO,MAAM,uBAAuB,eACtB,kBAAkB,WACrB,YAAY;;;;;CAMrB,CAAC;AAEH;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,gBAAgB;uBAMb,sBAAsB,YAAY,WAAW,KAAK,IAAI;6BAE1C,WAAW,KAAK,kBAAkB;0BAGvC,eAAe,GAAG,YAAY,SAC1C,WAAW,KAGjB,IAAI,GAAG,GAmCT,CAAC"}

package/src/lib/quire/versions/1.0.0-pre-release.2/node_modules/@lit/reactive-element/development/decorators/base.js

@@ -0,0 +1,65 @@
+/**
+ * @license
+ * Copyright 2017 Google LLC
+ * SPDX-License-Identifier: BSD-3-Clause
+ */
+export const legacyPrototypeMethod = (descriptor, proto, name) => {
+    Object.defineProperty(proto, name, descriptor);
+};
+export const standardPrototypeMethod = (descriptor, element) => ({
+    kind: 'method',
+    placement: 'prototype',
+    key: element.key,
+    descriptor,
+});
+/**
+ * Helper for decorating a property that is compatible with both TypeScript
+ * and Babel decorators. The optional `finisher` can be used to perform work on
+ * the class. The optional `descriptor` should return a PropertyDescriptor
+ * to install for the given property.
+ *
+ * @param finisher {function} Optional finisher method; receives the element
+ * constructor and property key as arguments and has no return value.
+ * @param descriptor {function} Optional descriptor method; receives the
+ * property key as an argument and returns a property descriptor to define for
+ * the given property.
+ * @returns {ClassElement|void}
+ */
+export const decorateProperty = ({ finisher, descriptor, }) => (protoOrDescriptor, name
+// Note TypeScript requires the return type to be `void|any`
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+) => {
+    var _a;
+    // TypeScript / Babel legacy mode
+    if (name !== undefined) {
+        const ctor = protoOrDescriptor
+            .constructor;
+        if (descriptor !== undefined) {
+            Object.defineProperty(protoOrDescriptor, name, descriptor(name));
+        }
+        finisher === null || finisher === void 0 ? void 0 : finisher(ctor, name);
+        // Babel standard mode
+    }
+    else {
+        // Note, the @property decorator saves `key` as `originalKey`
+        // so try to use it here.
+        const key = 
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        (_a = protoOrDescriptor.originalKey) !== null && _a !== void 0 ? _a : protoOrDescriptor.key;
+        const info = descriptor != undefined
+            ? {
+                kind: 'method',
+                placement: 'prototype',
+                key,
+                descriptor: descriptor(protoOrDescriptor.key),
+            }
+            : { ...protoOrDescriptor, key };
+        if (finisher != undefined) {
+            info.finisher = function (ctor) {
+                finisher(ctor, key);
+            };
+        }
+        return info;
+    }
+};
+//# sourceMappingURL=base.js.map

package/src/lib/quire/versions/1.0.0-pre-release.2/node_modules/@lit/reactive-element/development/decorators/base.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"base.js","sourceRoot":"","sources":["../../src/decorators/base.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AA2BH,MAAM,CAAC,MAAM,qBAAqB,GAAG,CACnC,UAA8B,EAC9B,KAAa,EACb,IAAiB,EACjB,EAAE;IACF,MAAM,CAAC,cAAc,CAAC,KAAK,EAAE,IAAI,EAAE,UAAU,CAAC,CAAC;AACjD,CAAC,CAAC;AAEF,MAAM,CAAC,MAAM,uBAAuB,GAAG,CACrC,UAA8B,EAC9B,OAAqB,EACrB,EAAE,CAAC,CAAC;IACJ,IAAI,EAAE,QAAQ;IACd,SAAS,EAAE,WAAW;IACtB,GAAG,EAAE,OAAO,CAAC,GAAG;IAChB,UAAU;CACX,CAAC,CAAC;AAEH;;;;;;;;;;;;GAYG;AACH,MAAM,CAAC,MAAM,gBAAgB,GAC3B,CAAC,EACC,QAAQ,EACR,UAAU,GAMX,EAAE,EAAE,CACL,CACE,iBAAiD,EACjD,IAAkB;AAClB,4DAA4D;AAC5D,8DAA8D;EAClD,EAAE;;IACd,iCAAiC;IACjC,IAAI,IAAI,KAAK,SAAS,EAAE;QACtB,MAAM,IAAI,GAAI,iBAAqC;aAChD,WAAqC,CAAC;QACzC,IAAI,UAAU,KAAK,SAAS,EAAE;YAC5B,MAAM,CAAC,cAAc,CAAC,iBAAiB,EAAE,IAAI,EAAE,UAAU,CAAC,IAAI,CAAC,CAAC,CAAC;SAClE;QACD,QAAQ,aAAR,QAAQ,uBAAR,QAAQ,CAAG,IAAI,EAAE,IAAK,CAAC,CAAC;QACxB,sBAAsB;KACvB;SAAM;QACL,6DAA6D;QAC7D,yBAAyB;QACzB,MAAM,GAAG;QACP,8DAA8D;QAC9D,MAAC,iBAAyB,CAAC,WAAW,mCACrC,iBAAkC,CAAC,GAAG,CAAC;QAC1C,MAAM,IAAI,GACR,UAAU,IAAI,SAAS;YACrB,CAAC,CAAC;gBACE,IAAI,EAAE,QAAQ;gBACd,SAAS,EAAE,WAAW;gBACtB,GAAG;gBACH,UAAU,EAAE,UAAU,CAAE,iBAAkC,CAAC,GAAG,CAAC;aAChE;YACH,CAAC,CAAC,EAAC,GAAI,iBAAkC,EAAE,GAAG,EAAC,CAAC;QACpD,IAAI,QAAQ,IAAI,SAAS,EAAE;YACzB,IAAI,CAAC,QAAQ,GAAG,UACd,IAAkC;gBAElC,QAAQ,CAAC,IAAyC,EAAE,GAAG,CAAC,CAAC;YAC3D,CAAC,CAAC;SACH;QACD,OAAO,IAAI,CAAC;KACb;AACH,CAAC,CAAC","sourcesContent":["/**\n * @license\n * Copyright 2017 Google LLC\n * SPDX-License-Identifier: BSD-3-Clause\n */\n\nimport {ReactiveElement} from '../reactive-element.js';\n\nexport type Constructor<T> = {\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  new (...args: any[]): T;\n};\n\n// From the TC39 Decorators proposal\nexport interface ClassDescriptor {\n  kind: 'class';\n  elements: ClassElement[];\n  finisher?: <T>(clazz: Constructor<T>) => void | Constructor<T>;\n}\n\n// From the TC39 Decorators proposal\nexport interface ClassElement {\n  kind: 'field' | 'method';\n  key: PropertyKey;\n  placement: 'static' | 'prototype' | 'own';\n  initializer?: Function;\n  extras?: ClassElement[];\n  finisher?: <T>(clazz: Constructor<T>) => void | Constructor<T>;\n  descriptor?: PropertyDescriptor;\n}\n\nexport const legacyPrototypeMethod = (\n  descriptor: PropertyDescriptor,\n  proto: Object,\n  name: PropertyKey\n) => {\n  Object.defineProperty(proto, name, descriptor);\n};\n\nexport const standardPrototypeMethod = (\n  descriptor: PropertyDescriptor,\n  element: ClassElement\n) => ({\n  kind: 'method',\n  placement: 'prototype',\n  key: element.key,\n  descriptor,\n});\n\n/**\n * Helper for decorating a property that is compatible with both TypeScript\n * and Babel decorators. The optional `finisher` can be used to perform work on\n * the class. The optional `descriptor` should return a PropertyDescriptor\n * to install for the given property.\n *\n * @param finisher {function} Optional finisher method; receives the element\n * constructor and property key as arguments and has no return value.\n * @param descriptor {function} Optional descriptor method; receives the\n * property key as an argument and returns a property descriptor to define for\n * the given property.\n * @returns {ClassElement|void}\n */\nexport const decorateProperty =\n  ({\n    finisher,\n    descriptor,\n  }: {\n    finisher?:\n      | ((ctor: typeof ReactiveElement, property: PropertyKey) => void)\n      | null;\n    descriptor?: (property: PropertyKey) => PropertyDescriptor;\n  }) =>\n  (\n    protoOrDescriptor: ReactiveElement | ClassElement,\n    name?: PropertyKey\n    // Note TypeScript requires the return type to be `void|any`\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  ): void | any => {\n    // TypeScript / Babel legacy mode\n    if (name !== undefined) {\n      const ctor = (protoOrDescriptor as ReactiveElement)\n        .constructor as typeof ReactiveElement;\n      if (descriptor !== undefined) {\n        Object.defineProperty(protoOrDescriptor, name, descriptor(name));\n      }\n      finisher?.(ctor, name!);\n      // Babel standard mode\n    } else {\n      // Note, the @property decorator saves `key` as `originalKey`\n      // so try to use it here.\n      const key =\n        // eslint-disable-next-line @typescript-eslint/no-explicit-any\n        (protoOrDescriptor as any).originalKey ??\n        (protoOrDescriptor as ClassElement).key;\n      const info: ClassElement =\n        descriptor != undefined\n          ? {\n              kind: 'method',\n              placement: 'prototype',\n              key,\n              descriptor: descriptor((protoOrDescriptor as ClassElement).key),\n            }\n          : {...(protoOrDescriptor as ClassElement), key};\n      if (finisher != undefined) {\n        info.finisher = function <ReactiveElement>(\n          ctor: Constructor<ReactiveElement>\n        ) {\n          finisher(ctor as unknown as typeof ReactiveElement, key);\n        };\n      }\n      return info;\n    }\n  };\n"]}

package/src/lib/quire/versions/1.0.0-pre-release.2/node_modules/@lit/reactive-element/development/decorators/custom-element.d.ts

@@ -0,0 +1,27 @@
+/**
+ * @license
+ * Copyright 2017 Google LLC
+ * SPDX-License-Identifier: BSD-3-Clause
+ */
+import { ClassDescriptor } from './base.js';
+/**
+ * Allow for custom element classes with private constructors
+ */
+declare type CustomElementClass = Omit<typeof HTMLElement, 'new'>;
+/**
+ * Class decorator factory that defines the decorated class as a custom element.
+ *
+ * ```js
+ * @customElement('my-element')
+ * class MyElement extends LitElement {
+ *   render() {
+ *     return html``;
+ *   }
+ * }
+ * ```
+ * @category Decorator
+ * @param tagName The tag name of the custom element to define.
+ */
+export declare const customElement: (tagName: string) => (classOrDescriptor: CustomElementClass | ClassDescriptor) => any;
+export {};
+//# sourceMappingURL=custom-element.d.ts.map

package/src/lib/quire/versions/1.0.0-pre-release.2/node_modules/@lit/reactive-element/development/decorators/custom-element.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"custom-element.d.ts","sourceRoot":"","sources":["../../src/decorators/custom-element.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAQH,OAAO,EAAc,eAAe,EAAC,MAAM,WAAW,CAAC;AAEvD;;GAEG;AACH,aAAK,kBAAkB,GAAG,IAAI,CAAC,OAAO,WAAW,EAAE,KAAK,CAAC,CAAC;AA4B1D;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,aAAa,YACd,MAAM,yBACI,kBAAkB,GAAG,eAAe,QAGkB,CAAC"}

package/src/lib/quire/versions/1.0.0-pre-release.2/node_modules/@lit/reactive-element/development/decorators/custom-element.js

@@ -0,0 +1,44 @@
+/**
+ * @license
+ * Copyright 2017 Google LLC
+ * SPDX-License-Identifier: BSD-3-Clause
+ */
+const legacyCustomElement = (tagName, clazz) => {
+    customElements.define(tagName, clazz);
+    // Cast as any because TS doesn't recognize the return type as being a
+    // subtype of the decorated class when clazz is typed as
+    // `Constructor<HTMLElement>` for some reason.
+    // `Constructor<HTMLElement>` is helpful to make sure the decorator is
+    // applied to elements however.
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    return clazz;
+};
+const standardCustomElement = (tagName, descriptor) => {
+    const { kind, elements } = descriptor;
+    return {
+        kind,
+        elements,
+        // This callback is called once the class is otherwise fully defined
+        finisher(clazz) {
+            customElements.define(tagName, clazz);
+        },
+    };
+};
+/**
+ * Class decorator factory that defines the decorated class as a custom element.
+ *
+ * ```js
+ * @customElement('my-element')
+ * class MyElement extends LitElement {
+ *   render() {
+ *     return html``;
+ *   }
+ * }
+ * ```
+ * @category Decorator
+ * @param tagName The tag name of the custom element to define.
+ */
+export const customElement = (tagName) => (classOrDescriptor) => typeof classOrDescriptor === 'function'
+    ? legacyCustomElement(tagName, classOrDescriptor)
+    : standardCustomElement(tagName, classOrDescriptor);
+//# sourceMappingURL=custom-element.js.map

package/src/lib/quire/versions/1.0.0-pre-release.2/node_modules/@lit/reactive-element/development/decorators/custom-element.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"custom-element.js","sourceRoot":"","sources":["../../src/decorators/custom-element.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAeH,MAAM,mBAAmB,GAAG,CAAC,OAAe,EAAE,KAAyB,EAAE,EAAE;IACzE,cAAc,CAAC,MAAM,CAAC,OAAO,EAAE,KAAiC,CAAC,CAAC;IAClE,sEAAsE;IACtE,wDAAwD;IACxD,8CAA8C;IAC9C,sEAAsE;IACtE,+BAA+B;IAC/B,8DAA8D;IAC9D,OAAO,KAAY,CAAC;AACtB,CAAC,CAAC;AAEF,MAAM,qBAAqB,GAAG,CAC5B,OAAe,EACf,UAA2B,EAC3B,EAAE;IACF,MAAM,EAAC,IAAI,EAAE,QAAQ,EAAC,GAAG,UAAU,CAAC;IACpC,OAAO;QACL,IAAI;QACJ,QAAQ;QACR,oEAAoE;QACpE,QAAQ,CAAC,KAA+B;YACtC,cAAc,CAAC,MAAM,CAAC,OAAO,EAAE,KAAK,CAAC,CAAC;QACxC,CAAC;KACF,CAAC;AACJ,CAAC,CAAC;AAEF;;;;;;;;;;;;;GAaG;AACH,MAAM,CAAC,MAAM,aAAa,GACxB,CAAC,OAAe,EAAE,EAAE,CACpB,CAAC,iBAAuD,EAAE,EAAE,CAC1D,OAAO,iBAAiB,KAAK,UAAU;IACrC,CAAC,CAAC,mBAAmB,CAAC,OAAO,EAAE,iBAAiB,CAAC;IACjD,CAAC,CAAC,qBAAqB,CAAC,OAAO,EAAE,iBAAoC,CAAC,CAAC","sourcesContent":["/**\n * @license\n * Copyright 2017 Google LLC\n * SPDX-License-Identifier: BSD-3-Clause\n */\n\n/*\n * IMPORTANT: For compatibility with tsickle and the Closure JS compiler, all\n * property decorators (but not class decorators) in this file that have\n * an @ExportDecoratedItems annotation must be defined as a regular function,\n * not an arrow function.\n */\nimport {Constructor, ClassDescriptor} from './base.js';\n\n/**\n * Allow for custom element classes with private constructors\n */\ntype CustomElementClass = Omit<typeof HTMLElement, 'new'>;\n\nconst legacyCustomElement = (tagName: string, clazz: CustomElementClass) => {\n  customElements.define(tagName, clazz as CustomElementConstructor);\n  // Cast as any because TS doesn't recognize the return type as being a\n  // subtype of the decorated class when clazz is typed as\n  // `Constructor<HTMLElement>` for some reason.\n  // `Constructor<HTMLElement>` is helpful to make sure the decorator is\n  // applied to elements however.\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  return clazz as any;\n};\n\nconst standardCustomElement = (\n  tagName: string,\n  descriptor: ClassDescriptor\n) => {\n  const {kind, elements} = descriptor;\n  return {\n    kind,\n    elements,\n    // This callback is called once the class is otherwise fully defined\n    finisher(clazz: Constructor<HTMLElement>) {\n      customElements.define(tagName, clazz);\n    },\n  };\n};\n\n/**\n * Class decorator factory that defines the decorated class as a custom element.\n *\n * ```js\n * @customElement('my-element')\n * class MyElement extends LitElement {\n *   render() {\n *     return html``;\n *   }\n * }\n * ```\n * @category Decorator\n * @param tagName The tag name of the custom element to define.\n */\nexport const customElement =\n  (tagName: string) =>\n  (classOrDescriptor: CustomElementClass | ClassDescriptor) =>\n    typeof classOrDescriptor === 'function'\n      ? legacyCustomElement(tagName, classOrDescriptor)\n      : standardCustomElement(tagName, classOrDescriptor as ClassDescriptor);\n"]}

package/src/lib/quire/versions/1.0.0-pre-release.2/node_modules/@lit/reactive-element/development/decorators/event-options.d.ts

@@ -0,0 +1,38 @@
+/**
+ * @license
+ * Copyright 2017 Google LLC
+ * SPDX-License-Identifier: BSD-3-Clause
+ */
+import { ReactiveElement } from '../reactive-element.js';
+/**
+ * Adds event listener options to a method used as an event listener in a
+ * lit-html template.
+ *
+ * @param options An object that specifies event listener options as accepted by
+ * `EventTarget#addEventListener` and `EventTarget#removeEventListener`.
+ *
+ * Current browsers support the `capture`, `passive`, and `once` options. See:
+ * https://developer.mozilla.org/en-US/docs/Web/API/EventTarget/addEventListener#Parameters
+ *
+ * ```ts
+ * class MyElement {
+ *   clicked = false;
+ *
+ *   render() {
+ *     return html`
+ *       <div @click=${this._onClick}>
+ *         <button></button>
+ *       </div>
+ *     `;
+ *   }
+ *
+ *   @eventOptions({capture: true})
+ *   _onClick(e) {
+ *     this.clicked = true;
+ *   }
+ * }
+ * ```
+ * @category Decorator
+ */
+export declare function eventOptions(options: AddEventListenerOptions): (protoOrDescriptor: ReactiveElement | import("./base.js").ClassElement, name?: PropertyKey | undefined) => any;
+//# sourceMappingURL=event-options.d.ts.map

package/src/lib/quire/versions/1.0.0-pre-release.2/node_modules/@lit/reactive-element/development/decorators/event-options.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"event-options.d.ts","sourceRoot":"","sources":["../../src/decorators/event-options.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AASH,OAAO,EAAC,eAAe,EAAC,MAAM,wBAAwB,CAAC;AAGvD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,wBAAgB,YAAY,CAAC,OAAO,EAAE,uBAAuB,kHAU5D"}

package/src/lib/quire/versions/1.0.0-pre-release.2/node_modules/@lit/reactive-element/development/decorators/event-options.js

@@ -0,0 +1,46 @@
+/**
+ * @license
+ * Copyright 2017 Google LLC
+ * SPDX-License-Identifier: BSD-3-Clause
+ */
+import { decorateProperty } from './base.js';
+/**
+ * Adds event listener options to a method used as an event listener in a
+ * lit-html template.
+ *
+ * @param options An object that specifies event listener options as accepted by
+ * `EventTarget#addEventListener` and `EventTarget#removeEventListener`.
+ *
+ * Current browsers support the `capture`, `passive`, and `once` options. See:
+ * https://developer.mozilla.org/en-US/docs/Web/API/EventTarget/addEventListener#Parameters
+ *
+ * ```ts
+ * class MyElement {
+ *   clicked = false;
+ *
+ *   render() {
+ *     return html`
+ *       <div @click=${this._onClick}>
+ *         <button></button>
+ *       </div>
+ *     `;
+ *   }
+ *
+ *   @eventOptions({capture: true})
+ *   _onClick(e) {
+ *     this.clicked = true;
+ *   }
+ * }
+ * ```
+ * @category Decorator
+ */
+export function eventOptions(options) {
+    return decorateProperty({
+        finisher: (ctor, name) => {
+            Object.assign(
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            ctor.prototype[name], options);
+        },
+    });
+}
+//# sourceMappingURL=event-options.js.map

package/src/lib/quire/versions/1.0.0-pre-release.2/node_modules/@lit/reactive-element/development/decorators/event-options.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"event-options.js","sourceRoot":"","sources":["../../src/decorators/event-options.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAUH,OAAO,EAAC,gBAAgB,EAAC,MAAM,WAAW,CAAC;AAE3C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,MAAM,UAAU,YAAY,CAAC,OAAgC;IAC3D,OAAO,gBAAgB,CAAC;QACtB,QAAQ,EAAE,CAAC,IAA4B,EAAE,IAAiB,EAAE,EAAE;YAC5D,MAAM,CAAC,MAAM;YACX,8DAA8D;YAC9D,IAAI,CAAC,SAAS,CAAC,IAA6B,CAAQ,EACpD,OAAO,CACR,CAAC;QACJ,CAAC;KACF,CAAC,CAAC;AACL,CAAC","sourcesContent":["/**\n * @license\n * Copyright 2017 Google LLC\n * SPDX-License-Identifier: BSD-3-Clause\n */\n\n/*\n * IMPORTANT: For compatibility with tsickle and the Closure JS compiler, all\n * property decorators (but not class decorators) in this file that have\n * an @ExportDecoratedItems annotation must be defined as a regular function,\n * not an arrow function.\n */\n\nimport {ReactiveElement} from '../reactive-element.js';\nimport {decorateProperty} from './base.js';\n\n/**\n * Adds event listener options to a method used as an event listener in a\n * lit-html template.\n *\n * @param options An object that specifies event listener options as accepted by\n * `EventTarget#addEventListener` and `EventTarget#removeEventListener`.\n *\n * Current browsers support the `capture`, `passive`, and `once` options. See:\n * https://developer.mozilla.org/en-US/docs/Web/API/EventTarget/addEventListener#Parameters\n *\n * ```ts\n * class MyElement {\n *   clicked = false;\n *\n *   render() {\n *     return html`\n *       <div @click=${this._onClick}>\n *         <button></button>\n *       </div>\n *     `;\n *   }\n *\n *   @eventOptions({capture: true})\n *   _onClick(e) {\n *     this.clicked = true;\n *   }\n * }\n * ```\n * @category Decorator\n */\nexport function eventOptions(options: AddEventListenerOptions) {\n  return decorateProperty({\n    finisher: (ctor: typeof ReactiveElement, name: PropertyKey) => {\n      Object.assign(\n        // eslint-disable-next-line @typescript-eslint/no-explicit-any\n        ctor.prototype[name as keyof ReactiveElement] as any,\n        options\n      );\n    },\n  });\n}\n"]}

package/src/lib/quire/versions/1.0.0-pre-release.2/node_modules/@lit/reactive-element/development/decorators/property.d.ts

@@ -0,0 +1,41 @@
+/**
+ * @license
+ * Copyright 2017 Google LLC
+ * SPDX-License-Identifier: BSD-3-Clause
+ */
+import { PropertyDeclaration } from '../reactive-element.js';
+import { ClassElement } from './base.js';
+/**
+ * A property decorator which creates a reactive property that reflects a
+ * corresponding attribute value. When a decorated property is set
+ * the element will update and render. A {@linkcode PropertyDeclaration} may
+ * optionally be supplied to configure property features.
+ *
+ * This decorator should only be used for public fields. As public fields,
+ * properties should be considered as primarily settable by element users,
+ * either via attribute or the property itself.
+ *
+ * Generally, properties that are changed by the element should be private or
+ * protected fields and should use the {@linkcode state} decorator.
+ *
+ * However, sometimes element code does need to set a public property. This
+ * should typically only be done in response to user interaction, and an event
+ * should be fired informing the user; for example, a checkbox sets its
+ * `checked` property when clicked and fires a `changed` event. Mutating public
+ * properties should typically not be done for non-primitive (object or array)
+ * properties. In other cases when an element needs to manage state, a private
+ * property decorated via the {@linkcode state} decorator should be used. When
+ * needed, state properties can be initialized via public properties to
+ * facilitate complex interactions.
+ *
+ * ```ts
+ * class MyElement {
+ *   @property({ type: Boolean })
+ *   clicked = false;
+ * }
+ * ```
+ * @category Decorator
+ * @ExportDecoratedItems
+ */
+export declare function property(options?: PropertyDeclaration): (protoOrDescriptor: Object | ClassElement, name?: PropertyKey) => any;
+//# sourceMappingURL=property.d.ts.map

package/src/lib/quire/versions/1.0.0-pre-release.2/node_modules/@lit/reactive-element/development/decorators/property.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"property.d.ts","sourceRoot":"","sources":["../../src/decorators/property.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAQH,OAAO,EAAC,mBAAmB,EAAkB,MAAM,wBAAwB,CAAC;AAC5E,OAAO,EAAC,YAAY,EAAC,MAAM,WAAW,CAAC;AA4DvC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,wBAAgB,QAAQ,CAAC,OAAO,CAAC,EAAE,mBAAmB,uBAEzB,MAAM,GAAG,YAAY,SAAS,WAAW,KAAG,GAAG,CAI3E"}

package/src/lib/quire/versions/1.0.0-pre-release.2/node_modules/@lit/reactive-element/development/decorators/property.js

@@ -0,0 +1,92 @@
+/**
+ * @license
+ * Copyright 2017 Google LLC
+ * SPDX-License-Identifier: BSD-3-Clause
+ */
+const standardProperty = (options, element) => {
+    // When decorating an accessor, pass it through and add property metadata.
+    // Note, the `hasOwnProperty` check in `createProperty` ensures we don't
+    // stomp over the user's accessor.
+    if (element.kind === 'method' &&
+        element.descriptor &&
+        !('value' in element.descriptor)) {
+        return {
+            ...element,
+            finisher(clazz) {
+                clazz.createProperty(element.key, options);
+            },
+        };
+    }
+    else {
+        // createProperty() takes care of defining the property, but we still
+        // must return some kind of descriptor, so return a descriptor for an
+        // unused prototype field. The finisher calls createProperty().
+        return {
+            kind: 'field',
+            key: Symbol(),
+            placement: 'own',
+            descriptor: {},
+            // store the original key so subsequent decorators have access to it.
+            originalKey: element.key,
+            // When @babel/plugin-proposal-decorators implements initializers,
+            // do this instead of the initializer below. See:
+            // https://github.com/babel/babel/issues/9260 extras: [
+            //   {
+            //     kind: 'initializer',
+            //     placement: 'own',
+            //     initializer: descriptor.initializer,
+            //   }
+            // ],
+            initializer() {
+                if (typeof element.initializer === 'function') {
+                    this[element.key] = element.initializer.call(this);
+                }
+            },
+            finisher(clazz) {
+                clazz.createProperty(element.key, options);
+            },
+        };
+    }
+};
+const legacyProperty = (options, proto, name) => {
+    proto.constructor.createProperty(name, options);
+};
+/**
+ * A property decorator which creates a reactive property that reflects a
+ * corresponding attribute value. When a decorated property is set
+ * the element will update and render. A {@linkcode PropertyDeclaration} may
+ * optionally be supplied to configure property features.
+ *
+ * This decorator should only be used for public fields. As public fields,
+ * properties should be considered as primarily settable by element users,
+ * either via attribute or the property itself.
+ *
+ * Generally, properties that are changed by the element should be private or
+ * protected fields and should use the {@linkcode state} decorator.
+ *
+ * However, sometimes element code does need to set a public property. This
+ * should typically only be done in response to user interaction, and an event
+ * should be fired informing the user; for example, a checkbox sets its
+ * `checked` property when clicked and fires a `changed` event. Mutating public
+ * properties should typically not be done for non-primitive (object or array)
+ * properties. In other cases when an element needs to manage state, a private
+ * property decorated via the {@linkcode state} decorator should be used. When
+ * needed, state properties can be initialized via public properties to
+ * facilitate complex interactions.
+ *
+ * ```ts
+ * class MyElement {
+ *   @property({ type: Boolean })
+ *   clicked = false;
+ * }
+ * ```
+ * @category Decorator
+ * @ExportDecoratedItems
+ */
+export function property(options) {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    return (protoOrDescriptor, name) => name !== undefined
+        ? legacyProperty(options, protoOrDescriptor, name)
+        : standardProperty(options, protoOrDescriptor);
+}
+//# sourceMappingURL=property.js.map

package/src/lib/quire/versions/1.0.0-pre-release.2/node_modules/@lit/reactive-element/development/decorators/property.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"property.js","sourceRoot":"","sources":["../../src/decorators/property.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAWH,MAAM,gBAAgB,GAAG,CACvB,OAA4B,EAC5B,OAAqB,EACrB,EAAE;IACF,0EAA0E;IAC1E,wEAAwE;IACxE,kCAAkC;IAClC,IACE,OAAO,CAAC,IAAI,KAAK,QAAQ;QACzB,OAAO,CAAC,UAAU;QAClB,CAAC,CAAC,OAAO,IAAI,OAAO,CAAC,UAAU,CAAC,EAChC;QACA,OAAO;YACL,GAAG,OAAO;YACV,QAAQ,CAAC,KAA6B;gBACpC,KAAK,CAAC,cAAc,CAAC,OAAO,CAAC,GAAG,EAAE,OAAO,CAAC,CAAC;YAC7C,CAAC;SACF,CAAC;KACH;SAAM;QACL,qEAAqE;QACrE,qEAAqE;QACrE,+DAA+D;QAC/D,OAAO;YACL,IAAI,EAAE,OAAO;YACb,GAAG,EAAE,MAAM,EAAE;YACb,SAAS,EAAE,KAAK;YAChB,UAAU,EAAE,EAAE;YACd,qEAAqE;YACrE,WAAW,EAAE,OAAO,CAAC,GAAG;YACxB,kEAAkE;YAClE,iDAAiD;YACjD,uDAAuD;YACvD,MAAM;YACN,2BAA2B;YAC3B,wBAAwB;YACxB,2CAA2C;YAC3C,MAAM;YACN,KAAK;YACL,WAAW;gBACT,IAAI,OAAO,OAAO,CAAC,WAAW,KAAK,UAAU,EAAE;oBAC7C,IAAI,CAAC,OAAO,CAAC,GAAa,CAAC,GAAG,OAAO,CAAC,WAAW,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;iBAC9D;YACH,CAAC;YACD,QAAQ,CAAC,KAA6B;gBACpC,KAAK,CAAC,cAAc,CAAC,OAAO,CAAC,GAAG,EAAE,OAAO,CAAC,CAAC;YAC7C,CAAC;SACF,CAAC;KACH;AACH,CAAC,CAAC;AAEF,MAAM,cAAc,GAAG,CACrB,OAA4B,EAC5B,KAAa,EACb,IAAiB,EACjB,EAAE;IACD,KAAK,CAAC,WAAsC,CAAC,cAAc,CAAC,IAAI,EAAE,OAAO,CAAC,CAAC;AAC9E,CAAC,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,MAAM,UAAU,QAAQ,CAAC,OAA6B;IACpD,8DAA8D;IAC9D,OAAO,CAAC,iBAAwC,EAAE,IAAkB,EAAO,EAAE,CAC3E,IAAI,KAAK,SAAS;QAChB,CAAC,CAAC,cAAc,CAAC,OAAQ,EAAE,iBAA2B,EAAE,IAAI,CAAC;QAC7D,CAAC,CAAC,gBAAgB,CAAC,OAAQ,EAAE,iBAAiC,CAAC,CAAC;AACtE,CAAC","sourcesContent":["/**\n * @license\n * Copyright 2017 Google LLC\n * SPDX-License-Identifier: BSD-3-Clause\n */\n\n/*\n * IMPORTANT: For compatibility with tsickle and the Closure JS compiler, all\n * property decorators (but not class decorators) in this file that have\n * an @ExportDecoratedItems annotation must be defined as a regular function,\n * not an arrow function.\n */\nimport {PropertyDeclaration, ReactiveElement} from '../reactive-element.js';\nimport {ClassElement} from './base.js';\n\nconst standardProperty = (\n  options: PropertyDeclaration,\n  element: ClassElement\n) => {\n  // When decorating an accessor, pass it through and add property metadata.\n  // Note, the `hasOwnProperty` check in `createProperty` ensures we don't\n  // stomp over the user's accessor.\n  if (\n    element.kind === 'method' &&\n    element.descriptor &&\n    !('value' in element.descriptor)\n  ) {\n    return {\n      ...element,\n      finisher(clazz: typeof ReactiveElement) {\n        clazz.createProperty(element.key, options);\n      },\n    };\n  } else {\n    // createProperty() takes care of defining the property, but we still\n    // must return some kind of descriptor, so return a descriptor for an\n    // unused prototype field. The finisher calls createProperty().\n    return {\n      kind: 'field',\n      key: Symbol(),\n      placement: 'own',\n      descriptor: {},\n      // store the original key so subsequent decorators have access to it.\n      originalKey: element.key,\n      // When @babel/plugin-proposal-decorators implements initializers,\n      // do this instead of the initializer below. See:\n      // https://github.com/babel/babel/issues/9260 extras: [\n      //   {\n      //     kind: 'initializer',\n      //     placement: 'own',\n      //     initializer: descriptor.initializer,\n      //   }\n      // ],\n      initializer(this: {[key: string]: unknown}) {\n        if (typeof element.initializer === 'function') {\n          this[element.key as string] = element.initializer.call(this);\n        }\n      },\n      finisher(clazz: typeof ReactiveElement) {\n        clazz.createProperty(element.key, options);\n      },\n    };\n  }\n};\n\nconst legacyProperty = (\n  options: PropertyDeclaration,\n  proto: Object,\n  name: PropertyKey\n) => {\n  (proto.constructor as typeof ReactiveElement).createProperty(name, options);\n};\n\n/**\n * A property decorator which creates a reactive property that reflects a\n * corresponding attribute value. When a decorated property is set\n * the element will update and render. A {@linkcode PropertyDeclaration} may\n * optionally be supplied to configure property features.\n *\n * This decorator should only be used for public fields. As public fields,\n * properties should be considered as primarily settable by element users,\n * either via attribute or the property itself.\n *\n * Generally, properties that are changed by the element should be private or\n * protected fields and should use the {@linkcode state} decorator.\n *\n * However, sometimes element code does need to set a public property. This\n * should typically only be done in response to user interaction, and an event\n * should be fired informing the user; for example, a checkbox sets its\n * `checked` property when clicked and fires a `changed` event. Mutating public\n * properties should typically not be done for non-primitive (object or array)\n * properties. In other cases when an element needs to manage state, a private\n * property decorated via the {@linkcode state} decorator should be used. When\n * needed, state properties can be initialized via public properties to\n * facilitate complex interactions.\n *\n * ```ts\n * class MyElement {\n *   @property({ type: Boolean })\n *   clicked = false;\n * }\n * ```\n * @category Decorator\n * @ExportDecoratedItems\n */\nexport function property(options?: PropertyDeclaration) {\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  return (protoOrDescriptor: Object | ClassElement, name?: PropertyKey): any =>\n    name !== undefined\n      ? legacyProperty(options!, protoOrDescriptor as Object, name)\n      : standardProperty(options!, protoOrDescriptor as ClassElement);\n}\n"]}

package/src/lib/quire/versions/1.0.0-pre-release.2/node_modules/@lit/reactive-element/development/decorators/query-all.d.ts

@@ -0,0 +1,32 @@
+/**
+ * @license
+ * Copyright 2017 Google LLC
+ * SPDX-License-Identifier: BSD-3-Clause
+ */
+import { ReactiveElement } from '../reactive-element.js';
+/**
+ * A property decorator that converts a class property into a getter
+ * that executes a querySelectorAll on the element's renderRoot.
+ *
+ * @param selector A DOMString containing one or more selectors to match.
+ *
+ * See:
+ * https://developer.mozilla.org/en-US/docs/Web/API/Document/querySelectorAll
+ *
+ * ```ts
+ * class MyElement {
+ *   @queryAll('div')
+ *   divs: NodeListOf<HTMLDivElement>;
+ *
+ *   render() {
+ *     return html`
+ *       <div id="first"></div>
+ *       <div id="second"></div>
+ *     `;
+ *   }
+ * }
+ * ```
+ * @category Decorator
+ */
+export declare function queryAll(selector: string): (protoOrDescriptor: ReactiveElement | import("./base.js").ClassElement, name?: PropertyKey | undefined) => any;
+//# sourceMappingURL=query-all.d.ts.map

package/src/lib/quire/versions/1.0.0-pre-release.2/node_modules/@lit/reactive-element/development/decorators/query-all.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"query-all.d.ts","sourceRoot":"","sources":["../../src/decorators/query-all.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AASH,OAAO,EAAC,eAAe,EAAC,MAAM,wBAAwB,CAAC;AAGvD;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,QAAQ,CAAC,QAAQ,EAAE,MAAM,kHAUxC"}

package/src/lib/quire/versions/1.0.0-pre-release.2/node_modules/@lit/reactive-element/development/decorators/query-all.js

@@ -0,0 +1,43 @@
+/**
+ * @license
+ * Copyright 2017 Google LLC
+ * SPDX-License-Identifier: BSD-3-Clause
+ */
+import { decorateProperty } from './base.js';
+/**
+ * A property decorator that converts a class property into a getter
+ * that executes a querySelectorAll on the element's renderRoot.
+ *
+ * @param selector A DOMString containing one or more selectors to match.
+ *
+ * See:
+ * https://developer.mozilla.org/en-US/docs/Web/API/Document/querySelectorAll
+ *
+ * ```ts
+ * class MyElement {
+ *   @queryAll('div')
+ *   divs: NodeListOf<HTMLDivElement>;
+ *
+ *   render() {
+ *     return html`
+ *       <div id="first"></div>
+ *       <div id="second"></div>
+ *     `;
+ *   }
+ * }
+ * ```
+ * @category Decorator
+ */
+export function queryAll(selector) {
+    return decorateProperty({
+        descriptor: (_name) => ({
+            get() {
+                var _a, _b;
+                return (_b = (_a = this.renderRoot) === null || _a === void 0 ? void 0 : _a.querySelectorAll(selector)) !== null && _b !== void 0 ? _b : [];
+            },
+            enumerable: true,
+            configurable: true,
+        }),
+    });
+}
+//# sourceMappingURL=query-all.js.map

package/src/lib/quire/versions/1.0.0-pre-release.2/node_modules/@lit/reactive-element/development/decorators/query-all.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"query-all.js","sourceRoot":"","sources":["../../src/decorators/query-all.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAUH,OAAO,EAAC,gBAAgB,EAAC,MAAM,WAAW,CAAC;AAE3C;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,MAAM,UAAU,QAAQ,CAAC,QAAgB;IACvC,OAAO,gBAAgB,CAAC;QACtB,UAAU,EAAE,CAAC,KAAkB,EAAE,EAAE,CAAC,CAAC;YACnC,GAAG;;gBACD,OAAO,MAAA,MAAA,IAAI,CAAC,UAAU,0CAAE,gBAAgB,CAAC,QAAQ,CAAC,mCAAI,EAAE,CAAC;YAC3D,CAAC;YACD,UAAU,EAAE,IAAI;YAChB,YAAY,EAAE,IAAI;SACnB,CAAC;KACH,CAAC,CAAC;AACL,CAAC","sourcesContent":["/**\n * @license\n * Copyright 2017 Google LLC\n * SPDX-License-Identifier: BSD-3-Clause\n */\n\n/*\n * IMPORTANT: For compatibility with tsickle and the Closure JS compiler, all\n * property decorators (but not class decorators) in this file that have\n * an @ExportDecoratedItems annotation must be defined as a regular function,\n * not an arrow function.\n */\n\nimport {ReactiveElement} from '../reactive-element.js';\nimport {decorateProperty} from './base.js';\n\n/**\n * A property decorator that converts a class property into a getter\n * that executes a querySelectorAll on the element's renderRoot.\n *\n * @param selector A DOMString containing one or more selectors to match.\n *\n * See:\n * https://developer.mozilla.org/en-US/docs/Web/API/Document/querySelectorAll\n *\n * ```ts\n * class MyElement {\n *   @queryAll('div')\n *   divs: NodeListOf<HTMLDivElement>;\n *\n *   render() {\n *     return html`\n *       <div id=\"first\"></div>\n *       <div id=\"second\"></div>\n *     `;\n *   }\n * }\n * ```\n * @category Decorator\n */\nexport function queryAll(selector: string) {\n  return decorateProperty({\n    descriptor: (_name: PropertyKey) => ({\n      get(this: ReactiveElement) {\n        return this.renderRoot?.querySelectorAll(selector) ?? [];\n      },\n      enumerable: true,\n      configurable: true,\n    }),\n  });\n}\n"]}

package/src/lib/quire/versions/1.0.0-pre-release.2/node_modules/@lit/reactive-element/development/decorators/query-assigned-elements.d.ts

@@ -0,0 +1,50 @@
+/**
+ * @license
+ * Copyright 2021 Google LLC
+ * SPDX-License-Identifier: BSD-3-Clause
+ */
+import type { ReactiveElement } from '../reactive-element.js';
+import type { QueryAssignedNodesOptions } from './query-assigned-nodes.js';
+/**
+ * Options for the {@linkcode queryAssignedElements} decorator. Extends the
+ * options that can be passed into
+ * [HTMLSlotElement.assignedElements](https://developer.mozilla.org/en-US/docs/Web/API/HTMLSlotElement/assignedElements).
+ */
+export interface QueryAssignedElementsOptions extends QueryAssignedNodesOptions {
+    /**
+     * CSS selector used to filter the elements returned. For example, a selector
+     * of `".item"` will only include elements with the `item` class.
+     */
+    selector?: string;
+}
+/**
+ * A property decorator that converts a class property into a getter that
+ * returns the `assignedElements` of the given `slot`. Provides a declarative
+ * way to use
+ * [`HTMLSlotElement.assignedElements`](https://developer.mozilla.org/en-US/docs/Web/API/HTMLSlotElement/assignedElements).
+ *
+ * Can be passed an optional {@linkcode QueryAssignedElementsOptions} object.
+ *
+ * Example usage:
+ * ```ts
+ * class MyElement {
+ *   @queryAssignedElements({ slot: 'list' })
+ *   listItems!: Array<HTMLElement>;
+ *   @queryAssignedElements()
+ *   unnamedSlotEls!: Array<HTMLElement>;
+ *
+ *   render() {
+ *     return html`
+ *       <slot name="list"></slot>
+ *       <slot></slot>
+ *     `;
+ *   }
+ * }
+ * ```
+ *
+ * Note, the type of this property should be annotated as `Array<HTMLElement>`.
+ *
+ * @category Decorator
+ */
+export declare function queryAssignedElements(options?: QueryAssignedElementsOptions): (protoOrDescriptor: ReactiveElement | import("./base.js").ClassElement, name?: PropertyKey | undefined) => any;
+//# sourceMappingURL=query-assigned-elements.d.ts.map

package/src/lib/quire/versions/1.0.0-pre-release.2/node_modules/@lit/reactive-element/development/decorators/query-assigned-elements.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"query-assigned-elements.d.ts","sourceRoot":"","sources":["../../src/decorators/query-assigned-elements.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAWH,OAAO,KAAK,EAAC,eAAe,EAAC,MAAM,wBAAwB,CAAC;AAC5D,OAAO,KAAK,EAAC,yBAAyB,EAAC,MAAM,2BAA2B,CAAC;AAmBzE;;;;GAIG;AACH,MAAM,WAAW,4BACf,SAAQ,yBAAyB;IACjC;;;OAGG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,wBAAgB,qBAAqB,CAAC,OAAO,CAAC,EAAE,4BAA4B,kHAmB3E"}