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

package/src/lib/quire/versions/1.0.0-pre-release.2/node_modules/lit-html/development/private-ssr-support.js

@@ -0,0 +1,55 @@
+/**
+ * @license
+ * Copyright 2019 Google LLC
+ * SPDX-License-Identifier: BSD-3-Clause
+ */
+import { _$LH as p, noChange, } from './lit-html.js';
+/**
+ * END USERS SHOULD NOT RELY ON THIS OBJECT.
+ *
+ * We currently do not make a mangled rollup build of the lit-ssr code. In order
+ * to keep a number of (otherwise private) top-level exports mangled in the
+ * client side code, we export a _$LH object containing those members (or
+ * helper methods for accessing private fields of those members), and then
+ * re-export them for use in lit-ssr. This keeps lit-ssr agnostic to whether the
+ * client-side code is being used in `dev` mode or `prod` mode.
+ * @private
+ */
+export const _$LH = {
+    boundAttributeSuffix: p._boundAttributeSuffix,
+    marker: p._marker,
+    markerMatch: p._markerMatch,
+    HTML_RESULT: p._HTML_RESULT,
+    getTemplateHtml: p._getTemplateHtml,
+    overrideDirectiveResolve: (directiveClass, resolveOverrideFn) => class extends directiveClass {
+        _$resolve(_part, values) {
+            return resolveOverrideFn(this, values);
+        }
+    },
+    setDirectiveClass(value, directiveClass) {
+        // This property needs to remain unminified.
+        value['_$litDirective$'] = directiveClass;
+    },
+    getAttributePartCommittedValue: (part, value, index) => {
+        // Use the part setter to resolve directives/concatenate multiple parts
+        // into a final value (captured by passing in a commitValue override)
+        let committedValue = noChange;
+        // Note that _commitValue need not be in `stableProperties` because this
+        // method is only run on `AttributePart`s created by lit-ssr using the same
+        // version of the library as this file
+        part._commitValue = (value) => (committedValue = value);
+        part._$setValue(value, part, index);
+        return committedValue;
+    },
+    connectedDisconnectable: (props) => ({
+        ...props,
+        _$isConnected: true,
+    }),
+    resolveDirective: p._resolveDirective,
+    AttributePart: p._AttributePart,
+    PropertyPart: p._PropertyPart,
+    BooleanAttributePart: p._BooleanAttributePart,
+    EventPart: p._EventPart,
+    ElementPart: p._ElementPart,
+};
+//# sourceMappingURL=private-ssr-support.js.map

package/src/lib/quire/versions/1.0.0-pre-release.2/node_modules/lit-html/development/private-ssr-support.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"private-ssr-support.js","sourceRoot":"","sources":["../src/private-ssr-support.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAQH,OAAO,EACL,IAAI,IAAI,CAAC,EAET,QAAQ,GAGT,MAAM,eAAe,CAAC;AAGvB;;;;;;;;;;GAUG;AACH,MAAM,CAAC,MAAM,IAAI,GAAG;IAClB,oBAAoB,EAAE,CAAC,CAAC,qBAAqB;IAC7C,MAAM,EAAE,CAAC,CAAC,OAAO;IACjB,WAAW,EAAE,CAAC,CAAC,YAAY;IAC3B,WAAW,EAAE,CAAC,CAAC,YAAY;IAC3B,eAAe,EAAE,CAAC,CAAC,gBAAgB;IACnC,wBAAwB,EAAE,CACxB,cAAuE,EACvE,iBAAuE,EACvE,EAAE,CACF,KAAM,SAAQ,cAAc;QACjB,SAAS,CAEhB,KAAW,EACX,MAAiB;YAEjB,OAAO,iBAAiB,CAAC,IAAI,EAAE,MAAM,CAAC,CAAC;QACzC,CAAC;KACF;IACH,iBAAiB,CAAC,KAAsB,EAAE,cAA8B;QACtE,4CAA4C;QAC5C,KAAK,CAAC,iBAAiB,CAAC,GAAG,cAAc,CAAC;IAC5C,CAAC;IACD,8BAA8B,EAAE,CAC9B,IAAmB,EACnB,KAAc,EACd,KAAyB,EACzB,EAAE;QACF,uEAAuE;QACvE,qEAAqE;QACrE,IAAI,cAAc,GAAY,QAAQ,CAAC;QACvC,wEAAwE;QACxE,2EAA2E;QAC3E,sCAAsC;QACtC,IAAI,CAAC,YAAY,GAAG,CAAC,KAAc,EAAE,EAAE,CAAC,CAAC,cAAc,GAAG,KAAK,CAAC,CAAC;QACjE,IAAI,CAAC,UAAU,CAAC,KAAK,EAAE,IAAI,EAAE,KAAK,CAAC,CAAC;QACpC,OAAO,cAAc,CAAC;IACxB,CAAC;IACD,uBAAuB,EAAE,CAAC,KAAc,EAAkB,EAAE,CAAC,CAAC;QAC5D,GAAG,KAAK;QACR,aAAa,EAAE,IAAI;KACpB,CAAC;IACF,gBAAgB,EAAE,CAAC,CAAC,iBAAiB;IACrC,aAAa,EAAE,CAAC,CAAC,cAAc;IAC/B,YAAY,EAAE,CAAC,CAAC,aAAa;IAC7B,oBAAoB,EAAE,CAAC,CAAC,qBAAqB;IAC7C,SAAS,EAAE,CAAC,CAAC,UAAU;IACvB,WAAW,EAAE,CAAC,CAAC,YAAY;CAC5B,CAAC","sourcesContent":["/**\n * @license\n * Copyright 2019 Google LLC\n * SPDX-License-Identifier: BSD-3-Clause\n */\n\nimport {\n  Directive,\n  PartInfo,\n  DirectiveClass,\n  DirectiveResult,\n} from './directive.js';\nimport {\n  _$LH as p,\n  AttributePart,\n  noChange,\n  Part,\n  Disconnectable,\n} from './lit-html.js';\nexport type {Template} from './lit-html.js';\n\n/**\n * END USERS SHOULD NOT RELY ON THIS OBJECT.\n *\n * We currently do not make a mangled rollup build of the lit-ssr code. In order\n * to keep a number of (otherwise private) top-level exports mangled in the\n * client side code, we export a _$LH object containing those members (or\n * helper methods for accessing private fields of those members), and then\n * re-export them for use in lit-ssr. This keeps lit-ssr agnostic to whether the\n * client-side code is being used in `dev` mode or `prod` mode.\n * @private\n */\nexport const _$LH = {\n  boundAttributeSuffix: p._boundAttributeSuffix,\n  marker: p._marker,\n  markerMatch: p._markerMatch,\n  HTML_RESULT: p._HTML_RESULT,\n  getTemplateHtml: p._getTemplateHtml,\n  overrideDirectiveResolve: (\n    directiveClass: new (part: PartInfo) => Directive & {render(): unknown},\n    resolveOverrideFn: (directive: Directive, values: unknown[]) => unknown\n  ) =>\n    class extends directiveClass {\n      override _$resolve(\n        this: Directive,\n        _part: Part,\n        values: unknown[]\n      ): unknown {\n        return resolveOverrideFn(this, values);\n      }\n    },\n  setDirectiveClass(value: DirectiveResult, directiveClass: DirectiveClass) {\n    // This property needs to remain unminified.\n    value['_$litDirective$'] = directiveClass;\n  },\n  getAttributePartCommittedValue: (\n    part: AttributePart,\n    value: unknown,\n    index: number | undefined\n  ) => {\n    // Use the part setter to resolve directives/concatenate multiple parts\n    // into a final value (captured by passing in a commitValue override)\n    let committedValue: unknown = noChange;\n    // Note that _commitValue need not be in `stableProperties` because this\n    // method is only run on `AttributePart`s created by lit-ssr using the same\n    // version of the library as this file\n    part._commitValue = (value: unknown) => (committedValue = value);\n    part._$setValue(value, part, index);\n    return committedValue;\n  },\n  connectedDisconnectable: (props?: object): Disconnectable => ({\n    ...props,\n    _$isConnected: true,\n  }),\n  resolveDirective: p._resolveDirective,\n  AttributePart: p._AttributePart,\n  PropertyPart: p._PropertyPart,\n  BooleanAttributePart: p._BooleanAttributePart,\n  EventPart: p._EventPart,\n  ElementPart: p._ElementPart,\n};\n"]}

