ruby2js 4.0.3 → 4.0.4

data/lib/tasks/testrails/node_modules/lit-element/lib/decorators.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"decorators.js","sourceRoot":"","sources":["../src/lib/decorators.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAoCH,MAAM,mBAAmB,GACrB,CAAC,OAAe,EAAE,KAA+B,EAAE,EAAE;IACnD,MAAM,CAAC,cAAc,CAAC,MAAM,CAAC,OAAO,EAAE,KAAK,CAAC,CAAC;IAC7C,sEAAsE;IACtE,wDAAwD;IACxD,8CAA8C;IAC9C,sEAAsE;IACtE,+BAA+B;IAC/B,kCAAkC;IAClC,OAAO,KAAY,CAAC;AACtB,CAAC,CAAC;AAEN,MAAM,qBAAqB,GACvB,CAAC,OAAe,EAAE,UAA2B,EAAE,EAAE;IAC/C,MAAM,EAAC,IAAI,EAAE,QAAQ,EAAC,GAAG,UAAU,CAAC;IACpC,OAAO;QACL,IAAI;QACJ,QAAQ;QACR,oEAAoE;QACpE,QAAQ,CAAC,KAA+B;YACtC,MAAM,CAAC,cAAc,CAAC,MAAM,CAAC,OAAO,EAAE,KAAK,CAAC,CAAC;QAC/C,CAAC;KACF,CAAC;AACJ,CAAC,CAAC;AAEN;;;;;;;;;;;;;GAaG;AACH,MAAM,CAAC,MAAM,aAAa,GAAG,CAAC,OAAe,EAAE,EAAE,CAC7C,CAAC,iBAA2D,EAAE,EAAE,CAC5D,CAAC,OAAO,iBAAiB,KAAK,UAAU,CAAC,CAAC,CAAC;IAC/C,mBAAmB,CAAC,OAAO,EAAE,iBAAiB,CAAC,CAAC,CAAC;IACjD,qBAAqB,CAAC,OAAO,EAAE,iBAAiB,CAAC,CAAC;AAEtD,MAAM,gBAAgB,GAClB,CAAC,OAA4B,EAAE,OAAqB,EAAE,EAAE;IACtD,0EAA0E;IAC1E,wEAAwE;IACxE,kCAAkC;IAClC,IAAI,OAAO,CAAC,IAAI,KAAK,QAAQ,IAAI,OAAO,CAAC,UAAU;QAC/C,CAAC,CAAC,OAAO,IAAI,OAAO,CAAC,UAAU,CAAC,EAAE;QACpC,uCACK,OAAO,KACV,QAAQ,CAAC,KAA6B;gBACpC,KAAK,CAAC,cAAc,CAAC,OAAO,CAAC,GAAG,EAAE,OAAO,CAAC,CAAC;YAC7C,CAAC,IACD;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,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;AAEN,MAAM,cAAc,GAChB,CAAC,OAA4B,EAAE,KAAa,EAAE,IAAiB,EAAE,EAAE;IAChE,KAAK,CAAC,WAAsC;SACxC,cAAc,CAAC,IAAI,EAAE,OAAO,CAAC,CAAC;AACrC,CAAC,CAAC;AAEN;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,UAAU,QAAQ,CAAC,OAA6B;IACpD,4CAA4C;IAC5C,OAAO,CAAC,iBAAsC,EAAE,IAAkB,EAAO,EAAE,CAChE,CAAC,IAAI,KAAK,SAAS,CAAC,CAAC,CAAC;QAC7B,cAAc,CAAC,OAAQ,EAAE,iBAA2B,EAAE,IAAI,CAAC,CAAC,CAAC;QAC7D,gBAAgB,CAAC,OAAQ,EAAE,iBAAiC,CAAC,CAAC;AACpE,CAAC;AAWD;;;;;;;;GAQG;AACH,MAAM,UAAU,gBAAgB,CAAC,OAAqC;IACpE,OAAO,QAAQ,CAAC,EAAC,SAAS,EAAE,KAAK,EAAE,UAAU,EAAE,OAAO,aAAP,OAAO,uBAAP,OAAO,CAAE,UAAU,EAAC,CAAC,CAAC;AACvE,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,MAAM,UAAU,KAAK,CAAC,QAAgB,EAAE,KAAe;IACrD,OAAO,CAAC,iBAAsC;IACtC,4CAA4C;IAC5C,IAAkB,EAAO,EAAE;QACjC,MAAM,UAAU,GAAG;YACjB,GAAG;gBACD,OAAO,IAAI,CAAC,UAAU,CAAC,aAAa,CAAC,QAAQ,CAAC,CAAC;YACjD,CAAC;YACD,UAAU,EAAE,IAAI;YAChB,YAAY,EAAE,IAAI;SACnB,CAAC;QACF,IAAI,KAAK,EAAE;YACT,MAAM,GAAG,GAAG,OAAO,IAAI,KAAK,QAAQ,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC,CAAC,CAAC,KAAK,IAAI,EAAE,CAAC;YAC9D,UAAU,CAAC,GAAG,GAAG;gBACf,IAAK,IACgC,CAAC,GAAa,CAAC,KAAK,SAAS,EAAE;oBAClE,CAAE,IAAmD,CAAC,GAAa,CAAC;wBAC/D,IAAI,CAAC,UAAU,CAAC,aAAa,CAAC,QAAQ,CAAC,CAAC,CAAC;iBAC/C;gBACD,OACI,IAAmD,CAAC,GAAa,CAAC,CAAC;YACzE,CAAC,CAAC;SACH;QACD,OAAO,CAAC,IAAI,KAAK,SAAS,CAAC,CAAC,CAAC;YACzB,WAAW,CAAC,UAAU,EAAE,iBAA2B,EAAE,IAAI,CAAC,CAAC,CAAC;YAC5D,aAAa,CAAC,UAAU,EAAE,iBAAiC,CAAC,CAAC;IACnE,CAAC,CAAC;AACJ,CAAC;AAED,4EAA4E;AAC5E,4EAA4E;AAC5E,sEAAsE;AACtE,wEAAwE;AACxE,wCAAwC;AACxC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,MAAM,UAAU,UAAU,CAAC,QAAgB;IACzC,OAAO,CAAC,iBAAsC;IACtC,4CAA4C;IAC5C,IAAkB,EAAO,EAAE;QACjC,MAAM,UAAU,GAAG;YACjB,KAAK,CAAC,GAAG;gBACP,MAAM,IAAI,CAAC,cAAc,CAAC;gBAC1B,OAAO,IAAI,CAAC,UAAU,CAAC,aAAa,CAAC,QAAQ,CAAC,CAAC;YACjD,CAAC;YACD,UAAU,EAAE,IAAI;YAChB,YAAY,EAAE,IAAI;SACnB,CAAC;QACF,OAAO,CAAC,IAAI,KAAK,SAAS,CAAC,CAAC,CAAC;YACzB,WAAW,CAAC,UAAU,EAAE,iBAA2B,EAAE,IAAI,CAAC,CAAC,CAAC;YAC5D,aAAa,CAAC,UAAU,EAAE,iBAAiC,CAAC,CAAC;IACnE,CAAC,CAAC;AACJ,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,MAAM,UAAU,QAAQ,CAAC,QAAgB;IACvC,OAAO,CAAC,iBAAsC;IACtC,4CAA4C;IAC5C,IAAkB,EAAO,EAAE;QACjC,MAAM,UAAU,GAAG;YACjB,GAAG;gBACD,OAAO,IAAI,CAAC,UAAU,CAAC,gBAAgB,CAAC,QAAQ,CAAC,CAAC;YACpD,CAAC;YACD,UAAU,EAAE,IAAI;YAChB,YAAY,EAAE,IAAI;SACnB,CAAC;QACF,OAAO,CAAC,IAAI,KAAK,SAAS,CAAC,CAAC,CAAC;YACzB,WAAW,CAAC,UAAU,EAAE,iBAA2B,EAAE,IAAI,CAAC,CAAC,CAAC;YAC5D,aAAa,CAAC,UAAU,EAAE,iBAAiC,CAAC,CAAC;IACnE,CAAC,CAAC;AACJ,CAAC;AAED,MAAM,WAAW,GACb,CAAC,UAA8B,EAAE,KAAa,EAAE,IAAiB,EAAE,EAAE;IACnE,MAAM,CAAC,cAAc,CAAC,KAAK,EAAE,IAAI,EAAE,UAAU,CAAC,CAAC;AACjD,CAAC,CAAC;AAEN,MAAM,aAAa,GAAG,CAAC,UAA8B,EAAE,OAAqB,EAAE,EAAE,CAC5E,CAAC;IACC,IAAI,EAAE,QAAQ;IACd,SAAS,EAAE,WAAW;IACtB,GAAG,EAAE,OAAO,CAAC,GAAG;IAChB,UAAU;CACX,CAAC,CAAC;AAEP,MAAM,oBAAoB,GACtB,CAAC,OAAgC,EAAE,OAAqB,EAAE,EAAE;IAC1D,uCACK,OAAO,KACV,QAAQ,CAAC,KAA6B;YACpC,MAAM,CAAC,MAAM,CACT,KAAK,CAAC,SAAS,CAAC,OAAO,CAAC,GAA4B,CAAC,EAAE,OAAO,CAAC,CAAC;QACtE,CAAC,IACD;AACJ,CAAC,CAAC;AAEN,MAAM,kBAAkB;AACpB,mDAAmD;AACnD,CAAC,OAAgC,EAAE,KAAU,EAAE,IAAiB,EAAE,EAAE;IAClE,MAAM,CAAC,MAAM,CAAC,KAAK,CAAC,IAAI,CAAC,EAAE,OAAO,CAAC,CAAC;AACtC,CAAC,CAAC;AAEN;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,MAAM,UAAU,YAAY,CAAC,OAAgC;IAC3D,wEAAwE;IACxE,4EAA4E;IAC5E,YAAY;IACZ,2EAA2E;IAC3E,aAAa;IACb,OAAO,CAAC,CAAC,iBAAsC,EAAE,IAAa,EAAE,EAAE,CACtD,CAAC,IAAI,KAAK,SAAS,CAAC,CAAC,CAAC;QACtB,kBAAkB,CAAC,OAAO,EAAE,iBAA2B,EAAE,IAAI,CAAC,CAAC,CAAC;QAChE,oBAAoB,CAChB,OAAO,EAAE,iBAAiC,CAAC,CAE7C,CAAC;AACjB,CAAC;AAED,gCAAgC;AAChC,kCAAkC;AAClC,MAAM,YAAY,GAAG,OAAO,CAAC,SAAgB,CAAC;AAC9C,MAAM,aAAa,GACf,YAAY,CAAC,iBAAiB,IAAI,YAAY,CAAC,qBAAqB,CAAC;AAEzE;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,MAAM,UAAU,kBAAkB,CAC9B,QAAQ,GAAG,EAAE,EAAE,OAAO,GAAG,KAAK,EAAE,QAAQ,GAAG,EAAE;IAC/C,OAAO,CAAC,iBAAsC;IACtC,4CAA4C;IAC5C,IAAkB,EAAO,EAAE;QACjC,MAAM,UAAU,GAAG;YACjB,GAAG;gBACD,MAAM,YAAY,GACd,OAAO,QAAQ,CAAC,CAAC,CAAC,SAAS,QAAQ,GAAG,CAAC,CAAC,CAAC,cAAc,EAAE,CAAC;gBAC9D,MAAM,IAAI,GAAG,IAAI,CAAC,UAAU,CAAC,aAAa,CAAC,YAAY,CAAC,CAAC;gBACzD,IAAI,KAAK,GAAG,IAAI,IAAK,IAAwB,CAAC,aAAa,CAAC,EAAC,OAAO,EAAC,CAAC,CAAC;gBACvE,IAAI,KAAK,IAAI,QAAQ,EAAE;oBACrB,KAAK,GAAG,KAAK,CAAC,MAAM,CAChB,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC,QAAQ,KAAK,IAAI,CAAC,YAAY;wBACpC,IAAgB,CAAC,OAAO,CAAC,CAAC;wBAC9B,IAAgB,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC,CAAC;wBACrC,aAAa,CAAC,IAAI,CAAC,IAAe,EAAE,QAAQ,CAAC,CAAC,CAAC;iBACxD;gBACD,OAAO,KAAK,CAAC;YACf,CAAC;YACD,UAAU,EAAE,IAAI;YAChB,YAAY,EAAE,IAAI;SACnB,CAAC;QACF,OAAO,CAAC,IAAI,KAAK,SAAS,CAAC,CAAC,CAAC;YACzB,WAAW,CAAC,UAAU,EAAE,iBAA2B,EAAE,IAAI,CAAC,CAAC,CAAC;YAC5D,aAAa,CAAC,UAAU,EAAE,iBAAiC,CAAC,CAAC;IACnE,CAAC,CAAC;AACJ,CAAC","sourcesContent":["/**\n * @license\n * Copyright (c) 2017 The Polymer Project Authors. All rights reserved.\n * This code may only be used under the BSD style license found at\n * http://polymer.github.io/LICENSE.txt\n * The complete set of authors may be found at\n * http://polymer.github.io/AUTHORS.txt\n * The complete set of contributors may be found at\n * http://polymer.github.io/CONTRIBUTORS.txt\n * Code distributed by Google as part of the polymer project is also\n * subject to an additional IP rights grant found at\n * http://polymer.github.io/PATENTS.txt\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 {LitElement} from '../lit-element.js';\n\nimport {PropertyDeclaration, UpdatingElement} from './updating-element.js';\n\nexport type Constructor<T> = {\n  // tslint:disable-next-line:no-any\n  new (...args: any[]): T\n};\n\n// From the TC39 Decorators proposal\ninterface ClassDescriptor {\n  kind: 'class';\n  elements: ClassElement[];\n  finisher?: <T>(clazz: Constructor<T>) => undefined | Constructor<T>;\n}\n\n// From the TC39 Decorators proposal\ninterface 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>) => undefined | Constructor<T>;\n  descriptor?: PropertyDescriptor;\n}\n\nconst legacyCustomElement =\n    (tagName: string, clazz: Constructor<HTMLElement>) => {\n      window.customElements.define(tagName, clazz);\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      // tslint:disable-next-line:no-any\n      return clazz as any;\n    };\n\nconst standardCustomElement =\n    (tagName: string, descriptor: ClassDescriptor) => {\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          window.customElements.define(tagName, clazz);\n        }\n      };\n    };\n\n/**\n * Class decorator factory that defines the decorated class as a custom element.\n *\n * ```\n * @customElement('my-element')\n * class MyElement {\n *   render() {\n *     return html``;\n *   }\n * }\n * ```\n * @category Decorator\n * @param tagName The name of the custom element to define.\n */\nexport const customElement = (tagName: string) =>\n    (classOrDescriptor: Constructor<HTMLElement>|ClassDescriptor) =>\n        (typeof classOrDescriptor === 'function') ?\n    legacyCustomElement(tagName, classOrDescriptor) :\n    standardCustomElement(tagName, classOrDescriptor);\n\nconst standardProperty =\n    (options: PropertyDeclaration, element: ClassElement) => {\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 (element.kind === 'method' && element.descriptor &&\n          !('value' in element.descriptor)) {\n        return {\n          ...element,\n          finisher(clazz: typeof UpdatingElement) {\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          // 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 UpdatingElement) {\n            clazz.createProperty(element.key, options);\n          }\n        };\n      }\n    };\n\nconst legacyProperty =\n    (options: PropertyDeclaration, proto: Object, name: PropertyKey) => {\n      (proto.constructor as typeof UpdatingElement)\n          .createProperty(name, options);\n    };\n\n/**\n * A property decorator which creates a LitElement property which reflects a\n * corresponding attribute value. A [[`PropertyDeclaration`]] may optionally be\n * supplied to configure property features.\n *\n * This decorator should only be used for public fields. Private or protected\n * fields should use the [[`internalProperty`]] decorator.\n *\n * @example\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  // tslint:disable-next-line:no-any decorator\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\nexport interface InternalPropertyDeclaration<Type = unknown> {\n  /**\n   * A function that indicates if a property should be considered changed when\n   * it is set. The function should take the `newValue` and `oldValue` and\n   * return `true` if an update should be requested.\n   */\n  hasChanged?(value: Type, oldValue: Type): boolean;\n}\n\n/**\n * Declares a private or protected property that still triggers updates to the\n * element when it changes.\n *\n * Properties declared this way must not be used from HTML or HTML templating\n * systems, they're solely for properties internal to the element. These\n * properties may be renamed by optimization tools like closure compiler.\n * @category Decorator\n */\nexport function internalProperty(options?: InternalPropertyDeclaration) {\n  return property({attribute: false, hasChanged: options?.hasChanged});\n}\n\n/**\n * A property decorator that converts a class property into a getter that\n * executes a querySelector on the element's renderRoot.\n *\n * @param selector A DOMString containing one or more selectors to match.\n * @param cache An optional boolean which when true performs the DOM query only\n * once and caches the result.\n *\n * See: https://developer.mozilla.org/en-US/docs/Web/API/Document/querySelector\n *\n * @example\n *\n * ```ts\n * class MyElement {\n *   @query('#first')\n *   first;\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 query(selector: string, cache?: boolean) {\n  return (protoOrDescriptor: Object|ClassElement,\n          // tslint:disable-next-line:no-any decorator\n          name?: PropertyKey): any => {\n    const descriptor = {\n      get(this: LitElement) {\n        return this.renderRoot.querySelector(selector);\n      },\n      enumerable: true,\n      configurable: true,\n    };\n    if (cache) {\n      const key = typeof name === 'symbol' ? Symbol() : `__${name}`;\n      descriptor.get = function(this: LitElement) {\n        if ((this as unknown as\n             {[key: string]: Element | null})[key as string] === undefined) {\n          ((this as unknown as {[key: string]: Element | null})[key as string] =\n               this.renderRoot.querySelector(selector));\n        }\n        return (\n            this as unknown as {[key: string]: Element | null})[key as string];\n      };\n    }\n    return (name !== undefined) ?\n        legacyQuery(descriptor, protoOrDescriptor as Object, name) :\n        standardQuery(descriptor, protoOrDescriptor as ClassElement);\n  };\n}\n\n// Note, in the future, we may extend this decorator to support the use case\n// where the queried element may need to do work to become ready to interact\n// with (e.g. load some implementation code). If so, we might elect to\n// add a second argument defining a function that can be run to make the\n// queried element loaded/updated/ready.\n/**\n * A property decorator that converts a class property into a getter that\n * returns a promise that resolves to the result of a querySelector on the\n * element's renderRoot done after the element's `updateComplete` promise\n * resolves. When the queried property may change with element state, this\n * decorator can be used instead of requiring users to await the\n * `updateComplete` before accessing the property.\n *\n * @param selector A DOMString containing one or more selectors to match.\n *\n * See: https://developer.mozilla.org/en-US/docs/Web/API/Document/querySelector\n *\n * @example\n * ```ts\n * class MyElement {\n *   @queryAsync('#first')\n *   first;\n *\n *   render() {\n *     return html`\n *       <div id=\"first\"></div>\n *       <div id=\"second\"></div>\n *     `;\n *   }\n * }\n *\n * // external usage\n * async doSomethingWithFirst() {\n *  (await aMyElement.first).doSomething();\n * }\n * ```\n * @category Decorator\n */\nexport function queryAsync(selector: string) {\n  return (protoOrDescriptor: Object|ClassElement,\n          // tslint:disable-next-line:no-any decorator\n          name?: PropertyKey): any => {\n    const descriptor = {\n      async get(this: LitElement) {\n        await this.updateComplete;\n        return this.renderRoot.querySelector(selector);\n      },\n      enumerable: true,\n      configurable: true,\n    };\n    return (name !== undefined) ?\n        legacyQuery(descriptor, protoOrDescriptor as Object, name) :\n        standardQuery(descriptor, protoOrDescriptor as ClassElement);\n  };\n}\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 * @example\n * ```ts\n * class MyElement {\n *   @queryAll('div')\n *   divs;\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 (protoOrDescriptor: Object|ClassElement,\n          // tslint:disable-next-line:no-any decorator\n          name?: PropertyKey): any => {\n    const descriptor = {\n      get(this: LitElement) {\n        return this.renderRoot.querySelectorAll(selector);\n      },\n      enumerable: true,\n      configurable: true,\n    };\n    return (name !== undefined) ?\n        legacyQuery(descriptor, protoOrDescriptor as Object, name) :\n        standardQuery(descriptor, protoOrDescriptor as ClassElement);\n  };\n}\n\nconst legacyQuery =\n    (descriptor: PropertyDescriptor, proto: Object, name: PropertyKey) => {\n      Object.defineProperty(proto, name, descriptor);\n    };\n\nconst standardQuery = (descriptor: PropertyDescriptor, element: ClassElement) =>\n    ({\n      kind: 'method',\n      placement: 'prototype',\n      key: element.key,\n      descriptor,\n    });\n\nconst standardEventOptions =\n    (options: AddEventListenerOptions, element: ClassElement) => {\n      return {\n        ...element,\n        finisher(clazz: typeof UpdatingElement) {\n          Object.assign(\n              clazz.prototype[element.key as keyof UpdatingElement], options);\n        }\n      };\n    };\n\nconst legacyEventOptions =\n    // tslint:disable-next-line:no-any legacy decorator\n    (options: AddEventListenerOptions, proto: any, name: PropertyKey) => {\n      Object.assign(proto[name], options);\n    };\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 * @example\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 value typed as any to prevent TypeScript from complaining that\n  // standard decorator function signature does not match TypeScript decorator\n  // signature\n  // TODO(kschaaf): unclear why it was only failing on this decorator and not\n  // the others\n  return ((protoOrDescriptor: Object|ClassElement, name?: string) =>\n              (name !== undefined) ?\n              legacyEventOptions(options, protoOrDescriptor as Object, name) :\n              standardEventOptions(\n                  options, protoOrDescriptor as ClassElement)) as\n             // tslint:disable-next-line:no-any decorator\n             any;\n}\n\n// x-browser support for matches\n// tslint:disable-next-line:no-any\nconst ElementProto = Element.prototype as any;\nconst legacyMatches =\n    ElementProto.msMatchesSelector || ElementProto.webkitMatchesSelector;\n\n/**\n * A property decorator that converts a class property into a getter that\n * returns the `assignedNodes` of the given named `slot`. Note, the type of\n * this property should be annotated as `NodeListOf<HTMLElement>`.\n *\n * @param slotName A string name of the slot.\n * @param flatten A boolean which when true flattens the assigned nodes,\n * meaning any assigned nodes that are slot elements are replaced with their\n * assigned nodes.\n * @param selector A string which filters the results to elements that match\n * the given css selector.\n *\n * * @example\n * ```ts\n * class MyElement {\n *   @queryAssignedNodes('list', true, '.item')\n *   listItems;\n *\n *   render() {\n *     return html`\n *       <slot name=\"list\"></slot>\n *     `;\n *   }\n * }\n * ```\n * @category Decorator\n */\nexport function queryAssignedNodes(\n    slotName = '', flatten = false, selector = '') {\n  return (protoOrDescriptor: Object|ClassElement,\n          // tslint:disable-next-line:no-any decorator\n          name?: PropertyKey): any => {\n    const descriptor = {\n      get(this: LitElement) {\n        const slotSelector =\n            `slot${slotName ? `[name=${slotName}]` : ':not([name])'}`;\n        const slot = this.renderRoot.querySelector(slotSelector);\n        let nodes = slot && (slot as HTMLSlotElement).assignedNodes({flatten});\n        if (nodes && selector) {\n          nodes = nodes.filter(\n              (node) => node.nodeType === Node.ELEMENT_NODE &&\n                      (node as Element).matches ?\n                  (node as Element).matches(selector) :\n                  legacyMatches.call(node as Element, selector));\n        }\n        return nodes;\n      },\n      enumerable: true,\n      configurable: true,\n    };\n    return (name !== undefined) ?\n        legacyQuery(descriptor, protoOrDescriptor as Object, name) :\n        standardQuery(descriptor, protoOrDescriptor as ClassElement);\n  };\n}\n"]}

