@luftborn/custom-elements 1.1.41 → 1.1.43

package/node_modules/@webcomponents/webcomponentsjs/package.json

@@ -1,8 +1,8 @@
 {
   "_from": "@webcomponents/webcomponentsjs@^2.4.3",
-  "_id": "@webcomponents/webcomponentsjs@2.6.0",
+  "_id": "@webcomponents/webcomponentsjs@2.8.0",
   "_inBundle": false,
-  "_integrity": "sha512-Moog+Smx3ORTbWwuPqoclr+uvfLnciVd6wdCaVscHPrxbmQ/IJKm3wbB7hpzJtXWjAq2l/6QMlO85aZiOdtv5Q==",
+  "_integrity": "sha512-loGD63sacRzOzSJgQnB9ZAhaQGkN7wl2Zuw7tsphI5Isa0irijrRo6EnJii/GgjGefIFO8AIO7UivzRhFaEk9w==",
   "_location": "/@webcomponents/webcomponentsjs",
   "_phantomChildren": {},
   "_requested": {
@@ -19,10 +19,10 @@
   "_requiredBy": [
     "/"
   ],
-  "_resolved": "https://registry.npmjs.org/@webcomponents/webcomponentsjs/-/webcomponentsjs-2.6.0.tgz",
-  "_shasum": "7d1674c40bddf0c6dd974c44ffd34512fe7274ff",
+  "_resolved": "https://registry.npmjs.org/@webcomponents/webcomponentsjs/-/webcomponentsjs-2.8.0.tgz",
+  "_shasum": "ab21f027594fa827c1889e8b646da7be27c7908a",
   "_spec": "@webcomponents/webcomponentsjs@^2.4.3",
-  "_where": "C:\\eSignatur\\JSCustomComponents\\custom-input-elements",
+  "_where": "C:\\eSignatur\\npm repos\\ss\\JSCustomComponents\\custom-input-elements",
   "author": {
     "name": "The Polymer Project Authors",
     "url": "https://polymer.github.io/AUTHORS.txt"
@@ -34,11 +34,11 @@
   "deprecated": false,
   "description": "Web Components Polyfills",
   "devDependencies": {
-    "@webcomponents/custom-elements": "^1.5.0",
-    "@webcomponents/shadycss": "^1.11.0",
-    "@webcomponents/shadydom": "^1.9.0",
-    "@webcomponents/template": "^1.5.0",
-    "@webcomponents/url": "^0.7.8",
+    "@webcomponents/custom-elements": "^1.6.0",
+    "@webcomponents/shadycss": "^1.11.2",
+    "@webcomponents/shadydom": "^1.11.0",
+    "@webcomponents/template": "^1.5.1",
+    "@webcomponents/url": "^0.7.9",
     "babel-preset-minify": "^0.4.3",
     "get-own-property-symbols": "^0.9.2",
     "gulp-concat": "^2.6.1",
@@ -53,7 +53,6 @@
     "webcomponents-bundle.js*",
     "webcomponents-loader.js"
   ],
-  "gitHead": "966c28a79fcd46dedc4367be6b93404565ab9cf6",
   "homepage": "https://github.com/webcomponents/polyfills/tree/master/packages/webcomponentsjs",
   "keywords": [
     "webcomponents",
@@ -79,5 +78,5 @@
     "prepack": "npm run build",
     "regen-package-lock": "rm -rf node_modules package-lock.json; npm install"
   },
-  "version": "2.6.0"
+  "version": "2.8.0"
 }

package/node_modules/@webcomponents/webcomponentsjs/src/entrypoints/webcomponents-pf_dom-index.js

@@ -9,9 +9,11 @@ subject to an additional IP rights grant found at http://polymer.github.io/PATEN
 */
 
 import '../platform/custom-event.js';
+import '../platform/event-listener-options.js';
 import '../platform/baseuri.js';
 import '../platform/get-attribute-names.js';
 import '../platform/matches.js';
 import '../platform/parent-node/index.js';
 import '../platform/child-node/index.js';
 import '../platform/svg-element-class-list.js';
+import '../platform/toggle-attribute.js';

package/node_modules/@webcomponents/webcomponentsjs/src/platform/event-listener-options.js

@@ -0,0 +1,122 @@
+/**
+ * @license
+ * Copyright (c) 2016 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;
+// Older browsers like IE do not support an object as the options parameter
+// to add/removeEventListener.
+// https://connect.microsoft.com/IE/feedback/details/790389/event-defaultprevented-returns-false-after-preventdefault-was-called
+const supportsEventOptions = (() => {
+    let supported = false;
+    let onceSupported = false;
+    const eventOptions = {
+        get capture() {
+            supported = true;
+            return true;
+        },
+        get once() {
+            onceSupported = true;
+            return true;
+        },
+    };
+    let callCount = 0;
+    const listener = () => {
+        callCount++;
+    };
+    const d = document.createElement('div');
+    // NOTE: These will be unpatched at this point.
+    d.addEventListener('click', listener, eventOptions);
+    let fullySupported = supported && onceSupported;
+    // Once + capture broken on Edge >= 17 < 79.
+    if (fullySupported) {
+        d.dispatchEvent(new Event('click'));
+        d.dispatchEvent(new Event('click'));
+        fullySupported = callCount == 1;
+    }
+    d.removeEventListener('click', listener, eventOptions);
+    return fullySupported;
+})();
+const nativeEventTarget = (_a = window.EventTarget) !== null && _a !== void 0 ? _a : window.Node;
+if (!supportsEventOptions &&
+    'addEventListener' in nativeEventTarget.prototype) {
+    const parseEventOptions = (optionsOrCapture) => {
+        let capture, once;
+        if (optionsOrCapture &&
+            (typeof optionsOrCapture === 'object' ||
+                typeof optionsOrCapture === 'function')) {
+            capture = Boolean(optionsOrCapture.capture);
+            once = Boolean(optionsOrCapture.once);
+        }
+        else {
+            capture = Boolean(optionsOrCapture);
+            once = false;
+        }
+        return {
+            capture,
+            once,
+        };
+    };
+    const origAddEventListener = nativeEventTarget.prototype.addEventListener;
+    const origRemoveEventListener = nativeEventTarget.prototype.removeEventListener;
+    const captureListenerMap = new WeakMap();
+    const listenerMap = new WeakMap();
+    const getListenerMap = (target, type, capture) => {
+        const elMap = capture ? captureListenerMap : listenerMap;
+        let typeMap = elMap.get(target);
+        if (typeMap === undefined) {
+            elMap.set(target, (typeMap = new Map()));
+        }
+        let listeners = typeMap.get(type);
+        if (listeners === undefined) {
+            typeMap.set(type, (listeners = new WeakMap()));
+        }
+        return listeners;
+    };
+    nativeEventTarget.prototype.addEventListener = function (type, listener, options) {
+        if (listener == null) {
+            return;
+        }
+        const { capture, once } = parseEventOptions(options);
+        const map = getListenerMap(this, type, capture);
+        if (!map.has(listener)) {
+            const cachedListener = once
+                ? (e) => {
+                    map.delete(listener);
+                    origRemoveEventListener.call(this, type, cachedListener, capture);
+                    if (typeof listener === 'function') {
+                        return listener.call(this, e);
+                    }
+                    if (typeof (listener === null || listener === void 0 ? void 0 : listener.handleEvent) === 'function') {
+                        return listener.handleEvent(e);
+                    }
+                }
+                : null;
+            map.set(listener, cachedListener);
+            // Note, the cached listener is null if no wrapper is used to avoid
+            // a strong ref to it;
+            origAddEventListener.call(this, type, cachedListener !== null && cachedListener !== void 0 ? cachedListener : listener, capture);
+        }
+    };
+    nativeEventTarget.prototype.removeEventListener = function (type, listener, options) {
+        if (listener == null) {
+            return;
+        }
+        const { capture } = parseEventOptions(options);
+        const map = getListenerMap(this, type, capture);
+        const cachedListener = map.get(listener);
+        if (cachedListener !== undefined) {
+            map.delete(listener);
+            // Note, the cached listener is null if no wrapper was used so that a
+            // strong ref to it is not kept.
+            origRemoveEventListener.call(this, type, cachedListener !== null && cachedListener !== void 0 ? cachedListener : listener, capture);
+        }
+    };
+}
+export {};
+//# sourceMappingURL=event-listener-options.js.map

package/node_modules/@webcomponents/webcomponentsjs/src/platform/toggle-attribute.js

@@ -0,0 +1,39 @@
+/**
+@license
+Copyright (c) 2020 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
+*/
+const Element_prototype = Element.prototype;
+const nativeHasAttribute = Element.prototype.hasAttribute;
+const nativeSetAttribute = Element.prototype.setAttribute;
+const nativeRemoveAttribute = Element.prototype.removeAttribute;
+if (!Element_prototype.hasOwnProperty('toggleAttribute')) {
+    Element_prototype.toggleAttribute = function toggleAttribute(name, force) {
+        if (force === undefined) {
+            if (nativeHasAttribute.call(this, name)) {
+                nativeRemoveAttribute.call(this, name);
+                return false;
+            }
+            else {
+                nativeSetAttribute.call(this, name, '');
+                return true;
+            }
+        }
+        if (force) {
+            if (!nativeHasAttribute.call(this, name)) {
+                nativeSetAttribute.call(this, name, '');
+            }
+            return true;
+        }
+        // force is falsey
+        nativeRemoveAttribute.call(this, name);
+        return false;
+    };
+}
+export {};
+//# sourceMappingURL=toggle-attribute.js.map

package/node_modules/@webcomponents/webcomponentsjs/webcomponents-bundle.d.ts

@@ -138,6 +138,7 @@ declare global {
     };
     noPatch: boolean | string;
     patchElementProto: (node: Object) => void;
+    querySelectorImplementation?: 'native' | 'selectorEngine';
     wrap: (node: Node) => Node;
   }