package/src/lib/quire/versions/1.0.0-pre-release.2/node_modules/lit-html/development/static.d.ts

@@ -0,0 +1,82 @@
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ * SPDX-License-Identifier: BSD-3-Clause
+ */
+import { html as coreHtml, svg as coreSvg, TemplateResult } from './lit-html.js';
+export interface StaticValue {
+    /** The value to interpolate as-is into the template. */
+    _$litStatic$: string;
+    /**
+     * A value that can't be decoded from ordinary JSON, make it harder for
+     * a attacker-controlled data that goes through JSON.parse to produce a valid
+     * StaticValue.
+     */
+    r: typeof brand;
+}
+/**
+ * Prevents JSON injection attacks.
+ *
+ * The goals of this brand:
+ *   1) fast to check
+ *   2) code is small on the wire
+ *   3) multiple versions of Lit in a single page will all produce mutually
+ *      interoperable StaticValues
+ *   4) normal JSON.parse (without an unusual reviver) can not produce a
+ *      StaticValue
+ *
+ * Symbols satisfy (1), (2), and (4). We use Symbol.for to satisfy (3), but
+ * we don't care about the key, so we break ties via (2) and use the empty
+ * string.
+ */
+declare const brand: unique symbol;
+/**
+ * Wraps a string so that it behaves like part of the static template
+ * strings instead of a dynamic value.
+ *
+ * Users must take care to ensure that adding the static string to the template
+ * results in well-formed HTML, or else templates may break unexpectedly.
+ *
+ * Note that this function is unsafe to use on untrusted content, as it will be
+ * directly parsed into HTML. Do not pass user input to this function
+ * without sanitizing it.
+ *
+ * Static values can be changed, but they will cause a complete re-render
+ * since they effectively create a new template.
+ */
+export declare const unsafeStatic: (value: string) => StaticValue;
+/**
+ * Tags a string literal so that it behaves like part of the static template
+ * strings instead of a dynamic value.
+ *
+ * The only values that may be used in template expressions are other tagged
+ * `literal` results or `unsafeStatic` values (note that untrusted content
+ * should never be passed to `unsafeStatic`).
+ *
+ * Users must take care to ensure that adding the static string to the template
+ * results in well-formed HTML, or else templates may break unexpectedly.
+ *
+ * Static values can be changed, but they will cause a complete re-render since
+ * they effectively create a new template.
+ */
+export declare const literal: (strings: TemplateStringsArray, ...values: unknown[]) => StaticValue;
+/**
+ * Wraps a lit-html template tag (`html` or `svg`) to add static value support.
+ */
+export declare const withStatic: (coreTag: typeof coreHtml | typeof coreSvg) => (strings: TemplateStringsArray, ...values: unknown[]) => TemplateResult;
+/**
+ * Interprets a template literal as an HTML template that can efficiently
+ * render to and update a container.
+ *
+ * Includes static value support from `lit-html/static.js`.
+ */
+export declare const html: (strings: TemplateStringsArray, ...values: unknown[]) => TemplateResult;
+/**
+ * Interprets a template literal as an SVG template that can efficiently
+ * render to and update a container.
+ *
+ * Includes static value support from `lit-html/static.js`.
+ */
+export declare const svg: (strings: TemplateStringsArray, ...values: unknown[]) => TemplateResult;
+export {};
+//# sourceMappingURL=static.d.ts.map

package/src/lib/quire/versions/1.0.0-pre-release.2/node_modules/lit-html/development/static.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"static.d.ts","sourceRoot":"","sources":["../src/static.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAKH,OAAO,EAAC,IAAI,IAAI,QAAQ,EAAE,GAAG,IAAI,OAAO,EAAE,cAAc,EAAC,MAAM,eAAe,CAAC;AAE/E,MAAM,WAAW,WAAW;IAC1B,wDAAwD;IACxD,YAAY,EAAE,MAAM,CAAC;IAErB;;;;OAIG;IACH,CAAC,EAAE,OAAO,KAAK,CAAC;CACjB;AAED;;;;;;;;;;;;;;GAcG;AACH,QAAA,MAAM,KAAK,eAAiB,CAAC;AAU7B;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,YAAY,UAAW,MAAM,KAAG,WAG3C,CAAC;AAaH;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,OAAO,YACT,oBAAoB,aAClB,OAAO,EAAE,KACnB,WAMD,CAAC;AAIH;;GAEG;AACH,eAAO,MAAM,UAAU,YACX,eAAe,GAAG,cAAc,eAChC,oBAAoB,aAAa,OAAO,EAAE,KAAG,cAkDtD,CAAC;AAEJ;;;;;GAKG;AACH,eAAO,MAAM,IAAI,YA1DL,oBAAoB,aAAa,OAAO,EAAE,KAAG,cA0DjB,CAAC;AAEzC;;;;;GAKG;AACH,eAAO,MAAM,GAAG,YAlEJ,oBAAoB,aAAa,OAAO,EAAE,KAAG,cAkEnB,CAAC"}

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

