@sbb-esta/lyne-elements 4.7.0 → 4.8.0

package/development/autocomplete/autocomplete.component.d.ts

@@ -11,6 +11,7 @@ import { SbbAutocompleteBaseElement } from './autocomplete-base-element.ts';
  * If the calculated remaining space is smaller, the value gets ignored.
  */
 export declare class SbbAutocompleteElement<T = string> extends SbbAutocompleteBaseElement<T> {
+    static readonly elementName: string;
     static readonly role: string | null;
     protected overlayId: string;
     protected panelRole: string;

package/development/autocomplete/autocomplete.component.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"autocomplete.component.d.ts","sourceRoot":"","sources":["../../../../src/elements/autocomplete/autocomplete.component.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,gBAAgB,EAAwB,MAAM,cAAc,CAAC;AAE3E,OAAO,EAAE,0BAA0B,EAAE,MAAM,gCAAgC,CAAC;AAU5E;;;;;;;;;GASG;AACH,qBAEM,sBAAsB,CAAC,CAAC,GAAG,MAAM,CAAE,SAAQ,0BAA0B,CAAC,CAAC,CAAC;IAC5E,gBAAgC,IAAI,gBAAqC;IACzE,SAAS,CAAC,SAAS,SAAkC;IACrD,SAAS,CAAC,SAAS,SAAa;IAEhC,SAAS,KAAK,OAAO,IAAI,gBAAgB,CAAC,CAAC,CAAC,EAAE,CAE7C;IAED,SAAS,CAAC,YAAY,IAAI,IAAI;IAM9B,SAAS,CAAC,8BAA8B,CAAC,KAAK,EAAE,aAAa,GAAG,IAAI;IAgBpE,SAAS,CAAC,gBAAgB,CAAC,KAAK,EAAE,aAAa,GAAG,IAAI;IAStD,SAAS,CAAC,mBAAmB,CAAC,KAAK,CAAC,EAAE,aAAa,GAAG,IAAI;IAkC1D,SAAS,CAAC,kBAAkB,IAAI,IAAI;IAMpC,SAAS,CAAC,oBAAoB,CAAC,OAAO,EAAE,gBAAgB,GAAG,IAAI;CAGhE;AAED,OAAO,CAAC,MAAM,CAAC;IACb,UAAU,qBAAqB;QAE7B,kBAAkB,EAAE,sBAAsB,CAAC;KAC5C;CACF"}
+{"version":3,"file":"autocomplete.component.d.ts","sourceRoot":"","sources":["../../../../src/elements/autocomplete/autocomplete.component.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,gBAAgB,EAAwB,MAAM,cAAc,CAAC;AAE3E,OAAO,EAAE,0BAA0B,EAAE,MAAM,gCAAgC,CAAC;AAU5E;;;;;;;;;GASG;AACH,qBAAa,sBAAsB,CAAC,CAAC,GAAG,MAAM,CAAE,SAAQ,0BAA0B,CAAC,CAAC,CAAC;IACnF,gBAAgC,WAAW,EAAE,MAAM,CAAsB;IACzE,gBAAgC,IAAI,gBAAqC;IACzE,SAAS,CAAC,SAAS,SAAkC;IACrD,SAAS,CAAC,SAAS,SAAa;IAEhC,SAAS,KAAK,OAAO,IAAI,gBAAgB,CAAC,CAAC,CAAC,EAAE,CAE7C;IAED,SAAS,CAAC,YAAY,IAAI,IAAI;IAM9B,SAAS,CAAC,8BAA8B,CAAC,KAAK,EAAE,aAAa,GAAG,IAAI;IAgBpE,SAAS,CAAC,gBAAgB,CAAC,KAAK,EAAE,aAAa,GAAG,IAAI;IAStD,SAAS,CAAC,mBAAmB,CAAC,KAAK,CAAC,EAAE,aAAa,GAAG,IAAI;IAkC1D,SAAS,CAAC,kBAAkB,IAAI,IAAI;IAMpC,SAAS,CAAC,oBAAoB,CAAC,OAAO,EAAE,gBAAgB,GAAG,IAAI;CAGhE;AAED,OAAO,CAAC,MAAM,CAAC;IACb,UAAU,qBAAqB;QAE7B,kBAAkB,EAAE,sBAAsB,CAAC;KAC5C;CACF"}

package/development/autocomplete/autocomplete.component.js

@@ -1,88 +1,85 @@
-import { __esDecorate, __runInitializers } from "tslib";
-import { customElement } from "lit/decorators.js";
-import { getNextElementIndex } from "../core/a11y.js";
+import { t as SbbAutocompleteBaseElement } from "../autocomplete-base-element-DCfmuVY6.js";
 import { isSafari } from "../core/dom.js";
 import { setAriaComboBoxAttributes } from "../core/overlay.js";
-import { SbbAutocompleteBaseElement } from "./autocomplete-base-element.js";
-let nextId = 0;
-const ariaRoleOnHost = isSafari;
-let SbbAutocompleteElement = (() => {
-  var _a;
-  let _classDecorators = [customElement("sbb-autocomplete")];
-  let _classDescriptor;
-  let _classExtraInitializers = [];
-  let _classThis;
-  let _classSuper = SbbAutocompleteBaseElement;
-  _a = class extends _classSuper {
-    constructor() {
-      super(...arguments);
-      this.overlayId = `sbb-autocomplete-${++nextId}`;
-      this.panelRole = "listbox";
-    }
-    get options() {
-      return Array.from(this.querySelectorAll?.("sbb-option") ?? []);
-    }
-    syncNegative() {
-      this.querySelectorAll?.("sbb-divider, sbb-option-hint").forEach((el) => el.negative = this.negative);
-    }
-    openedPanelKeyboardInteraction(event) {
-      if (!this.isOpen) {
-        return;
-      }
-      switch (event.key) {
-        case "Enter":
-          this.selectByKeyboard(event);
-          break;
-        case "ArrowDown":
-        case "ArrowUp":
-          this.setNextActiveOption(event);
-          break;
-      }
-    }
-    selectByKeyboard(event) {
-      if (this.activeOption) {
-        event.preventDefault();
-        this.activeOption["selectViaUserInteraction"](true);
-      }
-    }
-    setNextActiveOption(event) {
-      const enabledOptions = this.options.filter((opt) => !opt.matches(":is(:state(disabled),[state--disabled])"));
-      this.activeOption?.setActive(false);
-      this.triggerElement?.removeAttribute("aria-activedescendant");
-      if (!enabledOptions.length) {
-        this.activeOption = null;
-        return;
-      }
-      const activeItemIndex = this.activeOption ? enabledOptions.indexOf(this.activeOption) : -1;
-      const next = getNextElementIndex(event, activeItemIndex, enabledOptions.length);
-      this.activeOption = enabledOptions[next];
-      this.activeOption.setActive(true);
-      this.triggerElement?.setAttribute("aria-activedescendant", this.activeOption.id);
-      this.activeOption.scrollIntoView({ block: "nearest" });
-      if (event) {
-        event.preventDefault();
-      }
-      if (this.autoSelectActiveOption && event) {
-        this.setPendingSelection(this.activeOption);
-      }
-    }
-    resetActiveElement() {
-      this.activeOption?.setActive(false);
-      this.triggerElement?.removeAttribute("aria-activedescendant");
-      this.activeOption = null;
-    }
-    setTriggerAttributes(element) {
-      setAriaComboBoxAttributes(element, ariaRoleOnHost ? this.id : this.overlayId, false);
-    }
-  }, _classThis = _a, (() => {
-    const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
-    __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
-    _classThis = _classDescriptor.value;
-    if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
-  })(), _a.role = ariaRoleOnHost ? "listbox" : null, __runInitializers(_classThis, _classExtraInitializers), _a;
-  return _classThis;
-})();
-export {
-  SbbAutocompleteElement
+import { getNextElementIndex } from "../core/a11y.js";
+//#region src/elements/autocomplete/autocomplete.component.ts
+var nextId = 0;
+/**
+* On Safari, the aria role 'listbox' must be on the host element, or else VoiceOver won't work at all.
+* On the other hand, JAWS and NVDA need the role to be "closer" to the options, or else optgroups won't work.
+*/
+var ariaRoleOnHost = isSafari;
+/**
+* Combined with a native input, it displays a panel with a list of available options.
+*
+* @slot - Use the unnamed slot to add `sbb-option` or `sbb-optgroup` elements to the `sbb-autocomplete`.
+* @cssprop [--sbb-autocomplete-z-index=var(--sbb-overlay-default-z-index)] - To specify a custom stack order,
+* the `z-index` can be overridden by defining this CSS variable. The default `z-index` of the
+* component is set to `var(--sbb-overlay-default-z-index)` with a value of `1000`.
+* @cssprop [--sbb-options-panel-max-height] - Maximum height of the options panel.
+* If the calculated remaining space is smaller, the value gets ignored.
+*/
+var SbbAutocompleteElement = class extends SbbAutocompleteBaseElement {
+	constructor() {
+		super(...arguments);
+		this.overlayId = `sbb-autocomplete-${++nextId}`;
+		this.panelRole = "listbox";
+	}
+	static {
+		this.elementName = "sbb-autocomplete";
+	}
+	static {
+		this.role = ariaRoleOnHost ? "listbox" : null;
+	}
+	get options() {
+		return Array.from(this.querySelectorAll?.("sbb-option") ?? []);
+	}
+	syncNegative() {
+		this.querySelectorAll?.("sbb-divider, sbb-option-hint").forEach((el) => el.negative = this.negative);
+	}
+	openedPanelKeyboardInteraction(event) {
+		if (!this.isOpen) return;
+		switch (event.key) {
+			case "Enter":
+				this.selectByKeyboard(event);
+				break;
+			case "ArrowDown":
+			case "ArrowUp":
+				this.setNextActiveOption(event);
+				break;
+		}
+	}
+	selectByKeyboard(event) {
+		if (this.activeOption) {
+			event.preventDefault();
+			this.activeOption["selectViaUserInteraction"](true);
+		}
+	}
+	setNextActiveOption(event) {
+		const enabledOptions = this.options.filter((opt) => !opt.matches(":is(:state(disabled),[state--disabled])"));
+		this.activeOption?.setActive(false);
+		this.triggerElement?.removeAttribute("aria-activedescendant");
+		if (!enabledOptions.length) {
+			this.activeOption = null;
+			return;
+		}
+		this.activeOption = enabledOptions[getNextElementIndex(event, this.activeOption ? enabledOptions.indexOf(this.activeOption) : -1, enabledOptions.length)];
+		this.activeOption.setActive(true);
+		this.triggerElement?.setAttribute("aria-activedescendant", this.activeOption.id);
+		this.activeOption.scrollIntoView({ block: "nearest" });
+		if (event) event.preventDefault();
+		if (this.autoSelectActiveOption && event) this.setPendingSelection(this.activeOption);
+	}
+	resetActiveElement() {
+		this.activeOption?.setActive(false);
+		this.triggerElement?.removeAttribute("aria-activedescendant");
+		this.activeOption = null;
+	}
+	setTriggerAttributes(element) {
+		setAriaComboBoxAttributes(element, ariaRoleOnHost ? this.id : this.overlayId, false);
+	}
 };
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"autocomplete.component.js","sources":["../../../../src/elements/autocomplete/autocomplete.component.ts"],"sourcesContent":["import { customElement } from 'lit/decorators.js';\n\nimport { getNextElementIndex } from '../core/a11y.ts';\nimport { isSafari } from '../core/dom.ts';\nimport { setAriaComboBoxAttributes } from '../core/overlay.ts';\nimport type { SbbDividerElement } from '../divider/divider.component.ts';\nimport type { SbbOptionElement, SbbOptionHintElement } from '../option.ts';\n\nimport { SbbAutocompleteBaseElement } from './autocomplete-base-element.ts';\n\nlet nextId = 0;\n\n/**\n * On Safari, the aria role 'listbox' must be on the host element, or else VoiceOver won't work at all.\n * On the other hand, JAWS and NVDA need the role to be \"closer\" to the options, or else optgroups won't work.\n */\nconst ariaRoleOnHost = isSafari;\n\n/**\n * Combined with a native input, it displays a panel with a list of available options.\n *\n * @slot - Use the unnamed slot to add `sbb-option` or `sbb-optgroup` elements to the `sbb-autocomplete`.\n * @cssprop [--sbb-autocomplete-z-index=var(--sbb-overlay-default-z-index)] - To specify a custom stack order,\n * the `z-index` can be overridden by defining this CSS variable. The default `z-index` of the\n * component is set to `var(--sbb-overlay-default-z-index)` with a value of `1000`.\n * @cssprop [--sbb-options-panel-max-height] - Maximum height of the options panel.\n * If the calculated remaining space is smaller, the value gets ignored.\n */\nexport\n@customElement('sbb-autocomplete')\nclass SbbAutocompleteElement<T = string> extends SbbAutocompleteBaseElement<T> {\n  public static override readonly role = ariaRoleOnHost ? 'listbox' : null;\n  protected overlayId = `sbb-autocomplete-${++nextId}`;\n  protected panelRole = 'listbox';\n\n  protected get options(): SbbOptionElement<T>[] {\n    return Array.from(this.querySelectorAll?.<SbbOptionElement<T>>('sbb-option') ?? []);\n  }\n\n  protected syncNegative(): void {\n    this.querySelectorAll?.<SbbDividerElement | SbbOptionHintElement>(\n      'sbb-divider, sbb-option-hint',\n    ).forEach((el) => (el.negative = this.negative));\n  }\n\n  protected openedPanelKeyboardInteraction(event: KeyboardEvent): void {\n    if (!this.isOpen) {\n      return;\n    }\n    switch (event.key) {\n      case 'Enter':\n        this.selectByKeyboard(event);\n        break;\n\n      case 'ArrowDown':\n      case 'ArrowUp':\n        this.setNextActiveOption(event);\n        break;\n    }\n  }\n\n  protected selectByKeyboard(event: KeyboardEvent): void {\n    if (this.activeOption) {\n      // We are currently selecting an option and therefore the Enter press shouldn't trigger a form submit\n      event.preventDefault();\n\n      this.activeOption['selectViaUserInteraction'](true);\n    }\n  }\n\n  protected setNextActiveOption(event?: KeyboardEvent): void {\n    const enabledOptions = this.options.filter((opt) => !opt.matches(':state(disabled)'));\n\n    // Reset potentially active option\n    this.activeOption?.setActive(false);\n    this.triggerElement?.removeAttribute('aria-activedescendant');\n\n    if (!enabledOptions.length) {\n      this.activeOption = null;\n      return;\n    }\n\n    const activeItemIndex = this.activeOption\n      ? enabledOptions.indexOf(this.activeOption as SbbOptionElement<T>)\n      : -1;\n\n    // Get and activate the next active option\n    const next = getNextElementIndex(event, activeItemIndex, enabledOptions.length);\n    this.activeOption = enabledOptions[next];\n    this.activeOption.setActive(true);\n    this.triggerElement?.setAttribute('aria-activedescendant', this.activeOption.id);\n    this.activeOption.scrollIntoView({ block: 'nearest' });\n\n    // Moving the active option should not move the input cursor (caret)\n    if (event) {\n      event.preventDefault();\n    }\n\n    // If 'autoSelectActiveOption' and is triggered from a keyboard event\n    if (this.autoSelectActiveOption && event) {\n      this.setPendingSelection(this.activeOption);\n    }\n  }\n\n  protected resetActiveElement(): void {\n    this.activeOption?.setActive(false);\n    this.triggerElement?.removeAttribute('aria-activedescendant');\n    this.activeOption = null;\n  }\n\n  protected setTriggerAttributes(element: HTMLInputElement): void {\n    setAriaComboBoxAttributes(element, ariaRoleOnHost ? this.id : this.overlayId, false);\n  }\n}\n\ndeclare global {\n  interface HTMLElementTagNameMap {\n    // eslint-disable-next-line @typescript-eslint/naming-convention\n    'sbb-autocomplete': SbbAutocompleteElement;\n  }\n}\n"],"names":[],"mappings":";;;;;;AAUA,IAAI,SAAS;AAMb,MAAM,iBAAiB;IAcjB,0BAAsB,MAAA;;0BAD3B,cAAc,kBAAkB,CAAC;;;;oBACe;AAAR,EAAA,mBAAQ,YAA6B;AAAA;;AAElE,WAAA,YAAY,oBAAoB,EAAE,MAAM;AACxC,WAAA,YAAY;AAAA,IAgFxB;AAAA,IA9EE,IAAc,UAAO;AACnB,aAAO,MAAM,KAAK,KAAK,mBAAwC,YAAY,KAAK,EAAE;AAAA,IACpF;AAAA,IAEU,eAAY;AACpB,WAAK,mBACH,8BAA8B,EAC9B,QAAQ,CAAC,OAAQ,GAAG,WAAW,KAAK,QAAS;AAAA,IACjD;AAAA,IAEU,+BAA+B,OAAoB;AAC3D,UAAI,CAAC,KAAK,QAAQ;AAChB;AAAA,MACF;AACA,cAAQ,MAAM,KAAA;AAAA,QACZ,KAAK;AACH,eAAK,iBAAiB,KAAK;AAC3B;AAAA,QAEF,KAAK;AAAA,QACL,KAAK;AACH,eAAK,oBAAoB,KAAK;AAC9B;AAAA,MAAA;AAAA,IAEN;AAAA,IAEU,iBAAiB,OAAoB;AAC7C,UAAI,KAAK,cAAc;AAErB,cAAM,eAAA;AAEN,aAAK,aAAa,0BAA0B,EAAE,IAAI;AAAA,MACpD;AAAA,IACF;AAAA,IAEU,oBAAoB,OAAqB;AACjD,YAAM,iBAAiB,KAAK,QAAQ,OAAO,CAAC,QAAQ,CAAC,IAAI,QAAQ,yCAAkB,CAAC;AAGpF,WAAK,cAAc,UAAU,KAAK;AAClC,WAAK,gBAAgB,gBAAgB,uBAAuB;AAE5D,UAAI,CAAC,eAAe,QAAQ;AAC1B,aAAK,eAAe;AACpB;AAAA,MACF;AAEA,YAAM,kBAAkB,KAAK,eACzB,eAAe,QAAQ,KAAK,YAAmC,IAC/D;AAGJ,YAAM,OAAO,oBAAoB,OAAO,iBAAiB,eAAe,MAAM;AAC9E,WAAK,eAAe,eAAe,IAAI;AACvC,WAAK,aAAa,UAAU,IAAI;AAChC,WAAK,gBAAgB,aAAa,yBAAyB,KAAK,aAAa,EAAE;AAC/E,WAAK,aAAa,eAAe,EAAE,OAAO,WAAW;AAGrD,UAAI,OAAO;AACT,cAAM,eAAA;AAAA,MACR;AAGA,UAAI,KAAK,0BAA0B,OAAO;AACxC,aAAK,oBAAoB,KAAK,YAAY;AAAA,MAC5C;AAAA,IACF;AAAA,IAEU,qBAAkB;AAC1B,WAAK,cAAc,UAAU,KAAK;AAClC,WAAK,gBAAgB,gBAAgB,uBAAuB;AAC5D,WAAK,eAAe;AAAA,IACtB;AAAA,IAEU,qBAAqB,SAAyB;AACtD,gCAA0B,SAAS,iBAAiB,KAAK,KAAK,KAAK,WAAW,KAAK;AAAA,IACrF;AAAA;;AAlFF,iBAAA,MAAA,mBAAA,EAAA,OAAA,WAAA,GAAA,kBAAA,EAAA,MAAA,SAAA,MAAA,WAAA,MAAA,UAAA,UAAA,GAAA,MAAA,uBAAA;;;QACkC,GAAA,OAAO,iBAAiB,YAAY,MADhE,kBAAA,YAAA,uBAAA,GAAmC;;;"}
+//#endregion
+export { SbbAutocompleteElement };
+
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXV0b2NvbXBsZXRlLmNvbXBvbmVudC5qcyIsIm5hbWVzIjpbXSwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvZWxlbWVudHMvYXV0b2NvbXBsZXRlL2F1dG9jb21wbGV0ZS5jb21wb25lbnQudHMiXSwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgZ2V0TmV4dEVsZW1lbnRJbmRleCB9IGZyb20gJy4uL2NvcmUvYTExeS50cyc7XG5pbXBvcnQgeyBpc1NhZmFyaSB9IGZyb20gJy4uL2NvcmUvZG9tLnRzJztcbmltcG9ydCB7IHNldEFyaWFDb21ib0JveEF0dHJpYnV0ZXMgfSBmcm9tICcuLi9jb3JlL292ZXJsYXkudHMnO1xuaW1wb3J0IHR5cGUgeyBTYmJEaXZpZGVyRWxlbWVudCB9IGZyb20gJy4uL2RpdmlkZXIvZGl2aWRlci5jb21wb25lbnQudHMnO1xuaW1wb3J0IHR5cGUgeyBTYmJPcHRpb25FbGVtZW50LCBTYmJPcHRpb25IaW50RWxlbWVudCB9IGZyb20gJy4uL29wdGlvbi50cyc7XG5cbmltcG9ydCB7IFNiYkF1dG9jb21wbGV0ZUJhc2VFbGVtZW50IH0gZnJvbSAnLi9hdXRvY29tcGxldGUtYmFzZS1lbGVtZW50LnRzJztcblxubGV0IG5leHRJZCA9IDA7XG5cbi8qKlxuICogT24gU2FmYXJpLCB0aGUgYXJpYSByb2xlICdsaXN0Ym94JyBtdXN0IGJlIG9uIHRoZSBob3N0IGVsZW1lbnQsIG9yIGVsc2UgVm9pY2VPdmVyIHdvbid0IHdvcmsgYXQgYWxsLlxuICogT24gdGhlIG90aGVyIGhhbmQsIEpBV1MgYW5kIE5WREEgbmVlZCB0aGUgcm9sZSB0byBiZSBcImNsb3NlclwiIHRvIHRoZSBvcHRpb25zLCBvciBlbHNlIG9wdGdyb3VwcyB3b24ndCB3b3JrLlxuICovXG5jb25zdCBhcmlhUm9sZU9uSG9zdCA9IGlzU2FmYXJpO1xuXG4vKipcbiAqIENvbWJpbmVkIHdpdGggYSBuYXRpdmUgaW5wdXQsIGl0IGRpc3BsYXlzIGEgcGFuZWwgd2l0aCBhIGxpc3Qgb2YgYXZhaWxhYmxlIG9wdGlvbnMuXG4gKlxuICogQHNsb3QgLSBVc2UgdGhlIHVubmFtZWQgc2xvdCB0byBhZGQgYHNiYi1vcHRpb25gIG9yIGBzYmItb3B0Z3JvdXBgIGVsZW1lbnRzIHRvIHRoZSBgc2JiLWF1dG9jb21wbGV0ZWAuXG4gKiBAY3NzcHJvcCBbLS1zYmItYXV0b2NvbXBsZXRlLXotaW5kZXg9dmFyKC0tc2JiLW92ZXJsYXktZGVmYXVsdC16LWluZGV4KV0gLSBUbyBzcGVjaWZ5IGEgY3VzdG9tIHN0YWNrIG9yZGVyLFxuICogdGhlIGB6LWluZGV4YCBjYW4gYmUgb3ZlcnJpZGRlbiBieSBkZWZpbmluZyB0aGlzIENTUyB2YXJpYWJsZS4gVGhlIGRlZmF1bHQgYHotaW5kZXhgIG9mIHRoZVxuICogY29tcG9uZW50IGlzIHNldCB0byBgdmFyKC0tc2JiLW92ZXJsYXktZGVmYXVsdC16LWluZGV4KWAgd2l0aCBhIHZhbHVlIG9mIGAxMDAwYC5cbiAqIEBjc3Nwcm9wIFstLXNiYi1vcHRpb25zLXBhbmVsLW1heC1oZWlnaHRdIC0gTWF4aW11bSBoZWlnaHQgb2YgdGhlIG9wdGlvbnMgcGFuZWwuXG4gKiBJZiB0aGUgY2FsY3VsYXRlZCByZW1haW5pbmcgc3BhY2UgaXMgc21hbGxlciwgdGhlIHZhbHVlIGdldHMgaWdub3JlZC5cbiAqL1xuZXhwb3J0IGNsYXNzIFNiYkF1dG9jb21wbGV0ZUVsZW1lbnQ8VCA9IHN0cmluZz4gZXh0ZW5kcyBTYmJBdXRvY29tcGxldGVCYXNlRWxlbWVudDxUPiB7XG4gIHB1YmxpYyBzdGF0aWMgb3ZlcnJpZGUgcmVhZG9ubHkgZWxlbWVudE5hbWU6IHN0cmluZyA9ICdzYmItYXV0b2NvbXBsZXRlJztcbiAgcHVibGljIHN0YXRpYyBvdmVycmlkZSByZWFkb25seSByb2xlID0gYXJpYVJvbGVPbkhvc3QgPyAnbGlzdGJveCcgOiBudWxsO1xuICBwcm90ZWN0ZWQgb3ZlcmxheUlkID0gYHNiYi1hdXRvY29tcGxldGUtJHsrK25leHRJZH1gO1xuICBwcm90ZWN0ZWQgcGFuZWxSb2xlID0gJ2xpc3Rib3gnO1xuXG4gIHByb3RlY3RlZCBnZXQgb3B0aW9ucygpOiBTYmJPcHRpb25FbGVtZW50PFQ+W10ge1xuICAgIHJldHVybiBBcnJheS5mcm9tKHRoaXMucXVlcnlTZWxlY3RvckFsbD8uPFNiYk9wdGlvbkVsZW1lbnQ8VD4+KCdzYmItb3B0aW9uJykgPz8gW10pO1xuICB9XG5cbiAgcHJvdGVjdGVkIHN5bmNOZWdhdGl2ZSgpOiB2b2lkIHtcbiAgICB0aGlzLnF1ZXJ5U2VsZWN0b3JBbGw/LjxTYmJEaXZpZGVyRWxlbWVudCB8IFNiYk9wdGlvbkhpbnRFbGVtZW50PihcbiAgICAgICdzYmItZGl2aWRlciwgc2JiLW9wdGlvbi1oaW50JyxcbiAgICApLmZvckVhY2goKGVsKSA9PiAoZWwubmVnYXRpdmUgPSB0aGlzLm5lZ2F0aXZlKSk7XG4gIH1cblxuICBwcm90ZWN0ZWQgb3BlbmVkUGFuZWxLZXlib2FyZEludGVyYWN0aW9uKGV2ZW50OiBLZXlib2FyZEV2ZW50KTogdm9pZCB7XG4gICAgaWYgKCF0aGlzLmlzT3Blbikge1xuICAgICAgcmV0dXJuO1xuICAgIH1cbiAgICBzd2l0Y2ggKGV2ZW50LmtleSkge1xuICAgICAgY2FzZSAnRW50ZXInOlxuICAgICAgICB0aGlzLnNlbGVjdEJ5S2V5Ym9hcmQoZXZlbnQpO1xuICAgICAgICBicmVhaztcblxuICAgICAgY2FzZSAnQXJyb3dEb3duJzpcbiAgICAgIGNhc2UgJ0Fycm93VXAnOlxuICAgICAgICB0aGlzLnNldE5leHRBY3RpdmVPcHRpb24oZXZlbnQpO1xuICAgICAgICBicmVhaztcbiAgICB9XG4gIH1cblxuICBwcm90ZWN0ZWQgc2VsZWN0QnlLZXlib2FyZChldmVudDogS2V5Ym9hcmRFdmVudCk6IHZvaWQge1xuICAgIGlmICh0aGlzLmFjdGl2ZU9wdGlvbikge1xuICAgICAgLy8gV2UgYXJlIGN1cnJlbnRseSBzZWxlY3RpbmcgYW4gb3B0aW9uIGFuZCB0aGVyZWZvcmUgdGhlIEVudGVyIHByZXNzIHNob3VsZG4ndCB0cmlnZ2VyIGEgZm9ybSBzdWJtaXRcbiAgICAgIGV2ZW50LnByZXZlbnREZWZhdWx0KCk7XG5cbiAgICAgIHRoaXMuYWN0aXZlT3B0aW9uWydzZWxlY3RWaWFVc2VySW50ZXJhY3Rpb24nXSh0cnVlKTtcbiAgICB9XG4gIH1cblxuICBwcm90ZWN0ZWQgc2V0TmV4dEFjdGl2ZU9wdGlvbihldmVudD86IEtleWJvYXJkRXZlbnQpOiB2b2lkIHtcbiAgICBjb25zdCBlbmFibGVkT3B0aW9ucyA9IHRoaXMub3B0aW9ucy5maWx0ZXIoKG9wdCkgPT4gIW9wdC5tYXRjaGVzKCc6c3RhdGUoZGlzYWJsZWQpJykpO1xuXG4gICAgLy8gUmVzZXQgcG90ZW50aWFsbHkgYWN0aXZlIG9wdGlvblxuICAgIHRoaXMuYWN0aXZlT3B0aW9uPy5zZXRBY3RpdmUoZmFsc2UpO1xuICAgIHRoaXMudHJpZ2dlckVsZW1lbnQ/LnJlbW92ZUF0dHJpYnV0ZSgnYXJpYS1hY3RpdmVkZXNjZW5kYW50Jyk7XG5cbiAgICBpZiAoIWVuYWJsZWRPcHRpb25zLmxlbmd0aCkge1xuICAgICAgdGhpcy5hY3RpdmVPcHRpb24gPSBudWxsO1xuICAgICAgcmV0dXJuO1xuICAgIH1cblxuICAgIGNvbnN0IGFjdGl2ZUl0ZW1JbmRleCA9IHRoaXMuYWN0aXZlT3B0aW9uXG4gICAgICA/IGVuYWJsZWRPcHRpb25zLmluZGV4T2YodGhpcy5hY3RpdmVPcHRpb24gYXMgU2JiT3B0aW9uRWxlbWVudDxUPilcbiAgICAgIDogLTE7XG5cbiAgICAvLyBHZXQgYW5kIGFjdGl2YXRlIHRoZSBuZXh0IGFjdGl2ZSBvcHRpb25cbiAgICBjb25zdCBuZXh0ID0gZ2V0TmV4dEVsZW1lbnRJbmRleChldmVudCwgYWN0aXZlSXRlbUluZGV4LCBlbmFibGVkT3B0aW9ucy5sZW5ndGgpO1xuICAgIHRoaXMuYWN0aXZlT3B0aW9uID0gZW5hYmxlZE9wdGlvbnNbbmV4dF07XG4gICAgdGhpcy5hY3RpdmVPcHRpb24uc2V0QWN0aXZlKHRydWUpO1xuICAgIHRoaXMudHJpZ2dlckVsZW1lbnQ/LnNldEF0dHJpYnV0ZSgnYXJpYS1hY3RpdmVkZXNjZW5kYW50JywgdGhpcy5hY3RpdmVPcHRpb24uaWQpO1xuICAgIHRoaXMuYWN0aXZlT3B0aW9uLnNjcm9sbEludG9WaWV3KHsgYmxvY2s6ICduZWFyZXN0JyB9KTtcblxuICAgIC8vIE1vdmluZyB0aGUgYWN0aXZlIG9wdGlvbiBzaG91bGQgbm90IG1vdmUgdGhlIGlucHV0IGN1cnNvciAoY2FyZXQpXG4gICAgaWYgKGV2ZW50KSB7XG4gICAgICBldmVudC5wcmV2ZW50RGVmYXVsdCgpO1xuICAgIH1cblxuICAgIC8vIElmICdhdXRvU2VsZWN0QWN0aXZlT3B0aW9uJyBhbmQgaXMgdHJpZ2dlcmVkIGZyb20gYSBrZXlib2FyZCBldmVudFxuICAgIGlmICh0aGlzLmF1dG9TZWxlY3RBY3RpdmVPcHRpb24gJiYgZXZlbnQpIHtcbiAgICAgIHRoaXMuc2V0UGVuZGluZ1NlbGVjdGlvbih0aGlzLmFjdGl2ZU9wdGlvbik7XG4gICAgfVxuICB9XG5cbiAgcHJvdGVjdGVkIHJlc2V0QWN0aXZlRWxlbWVudCgpOiB2b2lkIHtcbiAgICB0aGlzLmFjdGl2ZU9wdGlvbj8uc2V0QWN0aXZlKGZhbHNlKTtcbiAgICB0aGlzLnRyaWdnZXJFbGVtZW50Py5yZW1vdmVBdHRyaWJ1dGUoJ2FyaWEtYWN0aXZlZGVzY2VuZGFudCcpO1xuICAgIHRoaXMuYWN0aXZlT3B0aW9uID0gbnVsbDtcbiAgfVxuXG4gIHByb3RlY3RlZCBzZXRUcmlnZ2VyQXR0cmlidXRlcyhlbGVtZW50OiBIVE1MSW5wdXRFbGVtZW50KTogdm9pZCB7XG4gICAgc2V0QXJpYUNvbWJvQm94QXR0cmlidXRlcyhlbGVtZW50LCBhcmlhUm9sZU9uSG9zdCA/IHRoaXMuaWQgOiB0aGlzLm92ZXJsYXlJZCwgZmFsc2UpO1xuICB9XG59XG5cbmRlY2xhcmUgZ2xvYmFsIHtcbiAgaW50ZXJmYWNlIEhUTUxFbGVtZW50VGFnTmFtZU1hcCB7XG4gICAgLy8gZXNsaW50LWRpc2FibGUtbmV4dC1saW5lIEB0eXBlc2NyaXB0LWVzbGludC9uYW1pbmctY29udmVudGlvblxuICAgICdzYmItYXV0b2NvbXBsZXRlJzogU2JiQXV0b2NvbXBsZXRlRWxlbWVudDtcbiAgfVxufVxuIl0sIm1hcHBpbmdzIjoiOzs7OztBQVFBLElBQUksU0FBUzs7Ozs7QUFNYixJQUFNLGlCQUFpQjs7Ozs7Ozs7Ozs7QUFZdkIsSUFBYSx5QkFBYixjQUF3RCwyQkFBNkI7Q0FBckYsY0FBQTs7QUFHWSxPQUFBLFlBQVksb0JBQW9CLEVBQUU7QUFDbEMsT0FBQSxZQUFZOzs7QUFIVSxPQUFBLGNBQXNCOzs7QUFDdEIsT0FBQSxPQUFPLGlCQUFpQixZQUFZOztDQUlwRSxJQUFjLFVBQU87QUFDbkIsU0FBTyxNQUFNLEtBQUssS0FBSyxtQkFBd0MsYUFBYSxJQUFJLEVBQUUsQ0FBQzs7Q0FHM0UsZUFBWTtBQUNwQixPQUFLLG1CQUNILCtCQUNELENBQUMsU0FBUyxPQUFRLEdBQUcsV0FBVyxLQUFLLFNBQVU7O0NBR3hDLCtCQUErQixPQUFvQjtBQUMzRCxNQUFJLENBQUMsS0FBSyxPQUNSO0FBRUYsVUFBUSxNQUFNLEtBQWQ7R0FDRSxLQUFLO0FBQ0gsU0FBSyxpQkFBaUIsTUFBTTtBQUM1QjtHQUVGLEtBQUs7R0FDTCxLQUFLO0FBQ0gsU0FBSyxvQkFBb0IsTUFBTTtBQUMvQjs7O0NBSUksaUJBQWlCLE9BQW9CO0FBQzdDLE1BQUksS0FBSyxjQUFjO0FBRXJCLFNBQU0sZ0JBQWdCO0FBRXRCLFFBQUssYUFBYSw0QkFBNEIsS0FBSzs7O0NBSTdDLG9CQUFvQixPQUFxQjtFQUNqRCxNQUFNLGlCQUFpQixLQUFLLFFBQVEsUUFBUSxRQUFRLENBQUMsSUFBSSxRQUFRLDBDQUFtQixDQUFDO0FBR3JGLE9BQUssY0FBYyxVQUFVLE1BQU07QUFDbkMsT0FBSyxnQkFBZ0IsZ0JBQWdCLHdCQUF3QjtBQUU3RCxNQUFJLENBQUMsZUFBZSxRQUFRO0FBQzFCLFFBQUssZUFBZTtBQUNwQjs7QUFTRixPQUFLLGVBQWUsZUFEUCxvQkFBb0IsT0FMVCxLQUFLLGVBQ3pCLGVBQWUsUUFBUSxLQUFLLGFBQW9DLEdBQ2hFLElBR3FELGVBQWUsT0FBTztBQUUvRSxPQUFLLGFBQWEsVUFBVSxLQUFLO0FBQ2pDLE9BQUssZ0JBQWdCLGFBQWEseUJBQXlCLEtBQUssYUFBYSxHQUFHO0FBQ2hGLE9BQUssYUFBYSxlQUFlLEVBQUUsT0FBTyxXQUFXLENBQUM7QUFHdEQsTUFBSSxNQUNGLE9BQU0sZ0JBQWdCO0FBSXhCLE1BQUksS0FBSywwQkFBMEIsTUFDakMsTUFBSyxvQkFBb0IsS0FBSyxhQUFhOztDQUlyQyxxQkFBa0I7QUFDMUIsT0FBSyxjQUFjLFVBQVUsTUFBTTtBQUNuQyxPQUFLLGdCQUFnQixnQkFBZ0Isd0JBQXdCO0FBQzdELE9BQUssZUFBZTs7Q0FHWixxQkFBcUIsU0FBeUI7QUFDdEQsNEJBQTBCLFNBQVMsaUJBQWlCLEtBQUssS0FBSyxLQUFLLFdBQVcsTUFBTSJ9