data/lib/tasks/testrails/node_modules/lit-element/lib/updating-element.d.ts

@@ -0,0 +1,428 @@
+/**
+ * @license
+ * Copyright (c) 2017 The Polymer Project Authors. All rights reserved.
+ * This code may only be used under the BSD style license found at
+ * http://polymer.github.io/LICENSE.txt
+ * The complete set of authors may be found at
+ * http://polymer.github.io/AUTHORS.txt
+ * The complete set of contributors may be found at
+ * http://polymer.github.io/CONTRIBUTORS.txt
+ * Code distributed by Google as part of the polymer project is also
+ * subject to an additional IP rights grant found at
+ * http://polymer.github.io/PATENTS.txt
+ */
+declare global {
+    var JSCompiler_renameProperty: <P extends PropertyKey>(prop: P, _obj: unknown) => P;
+    interface Window {
+        JSCompiler_renameProperty: typeof JSCompiler_renameProperty;
+    }
+}
+/**
+ * Converts property values to and from attribute values.
+ */
+export interface ComplexAttributeConverter<Type = unknown, TypeHint = unknown> {
+    /**
+     * Function called to convert an attribute value to a property
+     * value.
+     */
+    fromAttribute?(value: string | null, type?: TypeHint): Type;
+    /**
+     * Function called to convert a property value to an attribute
+     * value.
+     *
+     * It returns unknown instead of string, to be compatible with
+     * https://github.com/WICG/trusted-types (and similar efforts).
+     */
+    toAttribute?(value: Type, type?: TypeHint): unknown;
+}
+declare type AttributeConverter<Type = unknown, TypeHint = unknown> = ComplexAttributeConverter<Type> | ((value: string | null, type?: TypeHint) => Type);
+/**
+ * Defines options for a property accessor.
+ */
+export interface PropertyDeclaration<Type = unknown, TypeHint = unknown> {
+    /**
+     * Indicates how and whether the property becomes an observed attribute.
+     * If the value is `false`, the property is not added to `observedAttributes`.
+     * If true or absent, the lowercased property name is observed (e.g. `fooBar`
+     * becomes `foobar`). If a string, the string value is observed (e.g
+     * `attribute: 'foo-bar'`).
+     */
+    readonly attribute?: boolean | string;
+    /**
+     * Indicates the type of the property. This is used only as a hint for the
+     * `converter` to determine how to convert the attribute
+     * to/from a property.
+     */
+    readonly type?: TypeHint;
+    /**
+     * Indicates how to convert the attribute to/from a property. If this value
+     * is a function, it is used to convert the attribute value a the property
+     * value. If it's an object, it can have keys for `fromAttribute` and
+     * `toAttribute`. If no `toAttribute` function is provided and
+     * `reflect` is set to `true`, the property value is set directly to the
+     * attribute. A default `converter` is used if none is provided; it supports
+     * `Boolean`, `String`, `Number`, `Object`, and `Array`. Note,
+     * when a property changes and the converter is used to update the attribute,
+     * the property is never updated again as a result of the attribute changing,
+     * and vice versa.
+     */
+    readonly converter?: AttributeConverter<Type, TypeHint>;
+    /**
+     * Indicates if the property should reflect to an attribute.
+     * If `true`, when the property is set, the attribute is set using the
+     * attribute name determined according to the rules for the `attribute`
+     * property option and the value of the property converted using the rules
+     * from the `converter` property option.
+     */
+    readonly reflect?: boolean;
+    /**
+     * A function that indicates if a property should be considered changed when
+     * it is set. The function should take the `newValue` and `oldValue` and
+     * return `true` if an update should be requested.
+     */
+    hasChanged?(value: Type, oldValue: Type): boolean;
+    /**
+     * Indicates whether an accessor will be created for this property. By
+     * default, an accessor will be generated for this property that requests an
+     * update when set. If this flag is `true`, no accessor will be created, and
+     * it will be the user's responsibility to call
+     * `this.requestUpdate(propertyName, oldValue)` to request an update when
+     * the property changes.
+     */
+    readonly noAccessor?: boolean;
+}
+/**
+ * Map of properties to PropertyDeclaration options. For each property an
+ * accessor is made, and the property is processed according to the
+ * PropertyDeclaration options.
+ */
+export interface PropertyDeclarations {
+    readonly [key: string]: PropertyDeclaration;
+}
+/**
+ * Map of changed properties with old values. Takes an optional generic
+ * interface corresponding to the declared element properties.
+ */
+export declare type PropertyValues<T = any> = keyof T extends PropertyKey ? Map<keyof T, unknown> : never;
+export declare const defaultConverter: ComplexAttributeConverter;
+export interface HasChanged {
+    (value: unknown, old: unknown): boolean;
+}
+/**
+ * Change function that returns true if `value` is different from `oldValue`.
+ * This method is used as the default for a property's `hasChanged` function.
+ */
+export declare const notEqual: HasChanged;
+/**
+ * The Closure JS Compiler doesn't currently have good support for static
+ * property semantics where "this" is dynamic (e.g.
+ * https://github.com/google/closure-compiler/issues/3177 and others) so we use
+ * this hack to bypass any rewriting by the compiler.
+ */
+declare const finalized = "finalized";
+/**
+ * Base element class which manages element properties and attributes. When
+ * properties change, the `update` method is asynchronously called. This method
+ * should be supplied by subclassers to render updates as desired.
+ * @noInheritDoc
+ */
+export declare abstract class UpdatingElement extends HTMLElement {
+    /**
+     * Maps attribute names to properties; for example `foobar` attribute to
+     * `fooBar` property. Created lazily on user subclasses when finalizing the
+     * class.
+     */
+    private static _attributeToPropertyMap;
+    /**
+     * Marks class as having finished creating properties.
+     */
+    protected static [finalized]: boolean;
+    /**
+     * Memoized list of all class properties, including any superclass properties.
+     * Created lazily on user subclasses when finalizing the class.
+     */
+    private static _classProperties?;
+    /**
+     * User-supplied object that maps property names to `PropertyDeclaration`
+     * objects containing options for configuring the property.
+     */
+    static properties: PropertyDeclarations;
+    /**
+     * Returns a list of attributes corresponding to the registered properties.
+     * @nocollapse
+     */
+    static get observedAttributes(): string[];
+    /**
+     * Ensures the private `_classProperties` property metadata is created.
+     * In addition to `finalize` this is also called in `createProperty` to
+     * ensure the `@property` decorator can add property metadata.
+     */
+    /** @nocollapse */
+    private static _ensureClassProperties;
+    /**
+     * Creates a property accessor on the element prototype if one does not exist
+     * and stores a PropertyDeclaration for the property with the given options.
+     * The property setter calls the property's `hasChanged` property option
+     * or uses a strict identity check to determine whether or not to request
+     * an update.
+     *
+     * This method may be overridden to customize properties; however,
+     * when doing so, it's important to call `super.createProperty` to ensure
+     * the property is setup correctly. This method calls
+     * `getPropertyDescriptor` internally to get a descriptor to install.
+     * To customize what properties do when they are get or set, override
+     * `getPropertyDescriptor`. To customize the options for a property,
+     * implement `createProperty` like this:
+     *
+     * static createProperty(name, options) {
+     *   options = Object.assign(options, {myOption: true});
+     *   super.createProperty(name, options);
+     * }
+     *
+     * @nocollapse
+     */
+    static createProperty(name: PropertyKey, options?: PropertyDeclaration): void;
+    /**
+     * Returns a property descriptor to be defined on the given named property.
+     * If no descriptor is returned, the property will not become an accessor.
+     * For example,
+     *
+     *   class MyElement extends LitElement {
+     *     static getPropertyDescriptor(name, key, options) {
+     *       const defaultDescriptor =
+     *           super.getPropertyDescriptor(name, key, options);
+     *       const setter = defaultDescriptor.set;
+     *       return {
+     *         get: defaultDescriptor.get,
+     *         set(value) {
+     *           setter.call(this, value);
+     *           // custom action.
+     *         },
+     *         configurable: true,
+     *         enumerable: true
+     *       }
+     *     }
+     *   }
+     *
+     * @nocollapse
+     */
+    protected static getPropertyDescriptor(name: PropertyKey, key: string | symbol, options: PropertyDeclaration): {
+        get(): any;
+        set(this: UpdatingElement, value: unknown): void;
+        configurable: boolean;
+        enumerable: boolean;
+    };
+    /**
+     * Returns the property options associated with the given property.
+     * These options are defined with a PropertyDeclaration via the `properties`
+     * object or the `@property` decorator and are registered in
+     * `createProperty(...)`.
+     *
+     * Note, this method should be considered "final" and not overridden. To
+     * customize the options for a given property, override `createProperty`.
+     *
+     * @nocollapse
+     * @final
+     */
+    protected static getPropertyOptions(name: PropertyKey): PropertyDeclaration<unknown, unknown>;
+    /**
+     * Creates property accessors for registered properties and ensures
+     * any superclasses are also finalized.
+     * @nocollapse
+     */
+    protected static finalize(): void;
+    /**
+     * Returns the property name for the given attribute `name`.
+     * @nocollapse
+     */
+    private static _attributeNameForProperty;
+    /**
+     * Returns true if a property should request an update.
+     * Called when a property value is set and uses the `hasChanged`
+     * option for the property if present or a strict identity check.
+     * @nocollapse
+     */
+    private static _valueHasChanged;
+    /**
+     * Returns the property value for the given attribute value.
+     * Called via the `attributeChangedCallback` and uses the property's
+     * `converter` or `converter.fromAttribute` property option.
+     * @nocollapse
+     */
+    private static _propertyValueFromAttribute;
+    /**
+     * Returns the attribute value for the given property value. If this
+     * returns undefined, the property will *not* be reflected to an attribute.
+     * If this returns null, the attribute will be removed, otherwise the
+     * attribute will be set to the value.
+     * This uses the property's `reflect` and `type.toAttribute` property options.
+     * @nocollapse
+     */
+    private static _propertyValueToAttribute;
+    private _updateState;
+    private _instanceProperties?;
+    private _updatePromise;
+    private _enableUpdatingResolver;
+    /**
+     * Map with keys for any properties that have changed since the last
+     * update cycle with previous values.
+     */
+    private _changedProperties;
+    /**
+     * Map with keys of properties that should be reflected when updated.
+     */
+    private _reflectingProperties?;
+    constructor();
+    /**
+     * Performs element initialization. By default captures any pre-set values for
+     * registered properties.
+     */
+    protected initialize(): void;
+    /**
+     * Fixes any properties set on the instance before upgrade time.
+     * Otherwise these would shadow the accessor and break these properties.
+     * The properties are stored in a Map which is played back after the
+     * constructor runs. Note, on very old versions of Safari (<=9) or Chrome
+     * (<=41), properties created for native platform properties like (`id` or
+     * `name`) may not have default values set in the element constructor. On
+     * these browsers native properties appear on instances and therefore their
+     * default value will overwrite any element default (e.g. if the element sets
+     * this.id = 'id' in the constructor, the 'id' will become '' since this is
+     * the native platform default).
+     */
+    private _saveInstanceProperties;
+    /**
+     * Applies previously saved instance properties.
+     */
+    private _applyInstanceProperties;
+    connectedCallback(): void;
+    protected enableUpdating(): void;
+    /**
+     * Allows for `super.disconnectedCallback()` in extensions while
+     * reserving the possibility of making non-breaking feature additions
+     * when disconnecting at some point in the future.
+     */
+    disconnectedCallback(): void;
+    /**
+     * Synchronizes property values when attributes change.
+     */
+    attributeChangedCallback(name: string, old: string | null, value: string | null): void;
+    private _propertyToAttribute;
+    private _attributeToProperty;
+    /**
+     * This protected version of `requestUpdate` does not access or return the
+     * `updateComplete` promise. This promise can be overridden and is therefore
+     * not free to access.
+     */
+    protected requestUpdateInternal(name?: PropertyKey, oldValue?: unknown, options?: PropertyDeclaration): void;
+    /**
+     * Requests an update which is processed asynchronously. This should
+     * be called when an element should update based on some state not triggered
+     * by setting a property. In this case, pass no arguments. It should also be
+     * called when manually implementing a property setter. In this case, pass the
+     * property `name` and `oldValue` to ensure that any configured property
+     * options are honored. Returns the `updateComplete` Promise which is resolved
+     * when the update completes.
+     *
+     * @param name {PropertyKey} (optional) name of requesting property
+     * @param oldValue {any} (optional) old value of requesting property
+     * @returns {Promise} A Promise that is resolved when the update completes.
+     */
+    requestUpdate(name?: PropertyKey, oldValue?: unknown): Promise<unknown>;
+    /**
+     * Sets up the element to asynchronously update.
+     */
+    private _enqueueUpdate;
+    private get _hasRequestedUpdate();
+    protected get hasUpdated(): number;
+    /**
+     * Performs an element update. Note, if an exception is thrown during the
+     * update, `firstUpdated` and `updated` will not be called.
+     *
+     * You can override this method to change the timing of updates. If this
+     * method is overridden, `super.performUpdate()` must be called.
+     *
+     * For instance, to schedule updates to occur just before the next frame:
+     *
+     * ```
+     * protected async performUpdate(): Promise<unknown> {
+     *   await new Promise((resolve) => requestAnimationFrame(() => resolve()));
+     *   super.performUpdate();
+     * }
+     * ```
+     */
+    protected performUpdate(): void | Promise<unknown>;
+    private _markUpdated;
+    /**
+     * Returns a Promise that resolves when the element has completed updating.
+     * The Promise value is a boolean that is `true` if the element completed the
+     * update without triggering another update. The Promise result is `false` if
+     * a property was set inside `updated()`. If the Promise is rejected, an
+     * exception was thrown during the update.
+     *
+     * To await additional asynchronous work, override the `_getUpdateComplete`
+     * method. For example, it is sometimes useful to await a rendered element
+     * before fulfilling this Promise. To do this, first await
+     * `super._getUpdateComplete()`, then any subsequent state.
+     *
+     * @returns {Promise} The Promise returns a boolean that indicates if the
+     * update resolved without triggering another update.
+     */
+    get updateComplete(): Promise<unknown>;
+    /**
+     * Override point for the `updateComplete` promise.
+     *
+     * It is not safe to override the `updateComplete` getter directly due to a
+     * limitation in TypeScript which means it is not possible to call a
+     * superclass getter (e.g. `super.updateComplete.then(...)`) when the target
+     * language is ES5 (https://github.com/microsoft/TypeScript/issues/338).
+     * This method should be overridden instead. For example:
+     *
+     *   class MyElement extends LitElement {
+     *     async _getUpdateComplete() {
+     *       await super._getUpdateComplete();
+     *       await this._myChild.updateComplete;
+     *     }
+     *   }
+     */
+    protected _getUpdateComplete(): Promise<unknown>;
+    /**
+     * Controls whether or not `update` should be called when the element requests
+     * an update. By default, this method always returns `true`, but this can be
+     * customized to control when to update.
+     *
+     * @param _changedProperties Map of changed properties with old values
+     */
+    protected shouldUpdate(_changedProperties: PropertyValues): boolean;
+    /**
+     * Updates the element. This method reflects property values to attributes.
+     * It can be overridden to render and keep updated element DOM.
+     * Setting properties inside this method will *not* trigger
+     * another update.
+     *
+     * @param _changedProperties Map of changed properties with old values
+     */
+    protected update(_changedProperties: PropertyValues): void;
+    /**
+     * Invoked whenever the element is updated. Implement to perform
+     * post-updating tasks via DOM APIs, for example, focusing an element.
+     *
+     * Setting properties inside this method will trigger the element to update
+     * again after this update cycle completes.
+     *
+     * @param _changedProperties Map of changed properties with old values
+     */
+    protected updated(_changedProperties: PropertyValues): void;
+    /**
+     * Invoked when the element is first updated. Implement to perform one time
+     * work on the element after update.
+     *
+     * Setting properties inside this method will trigger the element to update
+     * again after this update cycle completes.
+     *
+     * @param _changedProperties Map of changed properties with old values
+     */
+    protected firstUpdated(_changedProperties: PropertyValues): void;
+}
+export {};
+//# sourceMappingURL=updating-element.d.ts.map