@@ -0,0 +1,139 @@
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ * SPDX-License-Identifier: BSD-3-Clause
+ */
+// Any new exports need to be added to the export statement in
+// `packages/lit/src/index.all.ts`.
+import { html as coreHtml, svg as coreSvg } from './lit-html.js';
+/**
+ * Prevents JSON injection attacks.
+ *
+ * The goals of this brand:
+ *   1) fast to check
+ *   2) code is small on the wire
+ *   3) multiple versions of Lit in a single page will all produce mutually
+ *      interoperable StaticValues
+ *   4) normal JSON.parse (without an unusual reviver) can not produce a
+ *      StaticValue
+ *
+ * Symbols satisfy (1), (2), and (4). We use Symbol.for to satisfy (3), but
+ * we don't care about the key, so we break ties via (2) and use the empty
+ * string.
+ */
+const brand = Symbol.for('');
+/** Safely extracts the string part of a StaticValue. */
+const unwrapStaticValue = (value) => {
+    if ((value === null || value === void 0 ? void 0 : value.r) !== brand) {
+        return undefined;
+    }
+    return value === null || value === void 0 ? void 0 : value['_$litStatic$'];
+};
+/**
+ * Wraps a string so that it behaves like part of the static template
+ * strings instead of a dynamic value.
+ *
+ * Users must take care to ensure that adding the static string to the template
+ * results in well-formed HTML, or else templates may break unexpectedly.
+ *
+ * Note that this function is unsafe to use on untrusted content, as it will be
+ * directly parsed into HTML. Do not pass user input to this function
+ * without sanitizing it.
+ *
+ * Static values can be changed, but they will cause a complete re-render
+ * since they effectively create a new template.
+ */
+export const unsafeStatic = (value) => ({
+    ['_$litStatic$']: value,
+    r: brand,
+});
+const textFromStatic = (value) => {
+    if (value['_$litStatic$'] !== undefined) {
+        return value['_$litStatic$'];
+    }
+    else {
+        throw new Error(`Value passed to 'literal' function must be a 'literal' result: ${value}. Use 'unsafeStatic' to pass non-literal values, but
+            take care to ensure page security.`);
+    }
+};
+/**
+ * Tags a string literal so that it behaves like part of the static template
+ * strings instead of a dynamic value.
+ *
+ * The only values that may be used in template expressions are other tagged
+ * `literal` results or `unsafeStatic` values (note that untrusted content
+ * should never be passed to `unsafeStatic`).
+ *
+ * Users must take care to ensure that adding the static string to the template
+ * results in well-formed HTML, or else templates may break unexpectedly.
+ *
+ * Static values can be changed, but they will cause a complete re-render since
+ * they effectively create a new template.
+ */
+export const literal = (strings, ...values) => ({
+    ['_$litStatic$']: values.reduce((acc, v, idx) => acc + textFromStatic(v) + strings[idx + 1], strings[0]),
+    r: brand,
+});
+const stringsCache = new Map();
+/**
+ * Wraps a lit-html template tag (`html` or `svg`) to add static value support.
+ */
+export const withStatic = (coreTag) => (strings, ...values) => {
+    const l = values.length;
+    let staticValue;
+    let dynamicValue;
+    const staticStrings = [];
+    const dynamicValues = [];
+    let i = 0;
+    let hasStatics = false;
+    let s;
+    while (i < l) {
+        s = strings[i];
+        // Collect any unsafeStatic values, and their following template strings
+        // so that we treat a run of template strings and unsafe static values as
+        // a single template string.
+        while (i < l &&
+            ((dynamicValue = values[i]),
+                (staticValue = unwrapStaticValue(dynamicValue))) !== undefined) {
+            s += staticValue + strings[++i];
+            hasStatics = true;
+        }
+        dynamicValues.push(dynamicValue);
+        staticStrings.push(s);
+        i++;
+    }
+    // If the last value isn't static (which would have consumed the last
+    // string), then we need to add the last string.
+    if (i === l) {
+        staticStrings.push(strings[l]);
+    }
+    if (hasStatics) {
+        const key = staticStrings.join('$$lit$$');
+        strings = stringsCache.get(key);
+        if (strings === undefined) {
+            // Beware: in general this pattern is unsafe, and doing so may bypass
+            // lit's security checks and allow an attacker to execute arbitrary
+            // code and inject arbitrary content.
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            staticStrings.raw = staticStrings;
+            stringsCache.set(key, (strings = staticStrings));
+        }
+        values = dynamicValues;
+    }
+    return coreTag(strings, ...values);
+};
+/**
+ * Interprets a template literal as an HTML template that can efficiently
+ * render to and update a container.
+ *
+ * Includes static value support from `lit-html/static.js`.
+ */
+export const html = withStatic(coreHtml);
+/**
+ * Interprets a template literal as an SVG template that can efficiently
+ * render to and update a container.
+ *
+ * Includes static value support from `lit-html/static.js`.
+ */
+export const svg = withStatic(coreSvg);
+//# sourceMappingURL=static.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"static.js","sourceRoot":"","sources":["../src/static.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n * Copyright 2020 Google LLC\n * SPDX-License-Identifier: BSD-3-Clause\n */\n\n// Any new exports need to be added to the export statement in\n// `packages/lit/src/index.all.ts`.\n\nimport {html as coreHtml, svg as coreSvg, TemplateResult} from './lit-html.js';\n\nexport interface StaticValue {\n  /** The value to interpolate as-is into the template. */\n  _$litStatic$: string;\n\n  /**\n   * A value that can't be decoded from ordinary JSON, make it harder for\n   * a attacker-controlled data that goes through JSON.parse to produce a valid\n   * StaticValue.\n   */\n  r: typeof brand;\n}\n\n/**\n * Prevents JSON injection attacks.\n *\n * The goals of this brand:\n *   1) fast to check\n *   2) code is small on the wire\n *   3) multiple versions of Lit in a single page will all produce mutually\n *      interoperable StaticValues\n *   4) normal JSON.parse (without an unusual reviver) can not produce a\n *      StaticValue\n *\n * Symbols satisfy (1), (2), and (4). We use Symbol.for to satisfy (3), but\n * we don't care about the key, so we break ties via (2) and use the empty\n * string.\n */\nconst brand = Symbol.for('');\n\n/** Safely extracts the string part of a StaticValue. */\nconst unwrapStaticValue = (value: unknown): string | undefined => {\n  if ((value as Partial<StaticValue>)?.r !== brand) {\n    return undefined;\n  }\n  return (value as Partial<StaticValue>)?.['_$litStatic$'];\n};\n\n/**\n * Wraps a string so that it behaves like part of the static template\n * strings instead of a dynamic value.\n *\n * Users must take care to ensure that adding the static string to the template\n * results in well-formed HTML, or else templates may break unexpectedly.\n *\n * Note that this function is unsafe to use on untrusted content, as it will be\n * directly parsed into HTML. Do not pass user input to this function\n * without sanitizing it.\n *\n * Static values can be changed, but they will cause a complete re-render\n * since they effectively create a new template.\n */\nexport const unsafeStatic = (value: string): StaticValue => ({\n  ['_$litStatic$']: value,\n  r: brand,\n});\n\nconst textFromStatic = (value: StaticValue) => {\n  if (value['_$litStatic$'] !== undefined) {\n    return value['_$litStatic$'];\n  } else {\n    throw new Error(\n      `Value passed to 'literal' function must be a 'literal' result: ${value}. Use 'unsafeStatic' to pass non-literal values, but\n            take care to ensure page security.`\n    );\n  }\n};\n\n/**\n * Tags a string literal so that it behaves like part of the static template\n * strings instead of a dynamic value.\n *\n * The only values that may be used in template expressions are other tagged\n * `literal` results or `unsafeStatic` values (note that untrusted content\n * should never be passed to `unsafeStatic`).\n *\n * Users must take care to ensure that adding the static string to the template\n * results in well-formed HTML, or else templates may break unexpectedly.\n *\n * Static values can be changed, but they will cause a complete re-render since\n * they effectively create a new template.\n */\nexport const literal = (\n  strings: TemplateStringsArray,\n  ...values: unknown[]\n): StaticValue => ({\n  ['_$litStatic$']: values.reduce(\n    (acc, v, idx) => acc + textFromStatic(v as StaticValue) + strings[idx + 1],\n    strings[0]\n  ) as string,\n  r: brand,\n});\n\nconst stringsCache = new Map<string, TemplateStringsArray>();\n\n/**\n * Wraps a lit-html template tag (`html` or `svg`) to add static value support.\n */\nexport const withStatic =\n  (coreTag: typeof coreHtml | typeof coreSvg) =>\n  (strings: TemplateStringsArray, ...values: unknown[]): TemplateResult => {\n    const l = values.length;\n    let staticValue: string | undefined;\n    let dynamicValue: unknown;\n    const staticStrings: Array<string> = [];\n    const dynamicValues: Array<unknown> = [];\n    let i = 0;\n    let hasStatics = false;\n    let s: string;\n\n    while (i < l) {\n      s = strings[i];\n      // Collect any unsafeStatic values, and their following template strings\n      // so that we treat a run of template strings and unsafe static values as\n      // a single template string.\n      while (\n        i < l &&\n        ((dynamicValue = values[i]),\n        (staticValue = unwrapStaticValue(dynamicValue))) !== undefined\n      ) {\n        s += staticValue + strings[++i];\n        hasStatics = true;\n      }\n      dynamicValues.push(dynamicValue);\n      staticStrings.push(s);\n      i++;\n    }\n    // If the last value isn't static (which would have consumed the last\n    // string), then we need to add the last string.\n    if (i === l) {\n      staticStrings.push(strings[l]);\n    }\n\n    if (hasStatics) {\n      const key = staticStrings.join('$$lit$$');\n      strings = stringsCache.get(key)!;\n      if (strings === undefined) {\n        // Beware: in general this pattern is unsafe, and doing so may bypass\n        // lit's security checks and allow an attacker to execute arbitrary\n        // code and inject arbitrary content.\n        // eslint-disable-next-line @typescript-eslint/no-explicit-any\n        (staticStrings as any).raw = staticStrings;\n        stringsCache.set(\n          key,\n          (strings = staticStrings as unknown as TemplateStringsArray)\n        );\n      }\n      values = dynamicValues;\n    }\n    return coreTag(strings, ...values);\n  };\n\n/**\n * Interprets a template literal as an HTML template that can efficiently\n * render to and update a container.\n *\n * Includes static value support from `lit-html/static.js`.\n */\nexport const html = withStatic(coreHtml);\n\n/**\n * Interprets a template literal as an SVG template that can efficiently\n * render to and update a container.\n *\n * Includes static value support from `lit-html/static.js`.\n */\nexport const svg = withStatic(coreSvg);\n"]}

package/src/lib/quire/versions/1.0.0-pre-release.2/node_modules/lit-html/directive-helpers.d.ts

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

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

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

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

@@ -0,0 +1,7 @@
+import{_$LH as o}from"./lit-html.js";
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ * SPDX-License-Identifier: BSD-3-Clause
+ */const{I:l}=o,t=o=>null===o||"object"!=typeof o&&"function"!=typeof o,i={HTML:1,SVG:2},n=(o,l)=>void 0===l?void 0!==(null==o?void 0:o._$litType$):(null==o?void 0:o._$litType$)===l,d=o=>void 0!==(null==o?void 0:o._$litDirective$),v=o=>null==o?void 0:o._$litDirective$,e=o=>void 0===o.strings,c=()=>document.createComment(""),r=(o,t,i)=>{var n;const d=o._$AA.parentNode,v=void 0===t?o._$AB:t._$AA;if(void 0===i){const t=d.insertBefore(c(),v),n=d.insertBefore(c(),v);i=new l(t,n,o,o.options)}else{const l=i._$AB.nextSibling,t=i._$AM,e=t!==o;if(e){let l;null===(n=i._$AQ)||void 0===n||n.call(i,o),i._$AM=o,void 0!==i._$AP&&(l=o._$AU)!==t._$AU&&i._$AP(l)}if(l!==v||e){let o=i._$AA;for(;o!==l;){const l=o.nextSibling;d.insertBefore(o,v),o=l}}}return i},u=(o,l,t=o)=>(o._$AI(l,t),o),f={},s=(o,l=f)=>o._$AH=l,m=o=>o._$AH,p=o=>{var l;null===(l=o._$AP)||void 0===l||l.call(o,!1,!0);let t=o._$AA;const i=o._$AB.nextSibling;for(;t!==i;){const o=t.nextSibling;t.remove(),t=o}},a=o=>{o._$AR()};export{i as TemplateResultType,a as clearPart,m as getCommittedValue,v as getDirectiveClass,r as insertPart,d as isDirectiveResult,t as isPrimitive,e as isSingleExpression,n as isTemplateResult,p as removePart,u as setChildPartValue,s as setCommittedValue};
+//# sourceMappingURL=directive-helpers.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"directive-helpers.js","sources":["src/directive-helpers.ts"],"sourcesContent":["/**\n * @license\n * Copyright 2020 Google LLC\n * SPDX-License-Identifier: BSD-3-Clause\n */\n\nimport {_$LH, Part, DirectiveParent, TemplateResult} from './lit-html.js';\nimport {\n  DirectiveResult,\n  DirectiveClass,\n  PartInfo,\n  AttributePartInfo,\n} from './directive.js';\ntype Primitive = null | undefined | boolean | number | string | symbol | bigint;\n\nconst {_ChildPart: ChildPart} = _$LH;\n\ntype ChildPart = InstanceType<typeof ChildPart>;\n\nconst ENABLE_SHADYDOM_NOPATCH = true;\n\nconst wrap =\n  ENABLE_SHADYDOM_NOPATCH &&\n  window.ShadyDOM?.inUse &&\n  window.ShadyDOM?.noPatch === true\n    ? window.ShadyDOM!.wrap\n    : (node: Node) => node;\n\n/**\n * Tests if a value is a primitive value.\n *\n * See https://tc39.github.io/ecma262/#sec-typeof-operator\n */\nexport const isPrimitive = (value: unknown): value is Primitive =>\n  value === null || (typeof value != 'object' && typeof value != 'function');\n\nexport const TemplateResultType = {\n  HTML: 1,\n  SVG: 2,\n} as const;\n\nexport type TemplateResultType =\n  typeof TemplateResultType[keyof typeof TemplateResultType];\n\n/**\n * Tests if a value is a TemplateResult.\n */\nexport const isTemplateResult = (\n  value: unknown,\n  type?: TemplateResultType\n): value is TemplateResult =>\n  type === undefined\n    ? // This property needs to remain unminified.\n      (value as TemplateResult)?.['_$litType$'] !== undefined\n    : (value as TemplateResult)?.['_$litType$'] === type;\n\n/**\n * Tests if a value is a DirectiveResult.\n */\nexport const isDirectiveResult = (value: unknown): value is DirectiveResult =>\n  // This property needs to remain unminified.\n  (value as DirectiveResult)?.['_$litDirective$'] !== undefined;\n\n/**\n * Retrieves the Directive class for a DirectiveResult\n */\nexport const getDirectiveClass = (value: unknown): DirectiveClass | undefined =>\n  // This property needs to remain unminified.\n  (value as DirectiveResult)?.['_$litDirective$'];\n\n/**\n * Tests whether a part has only a single-expression with no strings to\n * interpolate between.\n *\n * Only AttributePart and PropertyPart can have multiple expressions.\n * Multi-expression parts have a `strings` property and single-expression\n * parts do not.\n */\nexport const isSingleExpression = (part: PartInfo) =>\n  (part as AttributePartInfo).strings === undefined;\n\nconst createMarker = () => document.createComment('');\n\n/**\n * Inserts a ChildPart into the given container ChildPart's DOM, either at the\n * end of the container ChildPart, or before the optional `refPart`.\n *\n * This does not add the part to the containerPart's committed value. That must\n * be done by callers.\n *\n * @param containerPart Part within which to add the new ChildPart\n * @param refPart Part before which to add the new ChildPart; when omitted the\n *     part added to the end of the `containerPart`\n * @param part Part to insert, or undefined to create a new part\n */\nexport const insertPart = (\n  containerPart: ChildPart,\n  refPart?: ChildPart,\n  part?: ChildPart\n): ChildPart => {\n  const container = wrap(containerPart._$startNode).parentNode!;\n\n  const refNode =\n    refPart === undefined ? containerPart._$endNode : refPart._$startNode;\n\n  if (part === undefined) {\n    const startNode = wrap(container).insertBefore(createMarker(), refNode);\n    const endNode = wrap(container).insertBefore(createMarker(), refNode);\n    part = new ChildPart(\n      startNode,\n      endNode,\n      containerPart,\n      containerPart.options\n    );\n  } else {\n    const endNode = wrap(part._$endNode!).nextSibling;\n    const oldParent = part._$parent;\n    const parentChanged = oldParent !== containerPart;\n    if (parentChanged) {\n      part._$reparentDisconnectables?.(containerPart);\n      // Note that although `_$reparentDisconnectables` updates the part's\n      // `_$parent` reference after unlinking from its current parent, that\n      // method only exists if Disconnectables are present, so we need to\n      // unconditionally set it here\n      part._$parent = containerPart;\n      // Since the _$isConnected getter is somewhat costly, only\n      // read it once we know the subtree has directives that need\n      // to be notified\n      let newConnectionState;\n      if (\n        part._$notifyConnectionChanged !== undefined &&\n        (newConnectionState = containerPart._$isConnected) !==\n          oldParent!._$isConnected\n      ) {\n        part._$notifyConnectionChanged(newConnectionState);\n      }\n    }\n    if (endNode !== refNode || parentChanged) {\n      let start: Node | null = part._$startNode;\n      while (start !== endNode) {\n        const n: Node | null = wrap(start!).nextSibling;\n        wrap(container).insertBefore(start!, refNode);\n        start = n;\n      }\n    }\n  }\n\n  return part;\n};\n\n/**\n * Sets the value of a Part.\n *\n * Note that this should only be used to set/update the value of user-created\n * parts (i.e. those created using `insertPart`); it should not be used\n * by directives to set the value of the directive's container part. Directives\n * should return a value from `update`/`render` to update their part state.\n *\n * For directives that require setting their part value asynchronously, they\n * should extend `AsyncDirective` and call `this.setValue()`.\n *\n * @param part Part to set\n * @param value Value to set\n * @param index For `AttributePart`s, the index to set\n * @param directiveParent Used internally; should not be set by user\n */\nexport const setChildPartValue = <T extends ChildPart>(\n  part: T,\n  value: unknown,\n  directiveParent: DirectiveParent = part\n): T => {\n  part._$setValue(value, directiveParent);\n  return part;\n};\n\n// A sentinal value that can never appear as a part value except when set by\n// live(). Used to force a dirty-check to fail and cause a re-render.\nconst RESET_VALUE = {};\n\n/**\n * Sets the committed value of a ChildPart directly without triggering the\n * commit stage of the part.\n *\n * This is useful in cases where a directive needs to update the part such\n * that the next update detects a value change or not. When value is omitted,\n * the next update will be guaranteed to be detected as a change.\n *\n * @param part\n * @param value\n */\nexport const setCommittedValue = (part: Part, value: unknown = RESET_VALUE) =>\n  (part._$committedValue = value);\n\n/**\n * Returns the committed value of a ChildPart.\n *\n * The committed value is used for change detection and efficient updates of\n * the part. It can differ from the value set by the template or directive in\n * cases where the template value is transformed before being commited.\n *\n * - `TemplateResult`s are committed as a `TemplateInstance`\n * - Iterables are committed as `Array<ChildPart>`\n * - All other types are committed as the template value or value returned or\n *   set by a directive.\n *\n * @param part\n */\nexport const getCommittedValue = (part: ChildPart) => part._$committedValue;\n\n/**\n * Removes a ChildPart from the DOM, including any of its content.\n *\n * @param part The Part to remove\n */\nexport const removePart = (part: ChildPart) => {\n  part._$notifyConnectionChanged?.(false, true);\n  let start: ChildNode | null = part._$startNode;\n  const end: ChildNode | null = wrap(part._$endNode!).nextSibling;\n  while (start !== end) {\n    const n: ChildNode | null = wrap(start!).nextSibling;\n    (wrap(start!) as ChildNode).remove();\n    start = n;\n  }\n};\n\nexport const clearPart = (part: ChildPart) => {\n  part._$clear();\n};\n"],"names":["_ChildPart","ChildPart","_$LH","isPrimitive","value","TemplateResultType","HTML","SVG","isTemplateResult","type","undefined","isDirectiveResult","getDirectiveClass","isSingleExpression","part","strings","createMarker","document","createComment","insertPart","containerPart","refPart","container","_$startNode","parentNode","refNode","_$endNode","startNode","insertBefore","endNode","options","nextSibling","oldParent","_$parent","parentChanged","newConnectionState","_a","_$reparentDisconnectables","call","_$notifyConnectionChanged","_$isConnected","start","n","setChildPartValue","directiveParent","_$setValue","RESET_VALUE","setCommittedValue","_$committedValue","getCommittedValue","removePart","end","remove","clearPart","_$clear"],"mappings":";;;;;GAeA,MAAOA,EAAYC,GAAaC,EAkBnBC,EAAeC,GAChB,OAAVA,GAAmC,iBAATA,GAAqC,mBAATA,EAE3CC,EAAqB,CAChCC,KAAM,EACNC,IAAK,GASMC,EAAmB,CAC9BJ,EACAK,SAESC,IAATD,OAEkDC,KAA7CN,aAAK,EAALA,EAAuC,aACvCA,aAAK,EAALA,EAAuC,cAAMK,EAKvCE,EAAqBP,QAEoBM,KAAnDN,aAAA,EAAAA,EAA6C,iBAKnCQ,EAAqBR,GAE/BA,aAAK,EAALA,EAA6C,gBAUnCS,EAAsBC,QACOJ,IAAvCI,EAA2BC,QAExBC,EAAe,IAAMC,SAASC,cAAc,IAcrCC,EAAa,CACxBC,EACAC,EACAP,WAEA,MAAMQ,EAAiBF,EAAcG,KAAaC,WAE5CC,OACQf,IAAZW,EAAwBD,EAAcM,KAAYL,EAAQE,KAE5D,QAAab,IAATI,EAAoB,CACtB,MAAMa,EAAiBL,EAAWM,aAAaZ,IAAgBS,GACzDI,EAAeP,EAAWM,aAAaZ,IAAgBS,GAC7DX,EAAO,IAAIb,EACT0B,EACAE,EACAT,EACAA,EAAcU,QAEjB,KAAM,CACL,MAAMD,EAAef,EAAKY,KAAYK,YAChCC,EAAYlB,EAAKmB,KACjBC,EAAgBF,IAAcZ,EACpC,GAAIc,EAAe,CAUjB,IAAIC,EAT6B,QAAjCC,EAAAtB,EAAKuB,YAA4B,IAAAD,GAAAA,EAAAE,KAAAxB,EAAAM,GAKjCN,EAAKmB,KAAWb,OAMqBV,IAAnCI,EAAKyB,OACJJ,EAAqBf,EAAcoB,QAClCR,EAAWQ,MAEb1B,EAAKyB,KAA0BJ,EAElC,CACD,GAAIN,IAAYJ,GAAWS,EAAe,CACxC,IAAIO,EAAqB3B,EAAKS,KAC9B,KAAOkB,IAAUZ,GAAS,CACxB,MAAMa,EAAsBD,EAAQV,YAC/BT,EAAWM,aAAaa,EAAQhB,GACrCgB,EAAQC,CACT,CACF,CACF,CAED,OAAO5B,CAAI,EAmBA6B,EAAoB,CAC/B7B,EACAV,EACAwC,EAAmC9B,KAEnCA,EAAK+B,KAAWzC,EAAOwC,GAChB9B,GAKHgC,EAAc,CAAA,EAaPC,EAAoB,CAACjC,EAAYV,EAAiB0C,IAC5DhC,EAAKkC,KAAmB5C,EAgBd6C,EAAqBnC,GAAoBA,EAAKkC,KAO9CE,EAAcpC,UACK,QAA9BsB,EAAAtB,EAAKyB,YAAyB,IAAAH,GAAAA,EAAAE,KAAAxB,GAAG,GAAO,GACxC,IAAI2B,EAA0B3B,EAAKS,KACnC,MAAM4B,EAA6BrC,EAAKY,KAAYK,YACpD,KAAOU,IAAUU,GAAK,CACpB,MAAMT,EAA2BD,EAAQV,YACnCU,EAAsBW,SAC5BX,EAAQC,CACT,GAGUW,EAAavC,IACxBA,EAAKwC,MAAS"}