data/lib/tasks/testrails/node_modules/lit-element/lib/updating-element.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"updating-element.d.ts","sourceRoot":"","sources":["../src/lib/updating-element.ts"],"names":[],"mappings":"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"}

data/lib/tasks/testrails/node_modules/lit-element/lib/updating-element.js

@@ -0,0 +1,673 @@
+/**
+ * @license
+ * Copyright (c) 2017 The Polymer Project Authors. All rights reserved.
+ * This code may only be used under the BSD style license found at
+ * http://polymer.github.io/LICENSE.txt
+ * The complete set of authors may be found at
+ * http://polymer.github.io/AUTHORS.txt
+ * The complete set of contributors may be found at
+ * http://polymer.github.io/CONTRIBUTORS.txt
+ * Code distributed by Google as part of the polymer project is also
+ * subject to an additional IP rights grant found at
+ * http://polymer.github.io/PATENTS.txt
+ */
+var _a;
+/**
+ * Use this module if you want to create your own base class extending
+ * [[UpdatingElement]].
+ * @packageDocumentation
+ */
+/*
+ * When using Closure Compiler, JSCompiler_renameProperty(property, object) is
+ * replaced at compile time by the munged name for object[property]. We cannot
+ * alias this function, so we have to use a small shim that has the same
+ * behavior when not compiling.
+ */
+window.JSCompiler_renameProperty =
+    (prop, _obj) => prop;
+export const defaultConverter = {
+    toAttribute(value, type) {
+        switch (type) {
+            case Boolean:
+                return value ? '' : null;
+            case Object:
+            case Array:
+                // if the value is `null` or `undefined` pass this through
+                // to allow removing/no change behavior.
+                return value == null ? value : JSON.stringify(value);
+        }
+        return value;
+    },
+    fromAttribute(value, type) {
+        switch (type) {
+            case Boolean:
+                return value !== null;
+            case Number:
+                return value === null ? null : Number(value);
+            case Object:
+            case Array:
+                return JSON.parse(value);
+        }
+        return value;
+    }
+};
+/**
+ * Change function that returns true if `value` is different from `oldValue`.
+ * This method is used as the default for a property's `hasChanged` function.
+ */
+export const notEqual = (value, old) => {
+    // This ensures (old==NaN, value==NaN) always returns false
+    return old !== value && (old === old || value === value);
+};
+const defaultPropertyDeclaration = {
+    attribute: true,
+    type: String,
+    converter: defaultConverter,
+    reflect: false,
+    hasChanged: notEqual
+};
+const STATE_HAS_UPDATED = 1;
+const STATE_UPDATE_REQUESTED = 1 << 2;
+const STATE_IS_REFLECTING_TO_ATTRIBUTE = 1 << 3;
+const STATE_IS_REFLECTING_TO_PROPERTY = 1 << 4;
+/**
+ * The Closure JS Compiler doesn't currently have good support for static
+ * property semantics where "this" is dynamic (e.g.
+ * https://github.com/google/closure-compiler/issues/3177 and others) so we use
+ * this hack to bypass any rewriting by the compiler.
+ */
+const finalized = 'finalized';
+/**
+ * Base element class which manages element properties and attributes. When
+ * properties change, the `update` method is asynchronously called. This method
+ * should be supplied by subclassers to render updates as desired.
+ * @noInheritDoc
+ */
+export class UpdatingElement extends HTMLElement {
+    constructor() {
+        super();
+        this.initialize();
+    }
+    /**
+     * Returns a list of attributes corresponding to the registered properties.
+     * @nocollapse
+     */
+    static get observedAttributes() {
+        // note: piggy backing on this to ensure we're finalized.
+        this.finalize();
+        const attributes = [];
+        // Use forEach so this works even if for/of loops are compiled to for loops
+        // expecting arrays
+        this._classProperties.forEach((v, p) => {
+            const attr = this._attributeNameForProperty(p, v);
+            if (attr !== undefined) {
+                this._attributeToPropertyMap.set(attr, p);
+                attributes.push(attr);
+            }
+        });
+        return attributes;
+    }
+    /**
+     * Ensures the private `_classProperties` property metadata is created.
+     * In addition to `finalize` this is also called in `createProperty` to
+     * ensure the `@property` decorator can add property metadata.
+     */
+    /** @nocollapse */
+    static _ensureClassProperties() {
+        // ensure private storage for property declarations.
+        if (!this.hasOwnProperty(JSCompiler_renameProperty('_classProperties', this))) {
+            this._classProperties = new Map();
+            // NOTE: Workaround IE11 not supporting Map constructor argument.
+            const superProperties = Object.getPrototypeOf(this)._classProperties;
+            if (superProperties !== undefined) {
+                superProperties.forEach((v, k) => this._classProperties.set(k, v));
+            }
+        }
+    }
+    /**
+     * Creates a property accessor on the element prototype if one does not exist
+     * and stores a PropertyDeclaration for the property with the given options.
+     * The property setter calls the property's `hasChanged` property option
+     * or uses a strict identity check to determine whether or not to request
+     * an update.
+     *
+     * This method may be overridden to customize properties; however,
+     * when doing so, it's important to call `super.createProperty` to ensure
+     * the property is setup correctly. This method calls
+     * `getPropertyDescriptor` internally to get a descriptor to install.
+     * To customize what properties do when they are get or set, override
+     * `getPropertyDescriptor`. To customize the options for a property,
+     * implement `createProperty` like this:
+     *
+     * static createProperty(name, options) {
+     *   options = Object.assign(options, {myOption: true});
+     *   super.createProperty(name, options);
+     * }
+     *
+     * @nocollapse
+     */
+    static createProperty(name, options = defaultPropertyDeclaration) {
+        // Note, since this can be called by the `@property` decorator which
+        // is called before `finalize`, we ensure storage exists for property
+        // metadata.
+        this._ensureClassProperties();
+        this._classProperties.set(name, options);
+        // Do not generate an accessor if the prototype already has one, since
+        // it would be lost otherwise and that would never be the user's intention;
+        // Instead, we expect users to call `requestUpdate` themselves from
+        // user-defined accessors. Note that if the super has an accessor we will
+        // still overwrite it
+        if (options.noAccessor || this.prototype.hasOwnProperty(name)) {
+            return;
+        }
+        const key = typeof name === 'symbol' ? Symbol() : `__${name}`;
+        const descriptor = this.getPropertyDescriptor(name, key, options);
+        if (descriptor !== undefined) {
+            Object.defineProperty(this.prototype, name, descriptor);
+        }
+    }
+    /**
+     * Returns a property descriptor to be defined on the given named property.
+     * If no descriptor is returned, the property will not become an accessor.
+     * For example,
+     *
+     *   class MyElement extends LitElement {
+     *     static getPropertyDescriptor(name, key, options) {
+     *       const defaultDescriptor =
+     *           super.getPropertyDescriptor(name, key, options);
+     *       const setter = defaultDescriptor.set;
+     *       return {
+     *         get: defaultDescriptor.get,
+     *         set(value) {
+     *           setter.call(this, value);
+     *           // custom action.
+     *         },
+     *         configurable: true,
+     *         enumerable: true
+     *       }
+     *     }
+     *   }
+     *
+     * @nocollapse
+     */
+    static getPropertyDescriptor(name, key, options) {
+        return {
+            // tslint:disable-next-line:no-any no symbol in index
+            get() {
+                return this[key];
+            },
+            set(value) {
+                const oldValue = this[name];
+                this[key] = value;
+                this
+                    .requestUpdateInternal(name, oldValue, options);
+            },
+            configurable: true,
+            enumerable: true
+        };
+    }
+    /**
+     * Returns the property options associated with the given property.
+     * These options are defined with a PropertyDeclaration via the `properties`
+     * object or the `@property` decorator and are registered in
+     * `createProperty(...)`.
+     *
+     * Note, this method should be considered "final" and not overridden. To
+     * customize the options for a given property, override `createProperty`.
+     *
+     * @nocollapse
+     * @final
+     */
+    static getPropertyOptions(name) {
+        return this._classProperties && this._classProperties.get(name) ||
+            defaultPropertyDeclaration;
+    }
+    /**
+     * Creates property accessors for registered properties and ensures
+     * any superclasses are also finalized.
+     * @nocollapse
+     */
+    static finalize() {
+        // finalize any superclasses
+        const superCtor = Object.getPrototypeOf(this);
+        if (!superCtor.hasOwnProperty(finalized)) {
+            superCtor.finalize();
+        }
+        this[finalized] = true;
+        this._ensureClassProperties();
+        // initialize Map populated in observedAttributes
+        this._attributeToPropertyMap = new Map();
+        // make any properties
+        // Note, only process "own" properties since this element will inherit
+        // any properties defined on the superClass, and finalization ensures
+        // the entire prototype chain is finalized.
+        if (this.hasOwnProperty(JSCompiler_renameProperty('properties', this))) {
+            const props = this.properties;
+            // support symbols in properties (IE11 does not support this)
+            const propKeys = [
+                ...Object.getOwnPropertyNames(props),
+                ...(typeof Object.getOwnPropertySymbols === 'function') ?
+                    Object.getOwnPropertySymbols(props) :
+                    []
+            ];
+            // This for/of is ok because propKeys is an array
+            for (const p of propKeys) {
+                // note, use of `any` is due to TypeSript lack of support for symbol in
+                // index types
+                // tslint:disable-next-line:no-any no symbol in index
+                this.createProperty(p, props[p]);
+            }
+        }
+    }
+    /**
+     * Returns the property name for the given attribute `name`.
+     * @nocollapse
+     */
+    static _attributeNameForProperty(name, options) {
+        const attribute = options.attribute;
+        return attribute === false ?
+            undefined :
+            (typeof attribute === 'string' ?
+                attribute :
+                (typeof name === 'string' ? name.toLowerCase() : undefined));
+    }
+    /**
+     * Returns true if a property should request an update.
+     * Called when a property value is set and uses the `hasChanged`
+     * option for the property if present or a strict identity check.
+     * @nocollapse
+     */
+    static _valueHasChanged(value, old, hasChanged = notEqual) {
+        return hasChanged(value, old);
+    }
+    /**
+     * Returns the property value for the given attribute value.
+     * Called via the `attributeChangedCallback` and uses the property's
+     * `converter` or `converter.fromAttribute` property option.
+     * @nocollapse
+     */
+    static _propertyValueFromAttribute(value, options) {
+        const type = options.type;
+        const converter = options.converter || defaultConverter;
+        const fromAttribute = (typeof converter === 'function' ? converter : converter.fromAttribute);
+        return fromAttribute ? fromAttribute(value, type) : value;
+    }
+    /**
+     * Returns the attribute value for the given property value. If this
+     * returns undefined, the property will *not* be reflected to an attribute.
+     * If this returns null, the attribute will be removed, otherwise the
+     * attribute will be set to the value.
+     * This uses the property's `reflect` and `type.toAttribute` property options.
+     * @nocollapse
+     */
+    static _propertyValueToAttribute(value, options) {
+        if (options.reflect === undefined) {
+            return;
+        }
+        const type = options.type;
+        const converter = options.converter;
+        const toAttribute = converter && converter.toAttribute ||
+            defaultConverter.toAttribute;
+        return toAttribute(value, type);
+    }
+    /**
+     * Performs element initialization. By default captures any pre-set values for
+     * registered properties.
+     */
+    initialize() {
+        this._updateState = 0;
+        this._updatePromise =
+            new Promise((res) => this._enableUpdatingResolver = res);
+        this._changedProperties = new Map();
+        this._saveInstanceProperties();
+        // ensures first update will be caught by an early access of
+        // `updateComplete`
+        this.requestUpdateInternal();
+    }
+    /**
+     * Fixes any properties set on the instance before upgrade time.
+     * Otherwise these would shadow the accessor and break these properties.
+     * The properties are stored in a Map which is played back after the
+     * constructor runs. Note, on very old versions of Safari (<=9) or Chrome
+     * (<=41), properties created for native platform properties like (`id` or
+     * `name`) may not have default values set in the element constructor. On
+     * these browsers native properties appear on instances and therefore their
+     * default value will overwrite any element default (e.g. if the element sets
+     * this.id = 'id' in the constructor, the 'id' will become '' since this is
+     * the native platform default).
+     */
+    _saveInstanceProperties() {
+        // Use forEach so this works even if for/of loops are compiled to for loops
+        // expecting arrays
+        this.constructor
+            ._classProperties.forEach((_v, p) => {
+            if (this.hasOwnProperty(p)) {
+                const value = this[p];
+                delete this[p];
+                if (!this._instanceProperties) {
+                    this._instanceProperties = new Map();
+                }
+                this._instanceProperties.set(p, value);
+            }
+        });
+    }
+    /**
+     * Applies previously saved instance properties.
+     */
+    _applyInstanceProperties() {
+        // Use forEach so this works even if for/of loops are compiled to for loops
+        // expecting arrays
+        // tslint:disable-next-line:no-any
+        this._instanceProperties.forEach((v, p) => this[p] = v);
+        this._instanceProperties = undefined;
+    }
+    connectedCallback() {
+        // Ensure first connection completes an update. Updates cannot complete
+        // before connection.
+        this.enableUpdating();
+    }
+    enableUpdating() {
+        if (this._enableUpdatingResolver !== undefined) {
+            this._enableUpdatingResolver();
+            this._enableUpdatingResolver = undefined;
+        }
+    }
+    /**
+     * Allows for `super.disconnectedCallback()` in extensions while
+     * reserving the possibility of making non-breaking feature additions
+     * when disconnecting at some point in the future.
+     */
+    disconnectedCallback() {
+    }
+    /**
+     * Synchronizes property values when attributes change.
+     */
+    attributeChangedCallback(name, old, value) {
+        if (old !== value) {
+            this._attributeToProperty(name, value);
+        }
+    }
+    _propertyToAttribute(name, value, options = defaultPropertyDeclaration) {
+        const ctor = this.constructor;
+        const attr = ctor._attributeNameForProperty(name, options);
+        if (attr !== undefined) {
+            const attrValue = ctor._propertyValueToAttribute(value, options);
+            // an undefined value does not change the attribute.
+            if (attrValue === undefined) {
+                return;
+            }
+            // Track if the property is being reflected to avoid
+            // setting the property again via `attributeChangedCallback`. Note:
+            // 1. this takes advantage of the fact that the callback is synchronous.
+            // 2. will behave incorrectly if multiple attributes are in the reaction
+            // stack at time of calling. However, since we process attributes
+            // in `update` this should not be possible (or an extreme corner case
+            // that we'd like to discover).
+            // mark state reflecting
+            this._updateState = this._updateState | STATE_IS_REFLECTING_TO_ATTRIBUTE;
+            if (attrValue == null) {
+                this.removeAttribute(attr);
+            }
+            else {
+                this.setAttribute(attr, attrValue);
+            }
+            // mark state not reflecting
+            this._updateState = this._updateState & ~STATE_IS_REFLECTING_TO_ATTRIBUTE;
+        }
+    }
+    _attributeToProperty(name, value) {
+        // Use tracking info to avoid deserializing attribute value if it was
+        // just set from a property setter.
+        if (this._updateState & STATE_IS_REFLECTING_TO_ATTRIBUTE) {
+            return;
+        }
+        const ctor = this.constructor;
+        // Note, hint this as an `AttributeMap` so closure clearly understands
+        // the type; it has issues with tracking types through statics
+        // tslint:disable-next-line:no-unnecessary-type-assertion
+        const propName = ctor._attributeToPropertyMap.get(name);
+        if (propName !== undefined) {
+            const options = ctor.getPropertyOptions(propName);
+            // mark state reflecting
+            this._updateState = this._updateState | STATE_IS_REFLECTING_TO_PROPERTY;
+            this[propName] =
+                // tslint:disable-next-line:no-any
+                ctor._propertyValueFromAttribute(value, options);
+            // mark state not reflecting
+            this._updateState = this._updateState & ~STATE_IS_REFLECTING_TO_PROPERTY;
+        }
+    }
+    /**
+     * This protected version of `requestUpdate` does not access or return the
+     * `updateComplete` promise. This promise can be overridden and is therefore
+     * not free to access.
+     */
+    requestUpdateInternal(name, oldValue, options) {
+        let shouldRequestUpdate = true;
+        // If we have a property key, perform property update steps.
+        if (name !== undefined) {
+            const ctor = this.constructor;
+            options = options || ctor.getPropertyOptions(name);
+            if (ctor._valueHasChanged(this[name], oldValue, options.hasChanged)) {
+                if (!this._changedProperties.has(name)) {
+                    this._changedProperties.set(name, oldValue);
+                }
+                // Add to reflecting properties set.
+                // Note, it's important that every change has a chance to add the
+                // property to `_reflectingProperties`. This ensures setting
+                // attribute + property reflects correctly.
+                if (options.reflect === true &&
+                    !(this._updateState & STATE_IS_REFLECTING_TO_PROPERTY)) {
+                    if (this._reflectingProperties === undefined) {
+                        this._reflectingProperties = new Map();
+                    }
+                    this._reflectingProperties.set(name, options);
+                }
+            }
+            else {
+                // Abort the request if the property should not be considered changed.
+                shouldRequestUpdate = false;
+            }
+        }
+        if (!this._hasRequestedUpdate && shouldRequestUpdate) {
+            this._updatePromise = this._enqueueUpdate();
+        }
+    }
+    /**
+     * Requests an update which is processed asynchronously. This should
+     * be called when an element should update based on some state not triggered
+     * by setting a property. In this case, pass no arguments. It should also be
+     * called when manually implementing a property setter. In this case, pass the
+     * property `name` and `oldValue` to ensure that any configured property
+     * options are honored. Returns the `updateComplete` Promise which is resolved
+     * when the update completes.
+     *
+     * @param name {PropertyKey} (optional) name of requesting property
+     * @param oldValue {any} (optional) old value of requesting property
+     * @returns {Promise} A Promise that is resolved when the update completes.
+     */
+    requestUpdate(name, oldValue) {
+        this.requestUpdateInternal(name, oldValue);
+        return this.updateComplete;
+    }
+    /**
+     * Sets up the element to asynchronously update.
+     */
+    async _enqueueUpdate() {
+        this._updateState = this._updateState | STATE_UPDATE_REQUESTED;
+        try {
+            // Ensure any previous update has resolved before updating.
+            // This `await` also ensures that property changes are batched.
+            await this._updatePromise;
+        }
+        catch (e) {
+            // Ignore any previous errors. We only care that the previous cycle is
+            // done. Any error should have been handled in the previous update.
+        }
+        const result = this.performUpdate();
+        // If `performUpdate` returns a Promise, we await it. This is done to
+        // enable coordinating updates with a scheduler. Note, the result is
+        // checked to avoid delaying an additional microtask unless we need to.
+        if (result != null) {
+            await result;
+        }
+        return !this._hasRequestedUpdate;
+    }
+    get _hasRequestedUpdate() {
+        return (this._updateState & STATE_UPDATE_REQUESTED);
+    }
+    get hasUpdated() {
+        return (this._updateState & STATE_HAS_UPDATED);
+    }
+    /**
+     * Performs an element update. Note, if an exception is thrown during the
+     * update, `firstUpdated` and `updated` will not be called.
+     *
+     * You can override this method to change the timing of updates. If this
+     * method is overridden, `super.performUpdate()` must be called.
+     *
+     * For instance, to schedule updates to occur just before the next frame:
+     *
+     * ```
+     * protected async performUpdate(): Promise<unknown> {
+     *   await new Promise((resolve) => requestAnimationFrame(() => resolve()));
+     *   super.performUpdate();
+     * }
+     * ```
+     */
+    performUpdate() {
+        // Abort any update if one is not pending when this is called.
+        // This can happen if `performUpdate` is called early to "flush"
+        // the update.
+        if (!this._hasRequestedUpdate) {
+            return;
+        }
+        // Mixin instance properties once, if they exist.
+        if (this._instanceProperties) {
+            this._applyInstanceProperties();
+        }
+        let shouldUpdate = false;
+        const changedProperties = this._changedProperties;
+        try {
+            shouldUpdate = this.shouldUpdate(changedProperties);
+            if (shouldUpdate) {
+                this.update(changedProperties);
+            }
+            else {
+                this._markUpdated();
+            }
+        }
+        catch (e) {
+            // Prevent `firstUpdated` and `updated` from running when there's an
+            // update exception.
+            shouldUpdate = false;
+            // Ensure element can accept additional updates after an exception.
+            this._markUpdated();
+            throw e;
+        }
+        if (shouldUpdate) {
+            if (!(this._updateState & STATE_HAS_UPDATED)) {
+                this._updateState = this._updateState | STATE_HAS_UPDATED;
+                this.firstUpdated(changedProperties);
+            }
+            this.updated(changedProperties);
+        }
+    }
+    _markUpdated() {
+        this._changedProperties = new Map();
+        this._updateState = this._updateState & ~STATE_UPDATE_REQUESTED;
+    }
+    /**
+     * Returns a Promise that resolves when the element has completed updating.
+     * The Promise value is a boolean that is `true` if the element completed the
+     * update without triggering another update. The Promise result is `false` if
+     * a property was set inside `updated()`. If the Promise is rejected, an
+     * exception was thrown during the update.
+     *
+     * To await additional asynchronous work, override the `_getUpdateComplete`
+     * method. For example, it is sometimes useful to await a rendered element
+     * before fulfilling this Promise. To do this, first await
+     * `super._getUpdateComplete()`, then any subsequent state.
+     *
+     * @returns {Promise} The Promise returns a boolean that indicates if the
+     * update resolved without triggering another update.
+     */
+    get updateComplete() {
+        return this._getUpdateComplete();
+    }
+    /**
+     * Override point for the `updateComplete` promise.
+     *
+     * It is not safe to override the `updateComplete` getter directly due to a
+     * limitation in TypeScript which means it is not possible to call a
+     * superclass getter (e.g. `super.updateComplete.then(...)`) when the target
+     * language is ES5 (https://github.com/microsoft/TypeScript/issues/338).
+     * This method should be overridden instead. For example:
+     *
+     *   class MyElement extends LitElement {
+     *     async _getUpdateComplete() {
+     *       await super._getUpdateComplete();
+     *       await this._myChild.updateComplete;
+     *     }
+     *   }
+     */
+    _getUpdateComplete() {
+        return this._updatePromise;
+    }
+    /**
+     * Controls whether or not `update` should be called when the element requests
+     * an update. By default, this method always returns `true`, but this can be
+     * customized to control when to update.
+     *
+     * @param _changedProperties Map of changed properties with old values
+     */
+    shouldUpdate(_changedProperties) {
+        return true;
+    }
+    /**
+     * Updates the element. This method reflects property values to attributes.
+     * It can be overridden to render and keep updated element DOM.
+     * Setting properties inside this method will *not* trigger
+     * another update.
+     *
+     * @param _changedProperties Map of changed properties with old values
+     */
+    update(_changedProperties) {
+        if (this._reflectingProperties !== undefined &&
+            this._reflectingProperties.size > 0) {
+            // Use forEach so this works even if for/of loops are compiled to for
+            // loops expecting arrays
+            this._reflectingProperties.forEach((v, k) => this._propertyToAttribute(k, this[k], v));
+            this._reflectingProperties = undefined;
+        }
+        this._markUpdated();
+    }
+    /**
+     * Invoked whenever the element is updated. Implement to perform
+     * post-updating tasks via DOM APIs, for example, focusing an element.
+     *
+     * Setting properties inside this method will trigger the element to update
+     * again after this update cycle completes.
+     *
+     * @param _changedProperties Map of changed properties with old values
+     */
+    updated(_changedProperties) {
+    }
+    /**
+     * Invoked when the element is first updated. Implement to perform one time
+     * work on the element after update.
+     *
+     * Setting properties inside this method will trigger the element to update
+     * again after this update cycle completes.
+     *
+     * @param _changedProperties Map of changed properties with old values
+     */
+    firstUpdated(_changedProperties) {
+    }
+}
+_a = finalized;
+/**
+ * Marks class as having finished creating properties.
+ */
+UpdatingElement[_a] = true;
+//# sourceMappingURL=updating-element.js.map