package/src/lib/quire/versions/1.0.0-pre-release.2/node_modules/lit-html/directive.d.ts

@@ -0,0 +1,66 @@
+/**
+ * @license
+ * Copyright 2017 Google LLC
+ * SPDX-License-Identifier: BSD-3-Clause
+ */
+import { Disconnectable, Part } from './lit-html.js';
+export { AttributePart, BooleanAttributePart, ChildPart, ElementPart, EventPart, Part, PropertyPart, } from './lit-html.js';
+export interface DirectiveClass {
+    new (part: PartInfo): Directive;
+}
+/**
+ * This utility type extracts the signature of a directive class's render()
+ * method so we can use it for the type of the generated directive function.
+ */
+export declare type DirectiveParameters<C extends Directive> = Parameters<C['render']>;
+/**
+ * A generated directive function doesn't evaluate the directive, but just
+ * returns a DirectiveResult object that captures the arguments.
+ */
+export interface DirectiveResult<C extends DirectiveClass = DirectiveClass> {
+}
+export declare const PartType: {
+    readonly ATTRIBUTE: 1;
+    readonly CHILD: 2;
+    readonly PROPERTY: 3;
+    readonly BOOLEAN_ATTRIBUTE: 4;
+    readonly EVENT: 5;
+    readonly ELEMENT: 6;
+};
+export declare type PartType = typeof PartType[keyof typeof PartType];
+export interface ChildPartInfo {
+    readonly type: typeof PartType.CHILD;
+}
+export interface AttributePartInfo {
+    readonly type: typeof PartType.ATTRIBUTE | typeof PartType.PROPERTY | typeof PartType.BOOLEAN_ATTRIBUTE | typeof PartType.EVENT;
+    readonly strings?: ReadonlyArray<string>;
+    readonly name: string;
+    readonly tagName: string;
+}
+export interface ElementPartInfo {
+    readonly type: typeof PartType.ELEMENT;
+}
+/**
+ * Information about the part a directive is bound to.
+ *
+ * This is useful for checking that a directive is attached to a valid part,
+ * such as with directive that can only be used on attribute bindings.
+ */
+export declare type PartInfo = ChildPartInfo | AttributePartInfo | ElementPartInfo;
+/**
+ * Creates a user-facing directive function from a Directive class. This
+ * function has the same parameters as the directive's render() method.
+ */
+export declare const directive: <C extends DirectiveClass>(c: C) => (...values: Parameters<InstanceType<C>["render"]>) => DirectiveResult<C>;
+/**
+ * Base class for creating custom directives. Users should extend this class,
+ * implement `render` and/or `update`, and then pass their subclass to
+ * `directive`.
+ */
+export declare abstract class Directive implements Disconnectable {
+    constructor(_partInfo: PartInfo);
+    get _$isConnected(): boolean;
+    abstract render(...props: Array<unknown>): unknown;
+    update(_part: Part, props: Array<unknown>): unknown;
+}
+//# sourceMappingURL=directive.d.ts.map

package/src/lib/quire/versions/1.0.0-pre-release.2/node_modules/lit-html/directive.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"directive.d.ts","sourceRoot":"","sources":["../src/directive.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAC,cAAc,EAAE,IAAI,EAAC,MAAM,eAAe,CAAC;AAEnD,OAAO,EACL,aAAa,EACb,oBAAoB,EACpB,SAAS,EACT,WAAW,EACX,SAAS,EACT,IAAI,EACJ,YAAY,GACb,MAAM,eAAe,CAAC;AAEvB,MAAM,WAAW,cAAc;IAC7B,KAAK,IAAI,EAAE,QAAQ,GAAG,SAAS,CAAC;CACjC;AAED;;;GAGG;AACH,oBAAY,mBAAmB,CAAC,CAAC,SAAS,SAAS,IAAI,UAAU,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC;AAE/E;;;GAGG;AACH,MAAM,WAAW,eAAe,CAAC,CAAC,SAAS,cAAc,GAAG,cAAc;CAOzE;AAED,eAAO,MAAM,QAAQ;;;;;;;CAOX,CAAC;AAEX,oBAAY,QAAQ,GAAG,OAAO,QAAQ,CAAC,MAAM,OAAO,QAAQ,CAAC,CAAC;AAE9D,MAAM,WAAW,aAAa;IAC5B,QAAQ,CAAC,IAAI,EAAE,OAAO,QAAQ,CAAC,KAAK,CAAC;CACtC;AAED,MAAM,WAAW,iBAAiB;IAChC,QAAQ,CAAC,IAAI,EACT,OAAO,QAAQ,CAAC,SAAS,GACzB,OAAO,QAAQ,CAAC,QAAQ,GACxB,OAAO,QAAQ,CAAC,iBAAiB,GACjC,OAAO,QAAQ,CAAC,KAAK,CAAC;IAC1B,QAAQ,CAAC,OAAO,CAAC,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;IACzC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;CAC1B;AAED,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,IAAI,EAAE,OAAO,QAAQ,CAAC,OAAO,CAAC;CACxC;AAED;;;;;GAKG;AACH,oBAAY,QAAQ,GAAG,aAAa,GAAG,iBAAiB,GAAG,eAAe,CAAC;AAE3E;;;GAGG;AACH,eAAO,MAAM,SAAS,8GAMlB,CAAC;AAEL;;;;GAIG;AACH,8BAAsB,SAAU,YAAW,cAAc;gBAkB3C,SAAS,EAAE,QAAQ;IAG/B,IAAI,aAAa,YAEhB;IAiBD,QAAQ,CAAC,MAAM,CAAC,GAAG,KAAK,EAAE,KAAK,CAAC,OAAO,CAAC,GAAG,OAAO;IAElD,MAAM,CAAC,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,KAAK,CAAC,OAAO,CAAC,GAAG,OAAO;CAGpD"}

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

@@ -0,0 +1,7 @@
+/**
+ * @license
+ * Copyright 2017 Google LLC
+ * SPDX-License-Identifier: BSD-3-Clause
+ */
+const t={ATTRIBUTE:1,CHILD:2,PROPERTY:3,BOOLEAN_ATTRIBUTE:4,EVENT:5,ELEMENT:6},e=t=>(...e)=>({_$litDirective$:t,values:e});class i{constructor(t){}get _$AU(){return this._$AM._$AU}_$AT(t,e,i){this._$Ct=t,this._$AM=e,this._$Ci=i}_$AS(t,e){return this.update(t,e)}update(t,e){return this.render(...e)}}export{i as Directive,t as PartType,e as directive};
+//# sourceMappingURL=directive.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"directive.js","sources":["src/directive.ts"],"sourcesContent":["/**\n * @license\n * Copyright 2017 Google LLC\n * SPDX-License-Identifier: BSD-3-Clause\n */\n\nimport {Disconnectable, Part} from './lit-html.js';\n\nexport {\n  AttributePart,\n  BooleanAttributePart,\n  ChildPart,\n  ElementPart,\n  EventPart,\n  Part,\n  PropertyPart,\n} from './lit-html.js';\n\nexport interface DirectiveClass {\n  new (part: PartInfo): Directive;\n}\n\n/**\n * This utility type extracts the signature of a directive class's render()\n * method so we can use it for the type of the generated directive function.\n */\nexport type DirectiveParameters<C extends Directive> = Parameters<C['render']>;\n\n/**\n * A generated directive function doesn't evaluate the directive, but just\n * returns a DirectiveResult object that captures the arguments.\n */\nexport interface DirectiveResult<C extends DirectiveClass = DirectiveClass> {\n  /**\n   * This property needs to remain unminified.\n   * @internal */\n  ['_$litDirective$']: C;\n  /** @internal */\n  values: DirectiveParameters<InstanceType<C>>;\n}\n\nexport const PartType = {\n  ATTRIBUTE: 1,\n  CHILD: 2,\n  PROPERTY: 3,\n  BOOLEAN_ATTRIBUTE: 4,\n  EVENT: 5,\n  ELEMENT: 6,\n} as const;\n\nexport type PartType = typeof PartType[keyof typeof PartType];\n\nexport interface ChildPartInfo {\n  readonly type: typeof PartType.CHILD;\n}\n\nexport interface AttributePartInfo {\n  readonly type:\n    | typeof PartType.ATTRIBUTE\n    | typeof PartType.PROPERTY\n    | typeof PartType.BOOLEAN_ATTRIBUTE\n    | typeof PartType.EVENT;\n  readonly strings?: ReadonlyArray<string>;\n  readonly name: string;\n  readonly tagName: string;\n}\n\nexport interface ElementPartInfo {\n  readonly type: typeof PartType.ELEMENT;\n}\n\n/**\n * Information about the part a directive is bound to.\n *\n * This is useful for checking that a directive is attached to a valid part,\n * such as with directive that can only be used on attribute bindings.\n */\nexport type PartInfo = ChildPartInfo | AttributePartInfo | ElementPartInfo;\n\n/**\n * Creates a user-facing directive function from a Directive class. This\n * function has the same parameters as the directive's render() method.\n */\nexport const directive =\n  <C extends DirectiveClass>(c: C) =>\n  (...values: DirectiveParameters<InstanceType<C>>): DirectiveResult<C> => ({\n    // This property needs to remain unminified.\n    ['_$litDirective$']: c,\n    values,\n  });\n\n/**\n * Base class for creating custom directives. Users should extend this class,\n * implement `render` and/or `update`, and then pass their subclass to\n * `directive`.\n */\nexport abstract class Directive implements Disconnectable {\n  //@internal\n  __part!: Part;\n  //@internal\n  __attributeIndex: number | undefined;\n  //@internal\n  __directive?: Directive;\n\n  //@internal\n  _$parent!: Disconnectable;\n\n  // These will only exist on the AsyncDirective subclass\n  //@internal\n  _$disconnectableChildren?: Set<Disconnectable>;\n  // This property needs to remain unminified.\n  //@internal\n  ['_$notifyDirectiveConnectionChanged']?(isConnected: boolean): void;\n\n  constructor(_partInfo: PartInfo) {}\n\n  // See comment in Disconnectable interface for why this is a getter\n  get _$isConnected() {\n    return this._$parent._$isConnected;\n  }\n\n  /** @internal */\n  _$initialize(\n    part: Part,\n    parent: Disconnectable,\n    attributeIndex: number | undefined\n  ) {\n    this.__part = part;\n    this._$parent = parent;\n    this.__attributeIndex = attributeIndex;\n  }\n  /** @internal */\n  _$resolve(part: Part, props: Array<unknown>): unknown {\n    return this.update(part, props);\n  }\n\n  abstract render(...props: Array<unknown>): unknown;\n\n  update(_part: Part, props: Array<unknown>): unknown {\n    return this.render(...props);\n  }\n}\n"],"names":["PartType","ATTRIBUTE","CHILD","PROPERTY","BOOLEAN_ATTRIBUTE","EVENT","ELEMENT","directive","c","values","_$litDirective$","Directive","constructor","_partInfo","_$isConnected","this","_$parent","_$initialize","part","parent","attributeIndex","__part","__attributeIndex","_$resolve","props","update","_part","render"],"mappings":";;;;;AAyCa,MAAAA,EAAW,CACtBC,UAAW,EACXC,MAAO,EACPC,SAAU,EACVC,kBAAmB,EACnBC,MAAO,EACPC,QAAS,GAoCEC,EACgBC,GAC3B,IAAIC,KAAsE,CAExEC,gBAAqBF,EACrBC,iBAQkBE,EAkBpBC,YAAYC,GAAuB,CAG/BC,WACF,OAAOC,KAAKC,KAASF,IACtB,CAGDG,KACEC,EACAC,EACAC,GAEAL,KAAKM,KAASH,EACdH,KAAKC,KAAWG,EAChBJ,KAAKO,KAAmBF,CACzB,CAEDG,KAAUL,EAAYM,GACpB,OAAOT,KAAKU,OAAOP,EAAMM,EAC1B,CAIDC,OAAOC,EAAaF,GAClB,OAAOT,KAAKY,UAAUH,EACvB"}

package/src/lib/quire/versions/1.0.0-pre-release.2/node_modules/lit-html/directives/async-append.d.ts

@@ -0,0 +1,39 @@
+/**
+ * @license
+ * Copyright 2017 Google LLC
+ * SPDX-License-Identifier: BSD-3-Clause
+ */
+import { ChildPart } from '../lit-html.js';
+import { DirectiveParameters, PartInfo } from '../directive.js';
+import { AsyncReplaceDirective } from './async-replace.js';
+declare class AsyncAppendDirective extends AsyncReplaceDirective {
+    private __childPart;
+    constructor(partInfo: PartInfo);
+    update(part: ChildPart, params: DirectiveParameters<this>): typeof import("../lit-html.js").noChange | undefined;
+    protected commitValue(value: unknown, index: number): void;
+}
+/**
+ * A directive that renders the items of an async iterable[1], appending new
+ * values after previous values, similar to the built-in support for iterables.
+ * This directive is usable only in child expressions.
+ *
+ * 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 appended to the
+ * Part controlled by the directive. If another value other than this
+ * directive has been set on the Part, the iterable will no longer be listened
+ * to and new values won't be written to the Part.
+ *
+ * [1]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/for-await...of
+ *
+ * @param value An async iterable
+ * @param mapper An optional function that maps from (value, index) to another
+ *     value. Useful for generating templates for each item in the iterable.
+ */
+export declare const asyncAppend: (value: AsyncIterable<unknown>, _mapper?: ((v: unknown, index?: number | undefined) => unknown) | undefined) => import("../directive.js").DirectiveResult<typeof AsyncAppendDirective>;
+/**
+ * The type of the class that powers this directive. Necessary for naming the
+ * directive's return type.
+ */
+export type { AsyncAppendDirective };
+//# sourceMappingURL=async-append.d.ts.map

package/src/lib/quire/versions/1.0.0-pre-release.2/node_modules/lit-html/directives/async-append.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"async-append.d.ts","sourceRoot":"","sources":["../../src/directives/async-append.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAC,SAAS,EAAC,MAAM,gBAAgB,CAAC;AACzC,OAAO,EAEL,mBAAmB,EACnB,QAAQ,EAET,MAAM,iBAAiB,CAAC;AACzB,OAAO,EAAC,qBAAqB,EAAC,MAAM,oBAAoB,CAAC;AAOzD,cAAM,oBAAqB,SAAQ,qBAAqB;IACtD,OAAO,CAAC,WAAW,CAAa;gBAGpB,QAAQ,EAAE,QAAQ;IAQrB,MAAM,CAAC,IAAI,EAAE,SAAS,EAAE,MAAM,EAAE,mBAAmB,CAAC,IAAI,CAAC;cAM/C,WAAW,CAAC,KAAK,EAAE,OAAO,EAAE,KAAK,EAAE,MAAM;CAU7D;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,WAAW,wLAAkC,CAAC;AAE3D;;;GAGG;AACH,YAAY,EAAC,oBAAoB,EAAC,CAAC"}

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

@@ -0,0 +1,7 @@
+import{directive as r,PartType as e}from"../directive.js";import{AsyncReplaceDirective as s}from"./async-replace.js";import{clearPart as t,insertPart as o,setChildPartValue as i}from"../directive-helpers.js";
+/**
+ * @license
+ * Copyright 2017 Google LLC
+ * SPDX-License-Identifier: BSD-3-Clause
+ */const c=r(class extends s{constructor(r){if(super(r),r.type!==e.CHILD)throw Error("asyncAppend can only be used in child expressions")}update(r,e){return this._$Ctt=r,super.update(r,e)}commitValue(r,e){0===e&&t(this._$Ctt);const s=o(this._$Ctt);i(s,r)}});export{c as asyncAppend};
+//# sourceMappingURL=async-append.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"async-append.js","sources":["../src/directives/async-append.ts"],"sourcesContent":["/**\n * @license\n * Copyright 2017 Google LLC\n * SPDX-License-Identifier: BSD-3-Clause\n */\n\nimport {ChildPart} from '../lit-html.js';\nimport {\n  directive,\n  DirectiveParameters,\n  PartInfo,\n  PartType,\n} from '../directive.js';\nimport {AsyncReplaceDirective} from './async-replace.js';\nimport {\n  clearPart,\n  insertPart,\n  setChildPartValue,\n} from '../directive-helpers.js';\n\nclass AsyncAppendDirective extends AsyncReplaceDirective {\n  private __childPart!: ChildPart;\n\n  // Override AsyncReplace to narrow the allowed part type to ChildPart only\n  constructor(partInfo: PartInfo) {\n    super(partInfo);\n    if (partInfo.type !== PartType.CHILD) {\n      throw new Error('asyncAppend can only be used in child expressions');\n    }\n  }\n\n  // Override AsyncReplace to save the part since we need to append into it\n  override update(part: ChildPart, params: DirectiveParameters<this>) {\n    this.__childPart = part;\n    return super.update(part, params);\n  }\n\n  // Override AsyncReplace to append rather than replace\n  protected override commitValue(value: unknown, index: number) {\n    // When we get the first value, clear the part. This lets the\n    // previous value display until we can replace it.\n    if (index === 0) {\n      clearPart(this.__childPart);\n    }\n    // Create and insert a new part and set its value to the next value\n    const newPart = insertPart(this.__childPart);\n    setChildPartValue(newPart, value);\n  }\n}\n\n/**\n * A directive that renders the items of an async iterable[1], appending new\n * values after previous values, similar to the built-in support for iterables.\n * This directive is usable only in child expressions.\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 appended 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 asyncAppend = directive(AsyncAppendDirective);\n\n/**\n * The type of the class that powers this directive. Necessary for naming the\n * directive's return type.\n */\nexport type {AsyncAppendDirective};\n"],"names":["asyncAppend","directive","AsyncReplaceDirective","constructor","partInfo","super","type","PartType","CHILD","Error","update","part","params","this","__childPart","commitValue","value","index","clearPart","newPart","insertPart","setChildPartValue"],"mappings":";;;;;SAoEaA,EAAcC,EAhD3B,cAAmCC,EAIjCC,YAAYC,GAEV,GADAC,MAAMD,GACFA,EAASE,OAASC,EAASC,MAC7B,MAAUC,MAAM,oDAEnB,CAGQC,OAAOC,EAAiBC,GAE/B,OADAC,KAAKC,MAAcH,EACZN,MAAMK,OAAOC,EAAMC,EAC3B,CAGkBG,YAAYC,EAAgBC,GAG/B,IAAVA,GACFC,EAAUL,KAAKC,OAGjB,MAAMK,EAAUC,EAAWP,KAAKC,OAChCO,EAAkBF,EAASH,EAC5B"}