@digipair/skill-web-editor 0.4.2

package/index.esm2.js

@@ -0,0 +1,3237 @@
+function _extends() {
+    _extends = Object.assign || function assign(target) {
+        for(var i = 1; i < arguments.length; i++){
+            var source = arguments[i];
+            for(var key in source)if (Object.prototype.hasOwnProperty.call(source, key)) target[key] = source[key];
+        }
+        return target;
+    };
+    return _extends.apply(this, arguments);
+}
+
+function __decorate(decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for(var i = decorators.length - 1; i >= 0; i--)if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+function __metadata(metadataKey, metadataValue) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(metadataKey, metadataValue);
+}
+typeof SuppressedError === "function" ? SuppressedError : function _SuppressedError(error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+};
+
+/**
+ * @license
+ * Copyright 2019 Google LLC
+ * SPDX-License-Identifier: BSD-3-Clause
+ */ function _class_call_check$3(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+    }
+}
+function _defineProperties$3(target, props) {
+    for(var i = 0; i < props.length; i++){
+        var descriptor = props[i];
+        descriptor.enumerable = descriptor.enumerable || false;
+        descriptor.configurable = true;
+        if ("value" in descriptor) descriptor.writable = true;
+        Object.defineProperty(target, descriptor.key, descriptor);
+    }
+}
+function _create_class$3(Constructor, protoProps, staticProps) {
+    if (protoProps) _defineProperties$3(Constructor.prototype, protoProps);
+    if (staticProps) _defineProperties$3(Constructor, staticProps);
+    return Constructor;
+}
+function _instanceof(left, right) {
+    if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) {
+        return !!right[Symbol.hasInstance](left);
+    } else {
+        return left instanceof right;
+    }
+}
+var t$2 = globalThis, e$2 = t$2.ShadowRoot && (void 0 === t$2.ShadyCSS || t$2.ShadyCSS.nativeShadow) && "adoptedStyleSheets" in Document.prototype && "replace" in CSSStyleSheet.prototype, s$2 = Symbol(), o$3 = new WeakMap;
+var n$3 = /*#__PURE__*/ function() {
+    function n(t, e, o) {
+        _class_call_check$3(this, n);
+        if (this._$cssResult$ = !0, o !== s$2) throw Error("CSSResult is not constructable. Use `unsafeCSS` or `css` instead.");
+        this.cssText = t, this.t = e;
+    }
+    _create_class$3(n, [
+        {
+            key: "styleSheet",
+            get: function get() {
+                var t = this.o;
+                var s = this.t;
+                if (e$2 && void 0 === t) {
+                    var e1 = void 0 !== s && 1 === s.length;
+                    e1 && (t = o$3.get(s)), void 0 === t && ((this.o = t = new CSSStyleSheet).replaceSync(this.cssText), e1 && o$3.set(s, t));
+                }
+                return t;
+            }
+        },
+        {
+            key: "toString",
+            value: function toString() {
+                return this.cssText;
+            }
+        }
+    ]);
+    return n;
+}();
+var r$5 = function(t) {
+    return new n$3("string" == typeof t ? t : t + "", void 0, s$2);
+}, S$1 = function(s, o) {
+    var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+    if (e$2) s.adoptedStyleSheets = o.map(function(t) {
+        return _instanceof(t, CSSStyleSheet) ? t : t.styleSheet;
+    });
+    else try {
+        for(var _iterator = o[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+            var e1 = _step.value;
+            var _$o = document.createElement("style"), n = t$2.litNonce;
+            void 0 !== n && _$o.setAttribute("nonce", n), _$o.textContent = e1.cssText, s.appendChild(_$o);
+        }
+    } catch (err) {
+        _didIteratorError = true;
+        _iteratorError = err;
+    } finally{
+        try {
+            if (!_iteratorNormalCompletion && _iterator.return != null) {
+                _iterator.return();
+            }
+        } finally{
+            if (_didIteratorError) {
+                throw _iteratorError;
+            }
+        }
+    }
+}, c$2 = e$2 ? function(t) {
+    return t;
+} : function(t) {
+    return _instanceof(t, CSSStyleSheet) ? function(t) {
+        var e = "";
+        var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+        try {
+            for(var _iterator = t.cssRules[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                var s = _step.value;
+                e += s.cssText;
+            }
+        } catch (err) {
+            _didIteratorError = true;
+            _iteratorError = err;
+        } finally{
+            try {
+                if (!_iteratorNormalCompletion && _iterator.return != null) {
+                    _iterator.return();
+                }
+            } finally{
+                if (_didIteratorError) {
+                    throw _iteratorError;
+                }
+            }
+        }
+        return r$5(e);
+    }(t) : t;
+};
+
+function _array_like_to_array$1(arr, len) {
+    if (len == null || len > arr.length) len = arr.length;
+    for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
+    return arr2;
+}
+function _array_with_holes$1(arr) {
+    if (Array.isArray(arr)) return arr;
+}
+function _array_without_holes$1(arr) {
+    if (Array.isArray(arr)) return _array_like_to_array$1(arr);
+}
+function _assert_this_initialized$2(self) {
+    if (self === void 0) {
+        throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+    }
+    return self;
+}
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg);
+        var value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    if (info.done) {
+        resolve(value);
+    } else {
+        Promise.resolve(value).then(_next, _throw);
+    }
+}
+function _async_to_generator(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
+function _class_call_check$2(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+    }
+}
+function _construct(Parent, args, Class) {
+    if (_is_native_reflect_construct$2()) {
+        _construct = Reflect.construct;
+    } else {
+        _construct = function construct(Parent, args, Class) {
+            var a = [
+                null
+            ];
+            a.push.apply(a, args);
+            var Constructor = Function.bind.apply(Parent, a);
+            var instance = new Constructor();
+            if (Class) _set_prototype_of$2(instance, Class.prototype);
+            return instance;
+        };
+    }
+    return _construct.apply(null, arguments);
+}
+function _defineProperties$2(target, props) {
+    for(var i = 0; i < props.length; i++){
+        var descriptor = props[i];
+        descriptor.enumerable = descriptor.enumerable || false;
+        descriptor.configurable = true;
+        if ("value" in descriptor) descriptor.writable = true;
+        Object.defineProperty(target, descriptor.key, descriptor);
+    }
+}
+function _create_class$2(Constructor, protoProps, staticProps) {
+    if (protoProps) _defineProperties$2(Constructor.prototype, protoProps);
+    if (staticProps) _defineProperties$2(Constructor, staticProps);
+    return Constructor;
+}
+function _get_prototype_of$2(o) {
+    _get_prototype_of$2 = Object.setPrototypeOf ? Object.getPrototypeOf : function getPrototypeOf(o) {
+        return o.__proto__ || Object.getPrototypeOf(o);
+    };
+    return _get_prototype_of$2(o);
+}
+function _inherits$2(subClass, superClass) {
+    if (typeof superClass !== "function" && superClass !== null) {
+        throw new TypeError("Super expression must either be null or a function");
+    }
+    subClass.prototype = Object.create(superClass && superClass.prototype, {
+        constructor: {
+            value: subClass,
+            writable: true,
+            configurable: true
+        }
+    });
+    if (superClass) _set_prototype_of$2(subClass, superClass);
+}
+function _is_native_function(fn) {
+    return Function.toString.call(fn).indexOf("[native code]") !== -1;
+}
+function _iterable_to_array$1(iter) {
+    if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
+}
+function _iterable_to_array_limit$1(arr, i) {
+    var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"];
+    if (_i == null) return;
+    var _arr = [];
+    var _n = true;
+    var _d = false;
+    var _s, _e;
+    try {
+        for(_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true){
+            _arr.push(_s.value);
+            if (i && _arr.length === i) break;
+        }
+    } catch (err) {
+        _d = true;
+        _e = err;
+    } finally{
+        try {
+            if (!_n && _i["return"] != null) _i["return"]();
+        } finally{
+            if (_d) throw _e;
+        }
+    }
+    return _arr;
+}
+function _non_iterable_rest$1() {
+    throw new TypeError("Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _non_iterable_spread$1() {
+    throw new TypeError("Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _possible_constructor_return$2(self, call) {
+    if (call && (_type_of$2(call) === "object" || typeof call === "function")) {
+        return call;
+    }
+    return _assert_this_initialized$2(self);
+}
+function _set_prototype_of$2(o, p) {
+    _set_prototype_of$2 = Object.setPrototypeOf || function setPrototypeOf(o, p) {
+        o.__proto__ = p;
+        return o;
+    };
+    return _set_prototype_of$2(o, p);
+}
+function _sliced_to_array$1(arr, i) {
+    return _array_with_holes$1(arr) || _iterable_to_array_limit$1(arr, i) || _unsupported_iterable_to_array$1(arr, i) || _non_iterable_rest$1();
+}
+function _to_consumable_array$1(arr) {
+    return _array_without_holes$1(arr) || _iterable_to_array$1(arr) || _unsupported_iterable_to_array$1(arr) || _non_iterable_spread$1();
+}
+function _type_of$2(obj) {
+    "@swc/helpers - typeof";
+    return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
+}
+function _unsupported_iterable_to_array$1(o, minLen) {
+    if (!o) return;
+    if (typeof o === "string") return _array_like_to_array$1(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor) n = o.constructor.name;
+    if (n === "Map" || n === "Set") return Array.from(n);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array$1(o, minLen);
+}
+function _wrap_native_super(Class) {
+    var _cache = typeof Map === "function" ? new Map() : undefined;
+    _wrap_native_super = function wrapNativeSuper(Class) {
+        if (Class === null || !_is_native_function(Class)) return Class;
+        if (typeof Class !== "function") {
+            throw new TypeError("Super expression must either be null or a function");
+        }
+        if (typeof _cache !== "undefined") {
+            if (_cache.has(Class)) return _cache.get(Class);
+            _cache.set(Class, Wrapper);
+        }
+        function Wrapper() {
+            return _construct(Class, arguments, _get_prototype_of$2(this).constructor);
+        }
+        Wrapper.prototype = Object.create(Class.prototype, {
+            constructor: {
+                value: Wrapper,
+                enumerable: false,
+                writable: true,
+                configurable: true
+            }
+        });
+        return _set_prototype_of$2(Wrapper, Class);
+    };
+    return _wrap_native_super(Class);
+}
+function _is_native_reflect_construct$2() {
+    if (typeof Reflect === "undefined" || !Reflect.construct) return false;
+    if (Reflect.construct.sham) return false;
+    if (typeof Proxy === "function") return true;
+    try {
+        Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {}));
+        return true;
+    } catch (e) {
+        return false;
+    }
+}
+function _create_super$2(Derived) {
+    var hasNativeReflectConstruct = _is_native_reflect_construct$2();
+    return function _createSuperInternal() {
+        var Super = _get_prototype_of$2(Derived), result;
+        if (hasNativeReflectConstruct) {
+            var NewTarget = _get_prototype_of$2(this).constructor;
+            result = Reflect.construct(Super, arguments, NewTarget);
+        } else {
+            result = Super.apply(this, arguments);
+        }
+        return _possible_constructor_return$2(this, result);
+    };
+}
+function _ts_generator(thisArg, body) {
+    var f, y, t, g, _ = {
+        label: 0,
+        sent: function() {
+            if (t[0] & 1) throw t[1];
+            return t[1];
+        },
+        trys: [],
+        ops: []
+    };
+    return g = {
+        next: verb(0),
+        "throw": verb(1),
+        "return": verb(2)
+    }, typeof Symbol === "function" && (g[Symbol.iterator] = function() {
+        return this;
+    }), g;
+    function verb(n) {
+        return function(v) {
+            return step([
+                n,
+                v
+            ]);
+        };
+    }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while(_)try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [
+                op[0] & 2,
+                t.value
+            ];
+            switch(op[0]){
+                case 0:
+                case 1:
+                    t = op;
+                    break;
+                case 4:
+                    _.label++;
+                    return {
+                        value: op[1],
+                        done: false
+                    };
+                case 5:
+                    _.label++;
+                    y = op[1];
+                    op = [
+                        0
+                    ];
+                    continue;
+                case 7:
+                    op = _.ops.pop();
+                    _.trys.pop();
+                    continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+                        _ = 0;
+                        continue;
+                    }
+                    if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
+                        _.label = op[1];
+                        break;
+                    }
+                    if (op[0] === 6 && _.label < t[1]) {
+                        _.label = t[1];
+                        t = op;
+                        break;
+                    }
+                    if (t && _.label < t[2]) {
+                        _.label = t[2];
+                        _.ops.push(op);
+                        break;
+                    }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop();
+                    continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) {
+            op = [
+                6,
+                e
+            ];
+            y = 0;
+        } finally{
+            f = t = 0;
+        }
+        if (op[0] & 5) throw op[1];
+        return {
+            value: op[0] ? op[1] : void 0,
+            done: true
+        };
+    }
+}
+var _Symbol, _a, _a1;
+/**
+ * @license
+ * Copyright 2017 Google LLC
+ * SPDX-License-Identifier: BSD-3-Clause
+ */ var i$1 = Object.is, e$1 = Object.defineProperty, r$4 = Object.getOwnPropertyDescriptor, h$1 = Object.getOwnPropertyNames, o$2 = Object.getOwnPropertySymbols, n$2 = Object.getPrototypeOf, a$1 = globalThis, c$1 = a$1.trustedTypes, l$1 = c$1 ? c$1.emptyScript : "", p$1 = a$1.reactiveElementPolyfillSupport, d$1 = function(t, s) {
+    return t;
+}, u$1 = {
+    toAttribute: function toAttribute(t, s) {
+        switch(s){
+            case Boolean:
+                t = t ? l$1 : null;
+                break;
+            case Object:
+            case Array:
+                t = null == t ? t : JSON.stringify(t);
+        }
+        return t;
+    },
+    fromAttribute: function fromAttribute(t, s) {
+        var i = t;
+        switch(s){
+            case Boolean:
+                i = null !== t;
+                break;
+            case Number:
+                i = null === t ? null : Number(t);
+                break;
+            case Object:
+            case Array:
+                try {
+                    i = JSON.parse(t);
+                } catch (t) {
+                    i = null;
+                }
+        }
+        return i;
+    }
+}, f$1 = function(t, s) {
+    return !i$1(t, s);
+}, y$1 = {
+    attribute: !0,
+    type: String,
+    converter: u$1,
+    reflect: !1,
+    hasChanged: f$1
+};
+var _metadata, _litPropertyMetadata;
+(_metadata = (_Symbol = Symbol).metadata) !== null && _metadata !== void 0 ? _metadata : _Symbol.metadata = Symbol("metadata"), (_litPropertyMetadata = (_a = a$1).litPropertyMetadata) !== null && _litPropertyMetadata !== void 0 ? _litPropertyMetadata : _a.litPropertyMetadata = new WeakMap;
+var b = /*#__PURE__*/ function(HTMLElement1) {
+    _inherits$2(b, HTMLElement1);
+    var _super = _create_super$2(b);
+    function b() {
+        _class_call_check$2(this, b);
+        var _this;
+        _this = _super.call(this), _this._$Ep = void 0, _this.isUpdatePending = !1, _this.hasUpdated = !1, _this._$Em = null, _this._$Ev();
+        return _possible_constructor_return$2(_this);
+    }
+    _create_class$2(b, [
+        {
+            key: "_$Ev",
+            value: function _$Ev() {
+                var _this = this;
+                var _this_constructor_l;
+                this._$ES = new Promise(function(t) {
+                    return _this.enableUpdating = t;
+                }), this._$AL = new Map, this._$E_(), this.requestUpdate(), (_this_constructor_l = this.constructor.l) === null || _this_constructor_l === void 0 ? void 0 : _this_constructor_l.forEach(function(t) {
+                    return t(_this);
+                });
+            }
+        },
+        {
+            key: "addController",
+            value: function addController(t) {
+                var _t_hostConnected;
+                var _this__$EO;
+                ((_this__$EO = this._$EO) !== null && _this__$EO !== void 0 ? _this__$EO : this._$EO = new Set).add(t), void 0 !== this.renderRoot && this.isConnected && ((_t_hostConnected = t.hostConnected) === null || _t_hostConnected === void 0 ? void 0 : _t_hostConnected.call(t));
+            }
+        },
+        {
+            key: "removeController",
+            value: function removeController(t) {
+                var _this__$EO;
+                (_this__$EO = this._$EO) === null || _this__$EO === void 0 ? void 0 : _this__$EO.delete(t);
+            }
+        },
+        {
+            key: "_$E_",
+            value: function _$E_() {
+                var t = new Map, s = this.constructor.elementProperties;
+                var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+                try {
+                    for(var _iterator = s.keys()[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                        var i = _step.value;
+                        this.hasOwnProperty(i) && (t.set(i, this[i]), delete this[i]);
+                    }
+                } catch (err) {
+                    _didIteratorError = true;
+                    _iteratorError = err;
+                } finally{
+                    try {
+                        if (!_iteratorNormalCompletion && _iterator.return != null) {
+                            _iterator.return();
+                        }
+                    } finally{
+                        if (_didIteratorError) {
+                            throw _iteratorError;
+                        }
+                    }
+                }
+                t.size > 0 && (this._$Ep = t);
+            }
+        },
+        {
+            key: "createRenderRoot",
+            value: function createRenderRoot() {
+                var _this_shadowRoot;
+                var t = (_this_shadowRoot = this.shadowRoot) !== null && _this_shadowRoot !== void 0 ? _this_shadowRoot : this.attachShadow(this.constructor.shadowRootOptions);
+                return S$1(t, this.constructor.elementStyles), t;
+            }
+        },
+        {
+            key: "connectedCallback",
+            value: function connectedCallback() {
+                var _this__$EO;
+                var _this_renderRoot;
+                (_this_renderRoot = this.renderRoot) !== null && _this_renderRoot !== void 0 ? _this_renderRoot : this.renderRoot = this.createRenderRoot(), this.enableUpdating(!0), (_this__$EO = this._$EO) === null || _this__$EO === void 0 ? void 0 : _this__$EO.forEach(function(t) {
+                    var _t_hostConnected;
+                    return (_t_hostConnected = t.hostConnected) === null || _t_hostConnected === void 0 ? void 0 : _t_hostConnected.call(t);
+                });
+            }
+        },
+        {
+            key: "enableUpdating",
+            value: function enableUpdating(t) {}
+        },
+        {
+            key: "disconnectedCallback",
+            value: function disconnectedCallback() {
+                var _this__$EO;
+                (_this__$EO = this._$EO) === null || _this__$EO === void 0 ? void 0 : _this__$EO.forEach(function(t) {
+                    var _t_hostDisconnected;
+                    return (_t_hostDisconnected = t.hostDisconnected) === null || _t_hostDisconnected === void 0 ? void 0 : _t_hostDisconnected.call(t);
+                });
+            }
+        },
+        {
+            key: "attributeChangedCallback",
+            value: function attributeChangedCallback(t, s, i) {
+                this._$AK(t, i);
+            }
+        },
+        {
+            key: "_$EC",
+            value: function _$EC(t, s) {
+                var i = this.constructor.elementProperties.get(t), e = this.constructor._$Eu(t, i);
+                if (void 0 !== e && !0 === i.reflect) {
+                    var _i_converter;
+                    var r = (void 0 !== ((_i_converter = i.converter) === null || _i_converter === void 0 ? void 0 : _i_converter.toAttribute) ? i.converter : u$1).toAttribute(s, i.type);
+                    this._$Em = t, null == r ? this.removeAttribute(e) : this.setAttribute(e, r), this._$Em = null;
+                }
+            }
+        },
+        {
+            key: "_$AK",
+            value: function _$AK(t, s) {
+                var i = this.constructor, e = i._$Eh.get(t);
+                if (void 0 !== e && this._$Em !== e) {
+                    var _t_converter;
+                    var _$t = i.getPropertyOptions(e), r = "function" == typeof _$t.converter ? {
+                        fromAttribute: _$t.converter
+                    } : void 0 !== ((_t_converter = _$t.converter) === null || _t_converter === void 0 ? void 0 : _t_converter.fromAttribute) ? _$t.converter : u$1;
+                    this._$Em = e, this[e] = r.fromAttribute(s, _$t.type), this._$Em = null;
+                }
+            }
+        },
+        {
+            key: "requestUpdate",
+            value: function requestUpdate(t, s, i) {
+                if (void 0 !== t) {
+                    var _i_hasChanged;
+                    if (i !== null && i !== void 0 ? i : i = this.constructor.getPropertyOptions(t), !((_i_hasChanged = i.hasChanged) !== null && _i_hasChanged !== void 0 ? _i_hasChanged : f$1)(this[t], s)) return;
+                    this.P(t, s, i);
+                }
+                !1 === this.isUpdatePending && (this._$ES = this._$ET());
+            }
+        },
+        {
+            key: "P",
+            value: function P(t, s, i) {
+                var _this__$Ej;
+                this._$AL.has(t) || this._$AL.set(t, s), !0 === i.reflect && this._$Em !== t && ((_this__$Ej = this._$Ej) !== null && _this__$Ej !== void 0 ? _this__$Ej : this._$Ej = new Set).add(t);
+            }
+        },
+        {
+            key: "_$ET",
+            value: function _$ET() {
+                var _this = this;
+                return _async_to_generator(function() {
+                    var t, _$t, _tmp;
+                    return _ts_generator(this, function(_state) {
+                        switch(_state.label){
+                            case 0:
+                                _this.isUpdatePending = !0;
+                                _state.label = 1;
+                            case 1:
+                                _state.trys.push([
+                                    1,
+                                    3,
+                                    ,
+                                    4
+                                ]);
+                                return [
+                                    4,
+                                    _this._$ES
+                                ];
+                            case 2:
+                                _state.sent();
+                                return [
+                                    3,
+                                    4
+                                ];
+                            case 3:
+                                t = _state.sent();
+                                Promise.reject(t);
+                                return [
+                                    3,
+                                    4
+                                ];
+                            case 4:
+                                _$t = _this.scheduleUpdate();
+                                _tmp = null != _$t;
+                                if (!_tmp) return [
+                                    3,
+                                    6
+                                ];
+                                return [
+                                    4,
+                                    _$t
+                                ];
+                            case 5:
+                                _tmp = _state.sent();
+                                _state.label = 6;
+                            case 6:
+                                return [
+                                    2,
+                                    (!_this.isUpdatePending)
+                                ];
+                        }
+                    });
+                })();
+            }
+        },
+        {
+            key: "scheduleUpdate",
+            value: function scheduleUpdate() {
+                return this.performUpdate();
+            }
+        },
+        {
+            key: "performUpdate",
+            value: function performUpdate() {
+                if (!this.isUpdatePending) return;
+                if (!this.hasUpdated) {
+                    var _this_renderRoot;
+                    if ((_this_renderRoot = this.renderRoot) !== null && _this_renderRoot !== void 0 ? _this_renderRoot : this.renderRoot = this.createRenderRoot(), this._$Ep) {
+                        var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+                        try {
+                            for(var _iterator = this._$Ep[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                                var _step_value = _sliced_to_array$1(_step.value, 2), t = _step_value[0], _$s = _step_value[1];
+                                this[t] = _$s;
+                            }
+                        } catch (err) {
+                            _didIteratorError = true;
+                            _iteratorError = err;
+                        } finally{
+                            try {
+                                if (!_iteratorNormalCompletion && _iterator.return != null) {
+                                    _iterator.return();
+                                }
+                            } finally{
+                                if (_didIteratorError) {
+                                    throw _iteratorError;
+                                }
+                            }
+                        }
+                        this._$Ep = void 0;
+                    }
+                    var t1 = this.constructor.elementProperties;
+                    var _iteratorNormalCompletion1 = true, _didIteratorError1 = false, _iteratorError1 = undefined;
+                    if (t1.size > 0) try {
+                        for(var _iterator1 = t1[Symbol.iterator](), _step1; !(_iteratorNormalCompletion1 = (_step1 = _iterator1.next()).done); _iteratorNormalCompletion1 = true){
+                            var _step_value1 = _sliced_to_array$1(_step1.value, 2), _$s1 = _step_value1[0], i = _step_value1[1];
+                            !0 !== i.wrapped || this._$AL.has(_$s1) || void 0 === this[_$s1] || this.P(_$s1, this[_$s1], i);
+                        }
+                    } catch (err) {
+                        _didIteratorError1 = true;
+                        _iteratorError1 = err;
+                    } finally{
+                        try {
+                            if (!_iteratorNormalCompletion1 && _iterator1.return != null) {
+                                _iterator1.return();
+                            }
+                        } finally{
+                            if (_didIteratorError1) {
+                                throw _iteratorError1;
+                            }
+                        }
+                    }
+                }
+                var t2 = !1;
+                var _$s2 = this._$AL;
+                try {
+                    var _this__$EO;
+                    t2 = this.shouldUpdate(_$s2), t2 ? (this.willUpdate(_$s2), (_this__$EO = this._$EO) === null || _this__$EO === void 0 ? void 0 : _this__$EO.forEach(function(t) {
+                        var _t_hostUpdate;
+                        return (_t_hostUpdate = t.hostUpdate) === null || _t_hostUpdate === void 0 ? void 0 : _t_hostUpdate.call(t);
+                    }), this.update(_$s2)) : this._$EU();
+                } catch (s) {
+                    throw t2 = !1, this._$EU(), s;
+                }
+                t2 && this._$AE(_$s2);
+            }
+        },
+        {
+            key: "willUpdate",
+            value: function willUpdate(t) {}
+        },
+        {
+            key: "_$AE",
+            value: function _$AE(t) {
+                var _this__$EO;
+                (_this__$EO = this._$EO) === null || _this__$EO === void 0 ? void 0 : _this__$EO.forEach(function(t) {
+                    var _t_hostUpdated;
+                    return (_t_hostUpdated = t.hostUpdated) === null || _t_hostUpdated === void 0 ? void 0 : _t_hostUpdated.call(t);
+                }), this.hasUpdated || (this.hasUpdated = !0, this.firstUpdated(t)), this.updated(t);
+            }
+        },
+        {
+            key: "_$EU",
+            value: function _$EU() {
+                this._$AL = new Map, this.isUpdatePending = !1;
+            }
+        },
+        {
+            key: "updateComplete",
+            get: function get() {
+                return this.getUpdateComplete();
+            }
+        },
+        {
+            key: "getUpdateComplete",
+            value: function getUpdateComplete() {
+                return this._$ES;
+            }
+        },
+        {
+            key: "shouldUpdate",
+            value: function shouldUpdate(t) {
+                return !0;
+            }
+        },
+        {
+            key: "update",
+            value: function update(t) {
+                var _this = this;
+                this._$Ej && (this._$Ej = this._$Ej.forEach(function(t) {
+                    return _this._$EC(t, _this[t]);
+                })), this._$EU();
+            }
+        },
+        {
+            key: "updated",
+            value: function updated(t) {}
+        },
+        {
+            key: "firstUpdated",
+            value: function firstUpdated(t) {}
+        }
+    ], [
+        {
+            key: "addInitializer",
+            value: function addInitializer(t) {
+                var _this_l;
+                this._$Ei(), ((_this_l = this.l) !== null && _this_l !== void 0 ? _this_l : this.l = []).push(t);
+            }
+        },
+        {
+            key: "observedAttributes",
+            get: function get() {
+                return this.finalize(), this._$Eh && _to_consumable_array$1(this._$Eh.keys());
+            }
+        },
+        {
+            key: "createProperty",
+            value: function createProperty(t) {
+                var s = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : y$1;
+                if (s.state && (s.attribute = !1), this._$Ei(), this.elementProperties.set(t, s), !s.noAccessor) {
+                    var i = Symbol(), r = this.getPropertyDescriptor(t, i, s);
+                    void 0 !== r && e$1(this.prototype, t, r);
+                }
+            }
+        },
+        {
+            key: "getPropertyDescriptor",
+            value: function getPropertyDescriptor(t, s, i) {
+                var _r;
+                var _ref = (_r = r$4(this.prototype, t)) !== null && _r !== void 0 ? _r : {
+                    get: function get() {
+                        return this[s];
+                    },
+                    set: function set(t) {
+                        this[s] = t;
+                    }
+                }, e = _ref.get, h = _ref.set;
+                return {
+                    get: function get() {
+                        return e === null || e === void 0 ? void 0 : e.call(this);
+                    },
+                    set: function set(s) {
+                        var r = e === null || e === void 0 ? void 0 : e.call(this);
+                        h.call(this, s), this.requestUpdate(t, r, i);
+                    },
+                    configurable: !0,
+                    enumerable: !0
+                };
+            }
+        },
+        {
+            key: "getPropertyOptions",
+            value: function getPropertyOptions(t) {
+                var _this_elementProperties_get;
+                return (_this_elementProperties_get = this.elementProperties.get(t)) !== null && _this_elementProperties_get !== void 0 ? _this_elementProperties_get : y$1;
+            }
+        },
+        {
+            key: "_$Ei",
+            value: function _$Ei() {
+                if (this.hasOwnProperty(d$1("elementProperties"))) return;
+                var t = n$2(this);
+                t.finalize(), void 0 !== t.l && (this.l = _to_consumable_array$1(t.l)), this.elementProperties = new Map(t.elementProperties);
+            }
+        },
+        {
+            key: "finalize",
+            value: function finalize() {
+                if (this.hasOwnProperty(d$1("finalized"))) return;
+                if (this.finalized = !0, this._$Ei(), this.hasOwnProperty(d$1("properties"))) {
+                    var t = this.properties, s = _to_consumable_array$1(h$1(t)).concat(_to_consumable_array$1(o$2(t)));
+                    var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+                    try {
+                        for(var _iterator = s[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                            var i = _step.value;
+                            this.createProperty(i, t[i]);
+                        }
+                    } catch (err) {
+                        _didIteratorError = true;
+                        _iteratorError = err;
+                    } finally{
+                        try {
+                            if (!_iteratorNormalCompletion && _iterator.return != null) {
+                                _iterator.return();
+                            }
+                        } finally{
+                            if (_didIteratorError) {
+                                throw _iteratorError;
+                            }
+                        }
+                    }
+                }
+                var t1 = this[Symbol.metadata];
+                if (null !== t1) {
+                    var s1 = litPropertyMetadata.get(t1);
+                    var _iteratorNormalCompletion1 = true, _didIteratorError1 = false, _iteratorError1 = undefined;
+                    if (void 0 !== s1) try {
+                        for(var _iterator1 = s1[Symbol.iterator](), _step1; !(_iteratorNormalCompletion1 = (_step1 = _iterator1.next()).done); _iteratorNormalCompletion1 = true){
+                            var _step_value = _sliced_to_array$1(_step1.value, 2), t2 = _step_value[0], i1 = _step_value[1];
+                            this.elementProperties.set(t2, i1);
+                        }
+                    } catch (err) {
+                        _didIteratorError1 = true;
+                        _iteratorError1 = err;
+                    } finally{
+                        try {
+                            if (!_iteratorNormalCompletion1 && _iterator1.return != null) {
+                                _iterator1.return();
+                            }
+                        } finally{
+                            if (_didIteratorError1) {
+                                throw _iteratorError1;
+                            }
+                        }
+                    }
+                }
+                this._$Eh = new Map;
+                var _iteratorNormalCompletion2 = true, _didIteratorError2 = false, _iteratorError2 = undefined;
+                try {
+                    for(var _iterator2 = this.elementProperties[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true){
+                        var _step_value1 = _sliced_to_array$1(_step2.value, 2), t3 = _step_value1[0], s2 = _step_value1[1];
+                        var i2 = this._$Eu(t3, s2);
+                        void 0 !== i2 && this._$Eh.set(i2, t3);
+                    }
+                } catch (err) {
+                    _didIteratorError2 = true;
+                    _iteratorError2 = err;
+                } finally{
+                    try {
+                        if (!_iteratorNormalCompletion2 && _iterator2.return != null) {
+                            _iterator2.return();
+                        }
+                    } finally{
+                        if (_didIteratorError2) {
+                            throw _iteratorError2;
+                        }
+                    }
+                }
+                this.elementStyles = this.finalizeStyles(this.styles);
+            }
+        },
+        {
+            key: "finalizeStyles",
+            value: function finalizeStyles(s) {
+                var i = [];
+                if (Array.isArray(s)) {
+                    var e = new Set(s.flat(1 / 0).reverse());
+                    var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+                    try {
+                        for(var _iterator = e[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                            var _$s = _step.value;
+                            i.unshift(c$2(_$s));
+                        }
+                    } catch (err) {
+                        _didIteratorError = true;
+                        _iteratorError = err;
+                    } finally{
+                        try {
+                            if (!_iteratorNormalCompletion && _iterator.return != null) {
+                                _iterator.return();
+                            }
+                        } finally{
+                            if (_didIteratorError) {
+                                throw _iteratorError;
+                            }
+                        }
+                    }
+                } else void 0 !== s && i.push(c$2(s));
+                return i;
+            }
+        },
+        {
+            key: "_$Eu",
+            value: function _$Eu(t, s) {
+                var i = s.attribute;
+                return !1 === i ? void 0 : "string" == typeof i ? i : "string" == typeof t ? t.toLowerCase() : void 0;
+            }
+        }
+    ]);
+    return b;
+}(_wrap_native_super(HTMLElement));
+var _reactiveElementVersions;
+b.elementStyles = [], b.shadowRootOptions = {
+    mode: "open"
+}, b[d$1("elementProperties")] = new Map, b[d$1("finalized")] = new Map, p$1 === null || p$1 === void 0 ? void 0 : p$1({
+    ReactiveElement: b
+}), ((_reactiveElementVersions = (_a1 = a$1).reactiveElementVersions) !== null && _reactiveElementVersions !== void 0 ? _reactiveElementVersions : _a1.reactiveElementVersions = []).push("2.0.4");
+
+/**
+ * @license
+ * Copyright 2017 Google LLC
+ * SPDX-License-Identifier: BSD-3-Clause
+ */ function _array_like_to_array(arr, len) {
+    if (len == null || len > arr.length) len = arr.length;
+    for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
+    return arr2;
+}
+function _array_with_holes(arr) {
+    if (Array.isArray(arr)) return arr;
+}
+function _array_without_holes(arr) {
+    if (Array.isArray(arr)) return _array_like_to_array(arr);
+}
+function _assert_this_initialized$1(self) {
+    if (self === void 0) {
+        throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+    }
+    return self;
+}
+function _class_call_check$1(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+    }
+}
+function _defineProperties$1(target, props) {
+    for(var i = 0; i < props.length; i++){
+        var descriptor = props[i];
+        descriptor.enumerable = descriptor.enumerable || false;
+        descriptor.configurable = true;
+        if ("value" in descriptor) descriptor.writable = true;
+        Object.defineProperty(target, descriptor.key, descriptor);
+    }
+}
+function _create_class$1(Constructor, protoProps, staticProps) {
+    if (protoProps) _defineProperties$1(Constructor.prototype, protoProps);
+    if (staticProps) _defineProperties$1(Constructor, staticProps);
+    return Constructor;
+}
+function _get_prototype_of$1(o) {
+    _get_prototype_of$1 = Object.setPrototypeOf ? Object.getPrototypeOf : function getPrototypeOf(o) {
+        return o.__proto__ || Object.getPrototypeOf(o);
+    };
+    return _get_prototype_of$1(o);
+}
+function _inherits$1(subClass, superClass) {
+    if (typeof superClass !== "function" && superClass !== null) {
+        throw new TypeError("Super expression must either be null or a function");
+    }
+    subClass.prototype = Object.create(superClass && superClass.prototype, {
+        constructor: {
+            value: subClass,
+            writable: true,
+            configurable: true
+        }
+    });
+    if (superClass) _set_prototype_of$1(subClass, superClass);
+}
+function _iterable_to_array(iter) {
+    if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
+}
+function _iterable_to_array_limit(arr, i) {
+    var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"];
+    if (_i == null) return;
+    var _arr = [];
+    var _n = true;
+    var _d = false;
+    var _s, _e;
+    try {
+        for(_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true){
+            _arr.push(_s.value);
+            if (i && _arr.length === i) break;
+        }
+    } catch (err) {
+        _d = true;
+        _e = err;
+    } finally{
+        try {
+            if (!_n && _i["return"] != null) _i["return"]();
+        } finally{
+            if (_d) throw _e;
+        }
+    }
+    return _arr;
+}
+function _non_iterable_rest() {
+    throw new TypeError("Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _non_iterable_spread() {
+    throw new TypeError("Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _possible_constructor_return$1(self, call) {
+    if (call && (_type_of$1(call) === "object" || typeof call === "function")) {
+        return call;
+    }
+    return _assert_this_initialized$1(self);
+}
+function _set_prototype_of$1(o, p) {
+    _set_prototype_of$1 = Object.setPrototypeOf || function setPrototypeOf(o, p) {
+        o.__proto__ = p;
+        return o;
+    };
+    return _set_prototype_of$1(o, p);
+}
+function _sliced_to_array(arr, i) {
+    return _array_with_holes(arr) || _iterable_to_array_limit(arr, i) || _unsupported_iterable_to_array(arr, i) || _non_iterable_rest();
+}
+function _to_consumable_array(arr) {
+    return _array_without_holes(arr) || _iterable_to_array(arr) || _unsupported_iterable_to_array(arr) || _non_iterable_spread();
+}
+function _type_of$1(obj) {
+    "@swc/helpers - typeof";
+    return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
+}
+function _unsupported_iterable_to_array(o, minLen) {
+    if (!o) return;
+    if (typeof o === "string") return _array_like_to_array(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor) n = o.constructor.name;
+    if (n === "Map" || n === "Set") return Array.from(n);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array(o, minLen);
+}
+function _is_native_reflect_construct$1() {
+    if (typeof Reflect === "undefined" || !Reflect.construct) return false;
+    if (Reflect.construct.sham) return false;
+    if (typeof Proxy === "function") return true;
+    try {
+        Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {}));
+        return true;
+    } catch (e) {
+        return false;
+    }
+}
+function _create_super$1(Derived) {
+    var hasNativeReflectConstruct = _is_native_reflect_construct$1();
+    return function _createSuperInternal() {
+        var Super = _get_prototype_of$1(Derived), result;
+        if (hasNativeReflectConstruct) {
+            var NewTarget = _get_prototype_of$1(this).constructor;
+            result = Reflect.construct(Super, arguments, NewTarget);
+        } else {
+            result = Super.apply(this, arguments);
+        }
+        return _possible_constructor_return$1(this, result);
+    };
+}
+var _t;
+var t$1 = globalThis, i = t$1.trustedTypes, s$1 = i ? i.createPolicy("lit-html", {
+    createHTML: function(t) {
+        return t;
+    }
+}) : void 0, e = "$lit$", h = "lit$".concat((Math.random() + "").slice(9), "$"), o$1 = "?" + h, n$1 = "<".concat(o$1, ">"), r$3 = document, l = function() {
+    return r$3.createComment("");
+}, c = function(t) {
+    return null === t || "object" != typeof t && "function" != typeof t;
+}, a = Array.isArray, u = function(t) {
+    return a(t) || "function" == typeof (t === null || t === void 0 ? void 0 : t[Symbol.iterator]);
+}, d = "[ 	\n\f\r]", f = /<(?:(!--|\/[^a-zA-Z])|(\/?[a-zA-Z][^>\s]*)|(\/?$))/g, v = /-->/g, _ = />/g, m = RegExp(">|".concat(d, "(?:([^\\s\"'>=/]+)(").concat(d, "*=").concat(d, "*(?:[^ 	\n\f\r\"'`<>=]|(\"|')|))|$)"), "g"), p = /'/g, g = /"/g, $ = /^(?:script|style|textarea|title)$/i, y = function(t) {
+    return function(i) {
+        for(var _len = arguments.length, s = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++){
+            s[_key - 1] = arguments[_key];
+        }
+        return {
+            _$litType$: t,
+            strings: i,
+            values: s
+        };
+    };
+}, x = y(1), w = Symbol.for("lit-noChange"), T = Symbol.for("lit-nothing"), A = new WeakMap, E = r$3.createTreeWalker(r$3, 129);
+function C(t, i) {
+    if (!Array.isArray(t) || !t.hasOwnProperty("raw")) throw Error("invalid template strings array");
+    return void 0 !== s$1 ? s$1.createHTML(i) : i;
+}
+var P = function(t, i) {
+    var s = t.length - 1, o = [];
+    var r, l = 2 === i ? "<svg>" : "", c = f;
+    for(var _$i = 0; _$i < s; _$i++){
+        var s1 = t[_$i];
+        var a = void 0, u = void 0, d = -1, y = 0;
+        for(; y < s1.length && (c.lastIndex = y, u = c.exec(s1), null !== u);)y = c.lastIndex, c === f ? "!--" === u[1] ? c = v : void 0 !== u[1] ? c = _ : void 0 !== u[2] ? ($.test(u[2]) && (r = RegExp("</" + u[2], "g")), c = m) : void 0 !== u[3] && (c = m) : c === m ? ">" === u[0] ? (c = r !== null && r !== void 0 ? r : f, d = -1) : void 0 === u[1] ? d = -2 : (d = c.lastIndex - u[2].length, a = u[1], c = void 0 === u[3] ? m : '"' === u[3] ? g : p) : c === g || c === p ? c = m : c === v || c === _ ? c = f : (c = m, r = void 0);
+        var x = c === m && t[_$i + 1].startsWith("/>") ? " " : "";
+        l += c === f ? s1 + n$1 : d >= 0 ? (o.push(a), s1.slice(0, d) + e + s1.slice(d) + h + x) : s1 + h + (-2 === d ? _$i : x);
+    }
+    return [
+        C(t, l + (t[s] || "<?>") + (2 === i ? "</svg>" : "")),
+        o
+    ];
+};
+var V = /*#__PURE__*/ function() {
+    function V(param, n) {
+        var t = param.strings, s = param._$litType$;
+        _class_call_check$1(this, V);
+        var r;
+        this.parts = [];
+        var c = 0, a = 0;
+        var u = t.length - 1, d = this.parts, _P = _sliced_to_array(P(t, s), 2), f = _P[0], v = _P[1];
+        if (this.el = V.createElement(f, n), E.currentNode = this.el.content, 2 === s) {
+            var _t;
+            var t1 = this.el.content.firstChild;
+            (_t = t1).replaceWith.apply(_t, _to_consumable_array(t1.childNodes));
+        }
+        for(; null !== (r = E.nextNode()) && d.length < u;){
+            if (1 === r.nodeType) {
+                var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+                if (r.hasAttributes()) try {
+                    for(var _iterator = r.getAttributeNames()[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                        var t2 = _step.value;
+                        if (t2.endsWith(e)) {
+                            var i1 = v[a++], s1 = r.getAttribute(t2).split(h), e1 = /([.?@])?(.*)/.exec(i1);
+                            d.push({
+                                type: 1,
+                                index: c,
+                                name: e1[2],
+                                strings: s1,
+                                ctor: "." === e1[1] ? k : "?" === e1[1] ? H : "@" === e1[1] ? I : R
+                            }), r.removeAttribute(t2);
+                        } else t2.startsWith(h) && (d.push({
+                            type: 6,
+                            index: c
+                        }), r.removeAttribute(t2));
+                    }
+                } catch (err) {
+                    _didIteratorError = true;
+                    _iteratorError = err;
+                } finally{
+                    try {
+                        if (!_iteratorNormalCompletion && _iterator.return != null) {
+                            _iterator.return();
+                        }
+                    } finally{
+                        if (_didIteratorError) {
+                            throw _iteratorError;
+                        }
+                    }
+                }
+                if ($.test(r.tagName)) {
+                    var t3 = r.textContent.split(h), s2 = t3.length - 1;
+                    if (s2 > 0) {
+                        r.textContent = i ? i.emptyScript : "";
+                        for(var i2 = 0; i2 < s2; i2++)r.append(t3[i2], l()), E.nextNode(), d.push({
+                            type: 2,
+                            index: ++c
+                        });
+                        r.append(t3[s2], l());
+                    }
+                }
+            } else if (8 === r.nodeType) if (r.data === o$1) d.push({
+                type: 2,
+                index: c
+            });
+            else {
+                var t4 = -1;
+                for(; -1 !== (t4 = r.data.indexOf(h, t4 + 1));)d.push({
+                    type: 7,
+                    index: c
+                }), t4 += h.length - 1;
+            }
+            c++;
+        }
+    }
+    _create_class$1(V, null, [
+        {
+            key: "createElement",
+            value: function createElement(t, i) {
+                var s = r$3.createElement("template");
+                return s.innerHTML = t, s;
+            }
+        }
+    ]);
+    return V;
+}();
+function N(t, i) {
+    var s = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : t, e = arguments.length > 3 ? arguments[3] : void 0;
+    var _s__$Co, _h__$AO;
+    var _s;
+    if (i === w) return i;
+    var h = void 0 !== e ? (_s__$Co = s._$Co) === null || _s__$Co === void 0 ? void 0 : _s__$Co[e] : s._$Cl;
+    var o = c(i) ? void 0 : i._$litDirective$;
+    var __$Co;
+    return (h === null || h === void 0 ? void 0 : h.constructor) !== o && (h === null || h === void 0 ? void 0 : (_h__$AO = h._$AO) === null || _h__$AO === void 0 ? void 0 : _h__$AO.call(h, !1), void 0 === o ? h = void 0 : (h = new o(t), h._$AT(t, s, e)), void 0 !== e ? ((__$Co = (_s = s)._$Co) !== null && __$Co !== void 0 ? __$Co : _s._$Co = [])[e] = h : s._$Cl = h), void 0 !== h && (i = N(t, h._$AS(t, i.values), h, e)), i;
+}
+var S = /*#__PURE__*/ function() {
+    function S(t, i) {
+        _class_call_check$1(this, S);
+        this._$AV = [], this._$AN = void 0, this._$AD = t, this._$AM = i;
+    }
+    _create_class$1(S, [
+        {
+            key: "parentNode",
+            get: function get() {
+                return this._$AM.parentNode;
+            }
+        },
+        {
+            key: "_$AU",
+            get: function get() {
+                return this._$AM._$AU;
+            }
+        },
+        {
+            key: "u",
+            value: function u(t) {
+                var _t_creationScope;
+                var _this__$AD = this._$AD, _this__$AD_el = _this__$AD.el, i = _this__$AD_el.content, s = _this__$AD.parts, e = ((_t_creationScope = t === null || t === void 0 ? void 0 : t.creationScope) !== null && _t_creationScope !== void 0 ? _t_creationScope : r$3).importNode(i, !0);
+                E.currentNode = e;
+                var h = E.nextNode(), o = 0, n = 0, l = s[0];
+                for(; void 0 !== l;){
+                    if (o === l.index) {
+                        var i1 = void 0;
+                        2 === l.type ? i1 = new M(h, h.nextSibling, this, t) : 1 === l.type ? i1 = new l.ctor(h, l.name, l.strings, this, t) : 6 === l.type && (i1 = new L(h, this, t)), this._$AV.push(i1), l = s[++n];
+                    }
+                    o !== (l === null || l === void 0 ? void 0 : l.index) && (h = E.nextNode(), o++);
+                }
+                return E.currentNode = r$3, e;
+            }
+        },
+        {
+            key: "p",
+            value: function p(t) {
+                var i = 0;
+                var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+                try {
+                    for(var _iterator = this._$AV[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                        var s = _step.value;
+                        void 0 !== s && (void 0 !== s.strings ? (s._$AI(t, s, i), i += s.strings.length - 2) : s._$AI(t[i])), i++;
+                    }
+                } catch (err) {
+                    _didIteratorError = true;
+                    _iteratorError = err;
+                } finally{
+                    try {
+                        if (!_iteratorNormalCompletion && _iterator.return != null) {
+                            _iterator.return();
+                        }
+                    } finally{
+                        if (_didIteratorError) {
+                            throw _iteratorError;
+                        }
+                    }
+                }
+            }
+        }
+    ]);
+    return S;
+}();
+var M = /*#__PURE__*/ function() {
+    function M(t, i, s, e) {
+        _class_call_check$1(this, M);
+        var _e_isConnected;
+        this.type = 2, this._$AH = T, this._$AN = void 0, this._$AA = t, this._$AB = i, this._$AM = s, this.options = e, this._$Cv = (_e_isConnected = e === null || e === void 0 ? void 0 : e.isConnected) !== null && _e_isConnected !== void 0 ? _e_isConnected : !0;
+    }
+    _create_class$1(M, [
+        {
+            key: "_$AU",
+            get: function get() {
+                var _this__$AM;
+                var _this__$AM__$AU;
+                return (_this__$AM__$AU = (_this__$AM = this._$AM) === null || _this__$AM === void 0 ? void 0 : _this__$AM._$AU) !== null && _this__$AM__$AU !== void 0 ? _this__$AM__$AU : this._$Cv;
+            }
+        },
+        {
+            key: "parentNode",
+            get: function get() {
+                var t = this._$AA.parentNode;
+                var i = this._$AM;
+                return void 0 !== i && 11 === (t === null || t === void 0 ? void 0 : t.nodeType) && (t = i.parentNode), t;
+            }
+        },
+        {
+            key: "startNode",
+            get: function get() {
+                return this._$AA;
+            }
+        },
+        {
+            key: "endNode",
+            get: function get() {
+                return this._$AB;
+            }
+        },
+        {
+            key: "_$AI",
+            value: function _$AI(t) {
+                var i = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : this;
+                t = N(this, t, i), c(t) ? t === T || null == t || "" === t ? (this._$AH !== T && this._$AR(), this._$AH = T) : t !== this._$AH && t !== w && this._(t) : void 0 !== t._$litType$ ? this.$(t) : void 0 !== t.nodeType ? this.T(t) : u(t) ? this.k(t) : this._(t);
+            }
+        },
+        {
+            key: "S",
+            value: function S(t) {
+                return this._$AA.parentNode.insertBefore(t, this._$AB);
+            }
+        },
+        {
+            key: "T",
+            value: function T(t) {
+                this._$AH !== t && (this._$AR(), this._$AH = this.S(t));
+            }
+        },
+        {
+            key: "_",
+            value: function _(t) {
+                this._$AH !== T && c(this._$AH) ? this._$AA.nextSibling.data = t : this.T(r$3.createTextNode(t)), this._$AH = t;
+            }
+        },
+        {
+            key: "$",
+            value: function $(t) {
+                var _this__$AH;
+                var i = t.values, s = t._$litType$, e = "number" == typeof s ? this._$AC(t) : (void 0 === s.el && (s.el = V.createElement(C(s.h, s.h[0]), this.options)), s);
+                if (((_this__$AH = this._$AH) === null || _this__$AH === void 0 ? void 0 : _this__$AH._$AD) === e) this._$AH.p(i);
+                else {
+                    var _$t = new S(e, this), s1 = _$t.u(this.options);
+                    _$t.p(i), this.T(s1), this._$AH = _$t;
+                }
+            }
+        },
+        {
+            key: "_$AC",
+            value: function _$AC(t) {
+                var i = A.get(t.strings);
+                return void 0 === i && A.set(t.strings, i = new V(t)), i;
+            }
+        },
+        {
+            key: "k",
+            value: function k(t) {
+                a(this._$AH) || (this._$AH = [], this._$AR());
+                var i = this._$AH;
+                var s, e = 0;
+                var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+                try {
+                    for(var _iterator = t[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                        var h = _step.value;
+                        e === i.length ? i.push(s = new M(this.S(l()), this.S(l()), this, this.options)) : s = i[e], s._$AI(h), e++;
+                    }
+                } catch (err) {
+                    _didIteratorError = true;
+                    _iteratorError = err;
+                } finally{
+                    try {
+                        if (!_iteratorNormalCompletion && _iterator.return != null) {
+                            _iterator.return();
+                        }
+                    } finally{
+                        if (_didIteratorError) {
+                            throw _iteratorError;
+                        }
+                    }
+                }
+                e < i.length && (this._$AR(s && s._$AB.nextSibling, e), i.length = e);
+            }
+        },
+        {
+            key: "_$AR",
+            value: function _$AR() {
+                var t = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : this._$AA.nextSibling, i = arguments.length > 1 ? arguments[1] : void 0;
+                var _this__$AP, _this;
+                for((_this__$AP = (_this = this)._$AP) === null || _this__$AP === void 0 ? void 0 : _this__$AP.call(_this, !1, !0, i); t && t !== this._$AB;){
+                    var i1 = t.nextSibling;
+                    t.remove(), t = i1;
+                }
+            }
+        },
+        {
+            key: "setConnected",
+            value: function setConnected(t) {
+                var _this__$AP, _this;
+                void 0 === this._$AM && (this._$Cv = t, (_this__$AP = (_this = this)._$AP) === null || _this__$AP === void 0 ? void 0 : _this__$AP.call(_this, t));
+            }
+        }
+    ]);
+    return M;
+}();
+var R = /*#__PURE__*/ function() {
+    function R(t, i, s, e, h) {
+        _class_call_check$1(this, R);
+        this.type = 1, this._$AH = T, this._$AN = void 0, this.element = t, this.name = i, this._$AM = e, this.options = h, s.length > 2 || "" !== s[0] || "" !== s[1] ? (this._$AH = Array(s.length - 1).fill(new String), this.strings = s) : this._$AH = T;
+    }
+    _create_class$1(R, [
+        {
+            key: "tagName",
+            get: function get() {
+                return this.element.tagName;
+            }
+        },
+        {
+            key: "_$AU",
+            get: function get() {
+                return this._$AM._$AU;
+            }
+        },
+        {
+            key: "_$AI",
+            value: function _$AI(t) {
+                var i = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : this, s = arguments.length > 2 ? arguments[2] : void 0, e = arguments.length > 3 ? arguments[3] : void 0;
+                var h = this.strings;
+                var o = !1;
+                if (void 0 === h) t = N(this, t, i, 0), o = !c(t) || t !== this._$AH && t !== w, o && (this._$AH = t);
+                else {
+                    var e1 = t;
+                    var n, r;
+                    for(t = h[0], n = 0; n < h.length - 1; n++)r = N(this, e1[s + n], i, n), r === w && (r = this._$AH[n]), o || (o = !c(r) || r !== this._$AH[n]), r === T ? t = T : t !== T && (t += (r !== null && r !== void 0 ? r : "") + h[n + 1]), this._$AH[n] = r;
+                }
+                o && !e && this.j(t);
+            }
+        },
+        {
+            key: "j",
+            value: function j(t) {
+                t === T ? this.element.removeAttribute(this.name) : this.element.setAttribute(this.name, t !== null && t !== void 0 ? t : "");
+            }
+        }
+    ]);
+    return R;
+}();
+var k = /*#__PURE__*/ function(R) {
+    _inherits$1(k, R);
+    var _super = _create_super$1(k);
+    function k() {
+        _class_call_check$1(this, k);
+        var _this;
+        _this = _super.call.apply(_super, [
+            this
+        ].concat(Array.prototype.slice.call(arguments))), _this.type = 3;
+        return _possible_constructor_return$1(_this);
+    }
+    _create_class$1(k, [
+        {
+            key: "j",
+            value: function j(t) {
+                this.element[this.name] = t === T ? void 0 : t;
+            }
+        }
+    ]);
+    return k;
+}(R);
+var H = /*#__PURE__*/ function(R) {
+    _inherits$1(H, R);
+    var _super = _create_super$1(H);
+    function H() {
+        _class_call_check$1(this, H);
+        var _this;
+        _this = _super.call.apply(_super, [
+            this
+        ].concat(Array.prototype.slice.call(arguments))), _this.type = 4;
+        return _possible_constructor_return$1(_this);
+    }
+    _create_class$1(H, [
+        {
+            key: "j",
+            value: function j(t) {
+                this.element.toggleAttribute(this.name, !!t && t !== T);
+            }
+        }
+    ]);
+    return H;
+}(R);
+var I = /*#__PURE__*/ function(R) {
+    _inherits$1(I, R);
+    var _super = _create_super$1(I);
+    function I(t, i, s, e, h) {
+        _class_call_check$1(this, I);
+        var _this;
+        _this = _super.call(this, t, i, s, e, h), _this.type = 5;
+        return _possible_constructor_return$1(_this);
+    }
+    _create_class$1(I, [
+        {
+            key: "_$AI",
+            value: function _$AI(t) {
+                var i = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : this;
+                var _N;
+                if ((t = (_N = N(this, t, i, 0)) !== null && _N !== void 0 ? _N : T) === w) return;
+                var s = this._$AH, e = t === T && s !== T || t.capture !== s.capture || t.once !== s.once || t.passive !== s.passive, h = t !== T && (s === T || e);
+                e && this.element.removeEventListener(this.name, this, s), h && this.element.addEventListener(this.name, this, t), this._$AH = t;
+            }
+        },
+        {
+            key: "handleEvent",
+            value: function handleEvent(t) {
+                var _this_options;
+                var _this_options_host;
+                "function" == typeof this._$AH ? this._$AH.call((_this_options_host = (_this_options = this.options) === null || _this_options === void 0 ? void 0 : _this_options.host) !== null && _this_options_host !== void 0 ? _this_options_host : this.element, t) : this._$AH.handleEvent(t);
+            }
+        }
+    ]);
+    return I;
+}(R);
+var L = /*#__PURE__*/ function() {
+    function L(t, i, s) {
+        _class_call_check$1(this, L);
+        this.element = t, this.type = 6, this._$AN = void 0, this._$AM = i, this.options = s;
+    }
+    _create_class$1(L, [
+        {
+            key: "_$AU",
+            get: function get() {
+                return this._$AM._$AU;
+            }
+        },
+        {
+            key: "_$AI",
+            value: function _$AI(t) {
+                N(this, t);
+            }
+        }
+    ]);
+    return L;
+}();
+var Z = t$1.litHtmlPolyfillSupport;
+var _litHtmlVersions;
+Z === null || Z === void 0 ? void 0 : Z(V, M), ((_litHtmlVersions = (_t = t$1).litHtmlVersions) !== null && _litHtmlVersions !== void 0 ? _litHtmlVersions : _t.litHtmlVersions = []).push("3.1.2");
+var j = function(t, i, s) {
+    var _s_renderBefore;
+    var e = (_s_renderBefore = s === null || s === void 0 ? void 0 : s.renderBefore) !== null && _s_renderBefore !== void 0 ? _s_renderBefore : i;
+    var h = e._$litPart$;
+    if (void 0 === h) {
+        var _s_renderBefore1;
+        var _$t = (_s_renderBefore1 = s === null || s === void 0 ? void 0 : s.renderBefore) !== null && _s_renderBefore1 !== void 0 ? _s_renderBefore1 : null;
+        e._$litPart$ = h = new M(i.insertBefore(l(), _$t), _$t, void 0, s !== null && s !== void 0 ? s : {});
+    }
+    return h._$AI(t), h;
+};
+
+function _assert_this_initialized(self) {
+    if (self === void 0) {
+        throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+    }
+    return self;
+}
+function _class_call_check(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+    }
+}
+function _defineProperties(target, props) {
+    for(var i = 0; i < props.length; i++){
+        var descriptor = props[i];
+        descriptor.enumerable = descriptor.enumerable || false;
+        descriptor.configurable = true;
+        if ("value" in descriptor) descriptor.writable = true;
+        Object.defineProperty(target, descriptor.key, descriptor);
+    }
+}
+function _create_class(Constructor, protoProps, staticProps) {
+    if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+    if (staticProps) _defineProperties(Constructor, staticProps);
+    return Constructor;
+}
+function _get(target, property, receiver) {
+    if (typeof Reflect !== "undefined" && Reflect.get) {
+        _get = Reflect.get;
+    } else {
+        _get = function get(target, property, receiver) {
+            var base = _super_prop_base(target, property);
+            if (!base) return;
+            var desc = Object.getOwnPropertyDescriptor(base, property);
+            if (desc.get) {
+                return desc.get.call(receiver || target);
+            }
+            return desc.value;
+        };
+    }
+    return _get(target, property, receiver || target);
+}
+function _get_prototype_of(o) {
+    _get_prototype_of = Object.setPrototypeOf ? Object.getPrototypeOf : function getPrototypeOf(o) {
+        return o.__proto__ || Object.getPrototypeOf(o);
+    };
+    return _get_prototype_of(o);
+}
+function _inherits(subClass, superClass) {
+    if (typeof superClass !== "function" && superClass !== null) {
+        throw new TypeError("Super expression must either be null or a function");
+    }
+    subClass.prototype = Object.create(superClass && superClass.prototype, {
+        constructor: {
+            value: subClass,
+            writable: true,
+            configurable: true
+        }
+    });
+    if (superClass) _set_prototype_of(subClass, superClass);
+}
+function _possible_constructor_return(self, call) {
+    if (call && (_type_of(call) === "object" || typeof call === "function")) {
+        return call;
+    }
+    return _assert_this_initialized(self);
+}
+function _set_prototype_of(o, p) {
+    _set_prototype_of = Object.setPrototypeOf || function setPrototypeOf(o, p) {
+        o.__proto__ = p;
+        return o;
+    };
+    return _set_prototype_of(o, p);
+}
+function _super_prop_base(object, property) {
+    while(!Object.prototype.hasOwnProperty.call(object, property)){
+        object = _get_prototype_of(object);
+        if (object === null) break;
+    }
+    return object;
+}
+function _type_of(obj) {
+    "@swc/helpers - typeof";
+    return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
+}
+function _is_native_reflect_construct() {
+    if (typeof Reflect === "undefined" || !Reflect.construct) return false;
+    if (Reflect.construct.sham) return false;
+    if (typeof Proxy === "function") return true;
+    try {
+        Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {}));
+        return true;
+    } catch (e) {
+        return false;
+    }
+}
+function _create_super(Derived) {
+    var hasNativeReflectConstruct = _is_native_reflect_construct();
+    return function _createSuperInternal() {
+        var Super = _get_prototype_of(Derived), result;
+        if (hasNativeReflectConstruct) {
+            var NewTarget = _get_prototype_of(this).constructor;
+            result = Reflect.construct(Super, arguments, NewTarget);
+        } else {
+            result = Super.apply(this, arguments);
+        }
+        return _possible_constructor_return(this, result);
+    };
+}
+var _globalThis_litElementHydrateSupport, _globalThis;
+var _globalThis1;
+/**
+ * @license
+ * Copyright 2017 Google LLC
+ * SPDX-License-Identifier: BSD-3-Clause
+ */ var s = /*#__PURE__*/ function(t) {
+    _inherits(s, t);
+    var _super = _create_super(s);
+    function s() {
+        _class_call_check(this, s);
+        var _this;
+        _this = _super.call.apply(_super, [
+            this
+        ].concat(Array.prototype.slice.call(arguments))), _this.renderOptions = {
+            host: _assert_this_initialized(_this)
+        }, _this._$Do = void 0;
+        return _possible_constructor_return(_this);
+    }
+    _create_class(s, [
+        {
+            key: "createRenderRoot",
+            value: function createRenderRoot() {
+                var _this_renderOptions;
+                var _$t = _get(_get_prototype_of(s.prototype), "createRenderRoot", this).call(this);
+                var _renderBefore;
+                return (_renderBefore = (_this_renderOptions = this.renderOptions).renderBefore) !== null && _renderBefore !== void 0 ? _renderBefore : _this_renderOptions.renderBefore = _$t.firstChild, _$t;
+            }
+        },
+        {
+            key: "update",
+            value: function update(t) {
+                var i = this.render();
+                this.hasUpdated || (this.renderOptions.isConnected = this.isConnected), _get(_get_prototype_of(s.prototype), "update", this).call(this, t), this._$Do = j(i, this.renderRoot, this.renderOptions);
+            }
+        },
+        {
+            key: "connectedCallback",
+            value: function connectedCallback() {
+                var _this__$Do;
+                _get(_get_prototype_of(s.prototype), "connectedCallback", this).call(this), (_this__$Do = this._$Do) === null || _this__$Do === void 0 ? void 0 : _this__$Do.setConnected(!0);
+            }
+        },
+        {
+            key: "disconnectedCallback",
+            value: function disconnectedCallback() {
+                var _this__$Do;
+                _get(_get_prototype_of(s.prototype), "disconnectedCallback", this).call(this), (_this__$Do = this._$Do) === null || _this__$Do === void 0 ? void 0 : _this__$Do.setConnected(!1);
+            }
+        },
+        {
+            key: "render",
+            value: function render() {
+                return w;
+            }
+        }
+    ]);
+    return s;
+}(b);
+s._$litElement$ = !0, s["finalized"] = !0, (_globalThis_litElementHydrateSupport = (_globalThis = globalThis).litElementHydrateSupport) === null || _globalThis_litElementHydrateSupport === void 0 ? void 0 : _globalThis_litElementHydrateSupport.call(_globalThis, {
+    LitElement: s
+});
+var r$2 = globalThis.litElementPolyfillSupport;
+r$2 === null || r$2 === void 0 ? void 0 : r$2({
+    LitElement: s
+});
+var _litElementVersions;
+((_litElementVersions = (_globalThis1 = globalThis).litElementVersions) !== null && _litElementVersions !== void 0 ? _litElementVersions : _globalThis1.litElementVersions = []).push("4.0.4");
+
+/**
+ * @license
+ * Copyright 2017 Google LLC
+ * SPDX-License-Identifier: BSD-3-Clause
+ */ var t = function(t) {
+    return function(e, o) {
+        void 0 !== o ? o.addInitializer(function() {
+            customElements.define(t, e);
+        }) : customElements.define(t, e);
+    };
+};
+
+function _define_property$1(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+function _object_spread$1(target) {
+    for(var i = 1; i < arguments.length; i++){
+        var source = arguments[i] != null ? arguments[i] : {};
+        var ownKeys = Object.keys(source);
+        if (typeof Object.getOwnPropertySymbols === "function") {
+            ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
+                return Object.getOwnPropertyDescriptor(source, sym).enumerable;
+            }));
+        }
+        ownKeys.forEach(function(key) {
+            _define_property$1(target, key, source[key]);
+        });
+    }
+    return target;
+}
+function ownKeys$1(object, enumerableOnly) {
+    var keys = Object.keys(object);
+    if (Object.getOwnPropertySymbols) {
+        var symbols = Object.getOwnPropertySymbols(object);
+        if (enumerableOnly) {
+            symbols = symbols.filter(function(sym) {
+                return Object.getOwnPropertyDescriptor(object, sym).enumerable;
+            });
+        }
+        keys.push.apply(keys, symbols);
+    }
+    return keys;
+}
+function _object_spread_props$1(target, source) {
+    source = source != null ? source : {};
+    if (Object.getOwnPropertyDescriptors) {
+        Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
+    } else {
+        ownKeys$1(Object(source)).forEach(function(key) {
+            Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+        });
+    }
+    return target;
+}
+/**
+ * @license
+ * Copyright 2017 Google LLC
+ * SPDX-License-Identifier: BSD-3-Clause
+ */ var o = {
+    attribute: !0,
+    type: String,
+    converter: u$1,
+    reflect: !1,
+    hasChanged: f$1
+}, r$1 = function() {
+    var _$t = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : o, _$e = arguments.length > 1 ? arguments[1] : void 0, r = arguments.length > 2 ? arguments[2] : void 0;
+    var n = r.kind, i = r.metadata;
+    var s = globalThis.litPropertyMetadata.get(i);
+    if (void 0 === s && globalThis.litPropertyMetadata.set(i, s = new Map), s.set(r.name, _$t), "accessor" === n) {
+        var o1 = r.name;
+        return {
+            set: function set(r) {
+                var n = _$e.get.call(this);
+                _$e.set.call(this, r), this.requestUpdate(o1, n, _$t);
+            },
+            init: function init(e) {
+                return void 0 !== e && this.P(o1, void 0, _$t), e;
+            }
+        };
+    }
+    if ("setter" === n) {
+        var o2 = r.name;
+        return function r(r) {
+            var n = this[o2];
+            _$e.call(this, r), this.requestUpdate(o2, n, _$t);
+        };
+    }
+    throw Error("Unsupported decorator location: " + n);
+};
+function n(t) {
+    return function(e, o) {
+        return "object" == typeof o ? r$1(t, e, o) : function(t, e, o) {
+            var r = e.hasOwnProperty(o);
+            return e.constructor.createProperty(o, r ? _object_spread_props$1(_object_spread$1({}, t), {
+                wrapped: !0
+            }) : t), r ? Object.getOwnPropertyDescriptor(e, o) : void 0;
+        }(t, e, o);
+    };
+}
+
+function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+function _object_spread(target) {
+    for(var i = 1; i < arguments.length; i++){
+        var source = arguments[i] != null ? arguments[i] : {};
+        var ownKeys = Object.keys(source);
+        if (typeof Object.getOwnPropertySymbols === "function") {
+            ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
+                return Object.getOwnPropertyDescriptor(source, sym).enumerable;
+            }));
+        }
+        ownKeys.forEach(function(key) {
+            _define_property(target, key, source[key]);
+        });
+    }
+    return target;
+}
+function ownKeys(object, enumerableOnly) {
+    var keys = Object.keys(object);
+    if (Object.getOwnPropertySymbols) {
+        var symbols = Object.getOwnPropertySymbols(object);
+        if (enumerableOnly) {
+            symbols = symbols.filter(function(sym) {
+                return Object.getOwnPropertyDescriptor(object, sym).enumerable;
+            });
+        }
+        keys.push.apply(keys, symbols);
+    }
+    return keys;
+}
+function _object_spread_props(target, source) {
+    source = source != null ? source : {};
+    if (Object.getOwnPropertyDescriptors) {
+        Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
+    } else {
+        ownKeys(Object(source)).forEach(function(key) {
+            Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+        });
+    }
+    return target;
+}
+/**
+ * @license
+ * Copyright 2017 Google LLC
+ * SPDX-License-Identifier: BSD-3-Clause
+ */ function r(r) {
+    return n(_object_spread_props(_object_spread({}, r), {
+        state: !0,
+        attribute: !1
+    }));
+}
+
+var commonjsGlobal = typeof globalThis !== "undefined" ? globalThis : typeof window !== "undefined" ? window : typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : {};
+
+var toastify$1 = {
+    exports: {}
+};
+
+(function (module) {
+function _instanceof(left, right) {
+    if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) {
+        return !!right[Symbol.hasInstance](left);
+    } else {
+        return left instanceof right;
+    }
+}
+/*!
+ * Toastify js 1.12.0
+ * https://github.com/apvarun/toastify-js
+ * @license MIT licensed
+ *
+ * Copyright (C) 2018 Varun A P
+ */ (function(root, factory) {
+    if (module.exports) {
+        module.exports = factory();
+    } else {
+        root.Toastify = factory();
+    }
+})(commonjsGlobal, function(global) {
+    // Object initialization
+    var Toastify = function Toastify1(options) {
+        // Returning a new init object
+        return new Toastify.lib.init(options);
+    }, // Library version
+    version = "1.12.0";
+    // Set the default global options
+    Toastify.defaults = {
+        oldestFirst: true,
+        text: "Toastify is awesome!",
+        node: undefined,
+        duration: 3000,
+        selector: undefined,
+        callback: function callback() {},
+        destination: undefined,
+        newWindow: false,
+        close: false,
+        gravity: "toastify-top",
+        positionLeft: false,
+        position: "",
+        backgroundColor: "",
+        avatar: "",
+        className: "",
+        stopOnFocus: true,
+        onClick: function onClick() {},
+        offset: {
+            x: 0,
+            y: 0
+        },
+        escapeMarkup: true,
+        ariaLive: "polite",
+        style: {
+            background: ""
+        }
+    };
+    // Defining the prototype of the object
+    Toastify.lib = Toastify.prototype = {
+        toastify: version,
+        constructor: Toastify,
+        // Initializing the object with required parameters
+        init: function init(options) {
+            // Verifying and validating the input object
+            if (!options) {
+                options = {};
+            }
+            // Creating the options object
+            this.options = {};
+            this.toastElement = null;
+            // Validating the options
+            this.options.text = options.text || Toastify.defaults.text; // Display message
+            this.options.node = options.node || Toastify.defaults.node; // Display content as node
+            this.options.duration = options.duration === 0 ? 0 : options.duration || Toastify.defaults.duration; // Display duration
+            this.options.selector = options.selector || Toastify.defaults.selector; // Parent selector
+            this.options.callback = options.callback || Toastify.defaults.callback; // Callback after display
+            this.options.destination = options.destination || Toastify.defaults.destination; // On-click destination
+            this.options.newWindow = options.newWindow || Toastify.defaults.newWindow; // Open destination in new window
+            this.options.close = options.close || Toastify.defaults.close; // Show toast close icon
+            this.options.gravity = options.gravity === "bottom" ? "toastify-bottom" : Toastify.defaults.gravity; // toast position - top or bottom
+            this.options.positionLeft = options.positionLeft || Toastify.defaults.positionLeft; // toast position - left or right
+            this.options.position = options.position || Toastify.defaults.position; // toast position - left or right
+            this.options.backgroundColor = options.backgroundColor || Toastify.defaults.backgroundColor; // toast background color
+            this.options.avatar = options.avatar || Toastify.defaults.avatar; // img element src - url or a path
+            this.options.className = options.className || Toastify.defaults.className; // additional class names for the toast
+            this.options.stopOnFocus = options.stopOnFocus === undefined ? Toastify.defaults.stopOnFocus : options.stopOnFocus; // stop timeout on focus
+            this.options.onClick = options.onClick || Toastify.defaults.onClick; // Callback after click
+            this.options.offset = options.offset || Toastify.defaults.offset; // toast offset
+            this.options.escapeMarkup = options.escapeMarkup !== undefined ? options.escapeMarkup : Toastify.defaults.escapeMarkup;
+            this.options.ariaLive = options.ariaLive || Toastify.defaults.ariaLive;
+            this.options.style = options.style || Toastify.defaults.style;
+            if (options.backgroundColor) {
+                this.options.style.background = options.backgroundColor;
+            }
+            // Returning the current object for chaining functions
+            return this;
+        },
+        // Building the DOM element
+        buildToast: function buildToast() {
+            // Validating if the options are defined
+            if (!this.options) {
+                throw "Toastify is not initialized";
+            }
+            // Creating the DOM object
+            var divElement = document.createElement("div");
+            divElement.className = "toastify on " + this.options.className;
+            // Positioning toast to left or right or center
+            if (!!this.options.position) {
+                divElement.className += " toastify-" + this.options.position;
+            } else {
+                // To be depreciated in further versions
+                if (this.options.positionLeft === true) {
+                    divElement.className += " toastify-left";
+                    console.warn("Property `positionLeft` will be depreciated in further versions. Please use `position` instead.");
+                } else {
+                    // Default position
+                    divElement.className += " toastify-right";
+                }
+            }
+            // Assigning gravity of element
+            divElement.className += " " + this.options.gravity;
+            if (this.options.backgroundColor) {
+                // This is being deprecated in favor of using the style HTML DOM property
+                console.warn('DEPRECATION NOTICE: "backgroundColor" is being deprecated. Please use the "style.background" property.');
+            }
+            // Loop through our style object and apply styles to divElement
+            for(var property in this.options.style){
+                divElement.style[property] = this.options.style[property];
+            }
+            // Announce the toast to screen readers
+            if (this.options.ariaLive) {
+                divElement.setAttribute("aria-live", this.options.ariaLive);
+            }
+            // Adding the toast message/node
+            if (this.options.node && this.options.node.nodeType === Node.ELEMENT_NODE) {
+                // If we have a valid node, we insert it
+                divElement.appendChild(this.options.node);
+            } else {
+                if (this.options.escapeMarkup) {
+                    divElement.innerText = this.options.text;
+                } else {
+                    divElement.innerHTML = this.options.text;
+                }
+                if (this.options.avatar !== "") {
+                    var avatarElement = document.createElement("img");
+                    avatarElement.src = this.options.avatar;
+                    avatarElement.className = "toastify-avatar";
+                    if (this.options.position == "left" || this.options.positionLeft === true) {
+                        // Adding close icon on the left of content
+                        divElement.appendChild(avatarElement);
+                    } else {
+                        // Adding close icon on the right of content
+                        divElement.insertAdjacentElement("afterbegin", avatarElement);
+                    }
+                }
+            }
+            // Adding a close icon to the toast
+            if (this.options.close === true) {
+                // Create a span for close element
+                var closeElement = document.createElement("button");
+                closeElement.type = "button";
+                closeElement.setAttribute("aria-label", "Close");
+                closeElement.className = "toast-close";
+                closeElement.innerHTML = "&#10006;";
+                // Triggering the removal of toast from DOM on close click
+                closeElement.addEventListener("click", (function(event) {
+                    event.stopPropagation();
+                    this.removeElement(this.toastElement);
+                    window.clearTimeout(this.toastElement.timeOutValue);
+                }).bind(this));
+                //Calculating screen width
+                var width = window.innerWidth > 0 ? window.innerWidth : screen.width;
+                // Adding the close icon to the toast element
+                // Display on the right if screen width is less than or equal to 360px
+                if ((this.options.position == "left" || this.options.positionLeft === true) && width > 360) {
+                    // Adding close icon on the left of content
+                    divElement.insertAdjacentElement("afterbegin", closeElement);
+                } else {
+                    // Adding close icon on the right of content
+                    divElement.appendChild(closeElement);
+                }
+            }
+            // Clear timeout while toast is focused
+            if (this.options.stopOnFocus && this.options.duration > 0) {
+                var self = this;
+                // stop countdown
+                divElement.addEventListener("mouseover", function(event) {
+                    window.clearTimeout(divElement.timeOutValue);
+                });
+                // add back the timeout
+                divElement.addEventListener("mouseleave", function() {
+                    divElement.timeOutValue = window.setTimeout(function() {
+                        // Remove the toast from DOM
+                        self.removeElement(divElement);
+                    }, self.options.duration);
+                });
+            }
+            // Adding an on-click destination path
+            if (typeof this.options.destination !== "undefined") {
+                divElement.addEventListener("click", (function(event) {
+                    event.stopPropagation();
+                    if (this.options.newWindow === true) {
+                        window.open(this.options.destination, "_blank");
+                    } else {
+                        window.location = this.options.destination;
+                    }
+                }).bind(this));
+            }
+            if (typeof this.options.onClick === "function" && typeof this.options.destination === "undefined") {
+                divElement.addEventListener("click", (function(event) {
+                    event.stopPropagation();
+                    this.options.onClick();
+                }).bind(this));
+            }
+            // Adding offset
+            if (typeof this.options.offset === "object") {
+                var x = getAxisOffsetAValue("x", this.options);
+                var y = getAxisOffsetAValue("y", this.options);
+                var xOffset = this.options.position == "left" ? x : "-" + x;
+                var yOffset = this.options.gravity == "toastify-top" ? y : "-" + y;
+                divElement.style.transform = "translate(" + xOffset + "," + yOffset + ")";
+            }
+            // Returning the generated element
+            return divElement;
+        },
+        // Displaying the toast
+        showToast: function showToast() {
+            // Creating the DOM object for the toast
+            this.toastElement = this.buildToast();
+            // Getting the root element to with the toast needs to be added
+            var rootElement;
+            if (typeof this.options.selector === "string") {
+                rootElement = document.getElementById(this.options.selector);
+            } else if (_instanceof(this.options.selector, HTMLElement) || typeof ShadowRoot !== "undefined" && _instanceof(this.options.selector, ShadowRoot)) {
+                rootElement = this.options.selector;
+            } else {
+                rootElement = document.body;
+            }
+            // Validating if root element is present in DOM
+            if (!rootElement) {
+                throw "Root element is not defined";
+            }
+            // Adding the DOM element
+            var elementToInsert = Toastify.defaults.oldestFirst ? rootElement.firstChild : rootElement.lastChild;
+            rootElement.insertBefore(this.toastElement, elementToInsert);
+            // Repositioning the toasts in case multiple toasts are present
+            Toastify.reposition();
+            if (this.options.duration > 0) {
+                this.toastElement.timeOutValue = window.setTimeout((function() {
+                    // Remove the toast from DOM
+                    this.removeElement(this.toastElement);
+                }).bind(this), this.options.duration); // Binding `this` for function invocation
+            }
+            // Supporting function chaining
+            return this;
+        },
+        hideToast: function hideToast() {
+            if (this.toastElement.timeOutValue) {
+                clearTimeout(this.toastElement.timeOutValue);
+            }
+            this.removeElement(this.toastElement);
+        },
+        // Removing the element from the DOM
+        removeElement: function removeElement(toastElement) {
+            // Hiding the element
+            // toastElement.classList.remove("on");
+            toastElement.className = toastElement.className.replace(" on", "");
+            // Removing the element from DOM after transition end
+            window.setTimeout((function() {
+                // remove options node if any
+                if (this.options.node && this.options.node.parentNode) {
+                    this.options.node.parentNode.removeChild(this.options.node);
+                }
+                // Remove the element from the DOM, only when the parent node was not removed before.
+                if (toastElement.parentNode) {
+                    toastElement.parentNode.removeChild(toastElement);
+                }
+                // Calling the callback function
+                this.options.callback.call(toastElement);
+                // Repositioning the toasts again
+                Toastify.reposition();
+            }).bind(this), 400); // Binding `this` for function invocation
+        }
+    };
+    // Positioning the toasts on the DOM
+    Toastify.reposition = function() {
+        // Top margins with gravity
+        var topLeftOffsetSize = {
+            top: 15,
+            bottom: 15
+        };
+        var topRightOffsetSize = {
+            top: 15,
+            bottom: 15
+        };
+        var offsetSize = {
+            top: 15,
+            bottom: 15
+        };
+        // Get all toast messages on the DOM
+        var allToasts = document.getElementsByClassName("toastify");
+        var classUsed;
+        // Modifying the position of each toast element
+        for(var i = 0; i < allToasts.length; i++){
+            // Getting the applied gravity
+            if (containsClass(allToasts[i], "toastify-top") === true) {
+                classUsed = "toastify-top";
+            } else {
+                classUsed = "toastify-bottom";
+            }
+            var height = allToasts[i].offsetHeight;
+            classUsed = classUsed.substr(9, classUsed.length - 1);
+            // Spacing between toasts
+            var offset = 15;
+            var width = window.innerWidth > 0 ? window.innerWidth : screen.width;
+            // Show toast in center if screen with less than or equal to 360px
+            if (width <= 360) {
+                // Setting the position
+                allToasts[i].style[classUsed] = offsetSize[classUsed] + "px";
+                offsetSize[classUsed] += height + offset;
+            } else {
+                if (containsClass(allToasts[i], "toastify-left") === true) {
+                    // Setting the position
+                    allToasts[i].style[classUsed] = topLeftOffsetSize[classUsed] + "px";
+                    topLeftOffsetSize[classUsed] += height + offset;
+                } else {
+                    // Setting the position
+                    allToasts[i].style[classUsed] = topRightOffsetSize[classUsed] + "px";
+                    topRightOffsetSize[classUsed] += height + offset;
+                }
+            }
+        }
+        // Supporting function chaining
+        return this;
+    };
+    // Helper function to get offset.
+    function getAxisOffsetAValue(axis, options) {
+        if (options.offset[axis]) {
+            if (isNaN(options.offset[axis])) {
+                return options.offset[axis];
+            } else {
+                return options.offset[axis] + "px";
+            }
+        }
+        return "0px";
+    }
+    function containsClass(elem, yourClass) {
+        if (!elem || typeof yourClass !== "string") {
+            return false;
+        } else if (elem.className && elem.className.trim().split(/\s+/gi).indexOf(yourClass) > -1) {
+            return true;
+        } else {
+            return false;
+        }
+    }
+    // Setting up the prototype for the init object
+    Toastify.lib.init.prototype = Toastify.lib;
+    // Returning the Toastify function to be assigned to the window object/module
+    return Toastify;
+});
+}(toastify$1));
+
+var toastify = toastify$1.exports;
+
+const blocksLegacy = [
+    {
+        type: 'object',
+        message0: '{ %1 %2 }',
+        args0: [
+            {
+                type: 'input_dummy'
+            },
+            {
+                type: 'input_statement',
+                name: 'MEMBERS',
+                check: 'MEMBER'
+            }
+        ],
+        output: null,
+        colour: '#48c6be'
+    },
+    {
+        type: 'array',
+        message0: '[ %1 %2 ]',
+        args0: [
+            {
+                type: 'input_dummy'
+            },
+            {
+                type: 'input_statement',
+                name: 'MEMBERS',
+                check: 'ARRAY_INPUT'
+            }
+        ],
+        output: null,
+        colour: '#48c6be'
+    },
+    {
+        type: 'member',
+        message0: '%1 %2 %3',
+        args0: [
+            {
+                type: 'field_input',
+                name: 'MEMBER_NAME',
+                text: ''
+            },
+            {
+                type: 'field_label',
+                name: 'COLON',
+                text: ':'
+            },
+            {
+                type: 'input_value',
+                name: 'MEMBER_VALUE'
+            }
+        ],
+        previousStatement: 'MEMBER',
+        nextStatement: 'MEMBER',
+        colour: '#35b3ab'
+    },
+    {
+        type: 'array-input',
+        message0: '%1',
+        args0: [
+            {
+                type: 'input_value',
+                name: 'MEMBER_VALUE'
+            }
+        ],
+        previousStatement: 'ARRAY_INPUT',
+        nextStatement: 'ARRAY_INPUT',
+        colour: '#35b3ab'
+    },
+    {
+        type: 'unknown-pins',
+        message0: 'unknown-pins',
+        args0: [],
+        colour: 0,
+        inputsInline: false,
+        previousStatement: null,
+        nextStatement: null
+    },
+    {
+        type: 'unknown-format',
+        message0: 'unknown-format',
+        args0: [],
+        output: null,
+        colour: 0
+    },
+    {
+        type: 'unknown-component',
+        message0: 'unknown-component',
+        args0: [],
+        output: null,
+        colour: 0
+    },
+    {
+        type: 'generic-scene-block',
+        message0: 'Error - Generic Scene Block',
+        arg0: [],
+        message1: 'type = %1',
+        args1: [
+            {
+                type: 'field_input',
+                name: 'SCENE_TYPE',
+                text: 'default-type'
+            }
+        ],
+        message2: '%1 %2',
+        args2: [
+            {
+                type: 'field_label_serializable',
+                name: 'NAME_EXECUTE',
+                text: 'Execute*'
+            },
+            {
+                type: 'input_statement',
+                name: 'EXECUTE_PINS'
+            }
+        ],
+        message3: '%1 %2',
+        args3: [
+            {
+                type: 'field_label_serializable',
+                name: 'NAME_METADATA',
+                text: 'Metadata'
+            },
+            {
+                type: 'input_value',
+                name: 'METADATA_INPUT'
+            }
+        ],
+        message4: '%1 %2',
+        args4: [
+            {
+                type: 'field_label_serializable',
+                name: 'NAME_EVENTS',
+                text: 'Events'
+            },
+            {
+                type: 'input_value',
+                name: 'EVENTS_INPUT'
+            }
+        ],
+        colour: 0,
+        tooltip: '',
+        helpUrl: ''
+    }
+];
+
+let libraries;
+function initializeWorkspaceFromPinsAndLibraries(pinsSettings, workspace, librariesToLoad) {
+    workspace.clear();
+    libraries = librariesToLoad;
+    generateSceneBlock(pinsSettings, workspace);
+}
+function generateSceneBlock(pinsSettings, workspace) {
+    var _sceneBlock_getInput;
+    let sceneBlockName = '';
+    let sceneBlockLibrary = '';
+    let hasSceneBlock = false;
+    sceneBlockName = '/' + pinsSettings.element;
+    sceneBlockLibrary = pinsSettings.library;
+    const foundLibrary = libraries.find((library)=>library.info.title === sceneBlockLibrary);
+    hasSceneBlock = foundLibrary && foundLibrary['x-scene-blocks'] && Object.hasOwnProperty.call(foundLibrary['x-scene-blocks'], sceneBlockName);
+    let sceneBlock;
+    if (hasSceneBlock) {
+        //generating scene block
+        const sceneBlockId = sceneBlockLibrary + '/__SCENEBLOCK__' + sceneBlockName;
+        sceneBlock = workspace.newBlock(sceneBlockId);
+        if (sceneBlock.mutator) {
+            sceneBlock.itemList_ = itemListFromSceneSettings(pinsSettings, foundLibrary['x-scene-blocks'][sceneBlockName]);
+            sceneBlock.updateShape_();
+        }
+        sceneBlock.moveBy(20, 20);
+        sceneBlock.initSvg();
+        sceneBlock.render();
+        if (pinsSettings.metadata) {
+            for (const [metadataKey, metadataValue] of Object.entries(pinsSettings.metadata)){
+                const inputName = 'metadata--' + metadataKey;
+                if (sceneBlock.getInput(inputName)) {
+                    var _foundLibrary_xsceneblocks_sceneBlockName_metadata;
+                    const parameter = (_foundLibrary_xsceneblocks_sceneBlockName_metadata = foundLibrary['x-scene-blocks'][sceneBlockName].metadata) == null ? void 0 : _foundLibrary_xsceneblocks_sceneBlockName_metadata.find((p)=>p.name === metadataKey);
+                    if (parameter) {
+                        if (parameter.schema.type === 'array' && parameter.schema.items.$ref) {
+                            const parameterType = getParameterType(parameter.schema.items);
+                            for (const componentSettings of metadataValue.reverse()){
+                                const componentBlock = parameterType === 'component' ? generateBlockFromComponent(componentSettings, workspace, foundLibrary, parameter.schema.items.$ref) : generateBlockFromPins(componentSettings, workspace);
+                                const sceneInputConnection = sceneBlock.getInput(inputName).connection;
+                                connectBlock(componentBlock, sceneInputConnection);
+                            }
+                        } else {
+                            const metadataBlock = generateParameterBlock(parameter.schema, metadataValue, workspace, foundLibrary);
+                            const sceneInputConnection = sceneBlock.getInput(inputName).connection;
+                            connectBlock(metadataBlock, sceneInputConnection);
+                        }
+                    } else {
+                        console.log(`[generateSceneBlock] - Aucun metadata nommé "${inputName}" trouvé dans les métadonnées de "${sceneBlockName}".`);
+                    }
+                } else {
+                    console.log(`[generateSceneBlock] - Le bloc "${sceneBlockId}" n'a pas d'entrée metadata nommée "${inputName}" mais son format JSON semble en avoir une, une perte de donnée est possible si vous sauvegardez sans mettre à jour la librarie "${sceneBlockLibrary}"`);
+                }
+            }
+        }
+        if (pinsSettings.properties) {
+            for (const [key, value] of Object.entries(pinsSettings.properties)){
+                const inputName = key;
+                if (sceneBlock.getInput(inputName)) {
+                    var _foundLibrary_xsceneblocks_sceneBlockName_parameters;
+                    const parameter = (_foundLibrary_xsceneblocks_sceneBlockName_parameters = foundLibrary['x-scene-blocks'][sceneBlockName].parameters) == null ? void 0 : _foundLibrary_xsceneblocks_sceneBlockName_parameters.find((p)=>p.name === inputName);
+                    if (parameter) {
+                        if (parameter.schema.type === 'array' && parameter.schema.items.$ref) {
+                            const parameterType = getParameterType(parameter.schema.items);
+                            for (const componentSettings of value.reverse()){
+                                const componentBlock = parameterType === 'component' ? generateBlockFromComponent(componentSettings, workspace, foundLibrary, parameter.schema.items.$ref) : generateBlockFromPins(componentSettings, workspace);
+                                const sceneInputConnection = sceneBlock.getInput(inputName).connection;
+                                connectBlock(componentBlock, sceneInputConnection);
+                            }
+                        } else {
+                            const metadataBlock = generateParameterBlock(parameter.schema, value, workspace, foundLibrary);
+                            const sceneInputConnection = sceneBlock.getInput(inputName).connection;
+                            connectBlock(metadataBlock, sceneInputConnection);
+                        }
+                    } else {
+                        console.log(`[generateSceneBlock] - Aucun paramètre nommé "${inputName}" trouvé dans les métadonnées de "${sceneBlockName}".`);
+                    }
+                } else {
+                    console.log(`[generateSceneBlock] - Le bloc "${sceneBlockId}" n'a pas d'entrée parameters nommée "${inputName}" mais son format JSON semble en avoir une, une perte de donnée est possible si vous sauvegardez sans mettre à jour la librarie "${sceneBlockLibrary}"`);
+                }
+            }
+        }
+    } else {
+        //generating generic debug scene block
+        console.log('[generateSceneBlock] - Scene missing type or not existing in library ', sceneBlockLibrary);
+        sceneBlock = workspace.newBlock('generic-scene-block');
+        sceneBlock.initSvg();
+        const typeValue = pinsSettings && pinsSettings.type ? pinsSettings.type : 'null';
+        sceneBlock.setFieldValue(typeValue, 'SCENE_TYPE');
+        const metadataValue = pinsSettings && pinsSettings.metadata ? pinsSettings.metadata : null;
+        const metadataBlock = generateBlockFromJson(metadataValue, workspace);
+        const sceneInputConnection = sceneBlock.getInput('METADATA_INPUT').connection;
+        connectBlock(metadataBlock, sceneInputConnection);
+    }
+    const pinsConnection = (_sceneBlock_getInput = sceneBlock.getInput('EXECUTE_PINS')) == null ? void 0 : _sceneBlock_getInput.connection;
+    if (pinsConnection) {
+        const reversedPins = [
+            ...pinsSettings.pins || []
+        ].reverse();
+        for (const pinsSetting of reversedPins){
+            const pinsBlock = generateBlockFromPins(pinsSetting, workspace);
+            connectBlock(pinsBlock, pinsConnection);
+        }
+    }
+    sceneBlock.render();
+    return sceneBlock;
+}
+function generateBlockFromPins(pinsSettings, workspace) {
+    var _library_paths_;
+    const blockPath = pinsSettings.library + '/__PINS__/' + pinsSettings.element;
+    const library = getLibraryFromName(pinsSettings.library);
+    if (!library) {
+        const pinsBlock = workspace.newBlock('unknown-pins');
+        console.log('[generateBlockFromPins] - Library not loaded', pinsSettings.library);
+        pinsBlock.initSvg();
+        pinsBlock.render();
+        return pinsBlock;
+    }
+    const pinsDefinition = (_library_paths_ = library.paths['/' + pinsSettings.element]) == null ? void 0 : _library_paths_.post;
+    if (!pinsDefinition) {
+        const pinsBlock = workspace.newBlock('unknown-pins');
+        console.log('[generateBlockFromPins] - Pins not existing in library', pinsSettings.element, pinsSettings.library);
+        pinsBlock.initSvg();
+        pinsBlock.render();
+        return pinsBlock;
+    }
+    const pinsBlock = workspace.newBlock(blockPath);
+    if (pinsBlock.mutator) {
+        pinsBlock.itemList_ = itemListFromPinsSettings(pinsSettings, pinsDefinition);
+        pinsBlock.updateShape_();
+    }
+    pinsBlock.initSvg();
+    pinsBlock.render();
+    if (library.paths['/' + pinsSettings.element].post.tags && library.paths['/' + pinsSettings.element].post.tags.includes('needPins')) {
+        const pinsConnection = pinsBlock.getInput('pins').connection;
+        const reversedPins = [
+            ...pinsSettings.pins || []
+        ].reverse();
+        for (const pinsSetting of reversedPins){
+            const pinsBlock = generateBlockFromPins(pinsSetting, workspace);
+            connectBlock(pinsBlock, pinsConnection);
+        }
+    }
+    if (!pinsSettings || !pinsSettings.properties) {
+        return pinsBlock;
+    }
+    for (const parameter of pinsDefinition.parameters){
+        if (!Object.prototype.hasOwnProperty.call(pinsSettings.properties, parameter.name)) {
+            continue;
+        }
+        const valueToLoad = pinsSettings.properties[parameter.name];
+        if (parameter.schema.type === 'array' && parameter.schema.items.$ref) {
+            const parameterType = getParameterType(parameter.schema.items);
+            for (const propertyValue of valueToLoad.reverse()){
+                const parameterBlock = parameterType === 'component' ? generateBlockFromComponent(propertyValue, workspace, library, parameter.schema.items.$ref) : generateBlockFromPins(propertyValue, workspace);
+                const sceneInputConnection = pinsBlock.getInput(parameter.name).connection;
+                connectBlock(parameterBlock, sceneInputConnection);
+            }
+        } else {
+            const parameterBlock = generateParameterBlock(parameter.schema, valueToLoad, workspace, library);
+            const sceneInputConnection = pinsBlock.getInput(parameter.name).connection;
+            connectBlock(parameterBlock, sceneInputConnection);
+        }
+    }
+    for (const event of pinsDefinition['x-events']){
+        if (!pinsSettings.events || !Object.prototype.hasOwnProperty.call(pinsSettings.events, event.name)) {
+            continue;
+        }
+        const valueToLoad = pinsSettings.events[event.name];
+        for (const propertyValue of valueToLoad.reverse()){
+            const parameterBlock = generateBlockFromPins(propertyValue, workspace);
+            const inputConnection = pinsBlock.getInput('__EVENT__/' + event.name).connection;
+            connectBlock(parameterBlock, inputConnection);
+        }
+    }
+    return pinsBlock;
+}
+function generateBlockFromComponent(componentSettings, workspace, library, component$ref) {
+    const componentName = component$ref.split('/').pop();
+    const blockPath = library.info.title + '/__COMPONENTS__/' + componentName;
+    const componentDefinition = library.components.schemas[componentName];
+    if (!componentDefinition) {
+        const componentBlock = workspace.newBlock('unknown-component');
+        componentBlock.initSvg();
+        componentBlock.render();
+        return componentBlock;
+    }
+    const componentBlock = workspace.newBlock(blockPath);
+    if (componentBlock.mutator) {
+        componentBlock.itemList_ = itemListFromComponentSettings(componentSettings, componentDefinition);
+        componentBlock.updateShape_();
+    }
+    componentBlock.initSvg();
+    componentBlock.render();
+    for (const [propertyKey, schema] of Object.entries(componentDefinition.properties)){
+        if (!Object.prototype.hasOwnProperty.call(componentSettings, propertyKey)) {
+            continue;
+        }
+        const valueToLoad = componentSettings[propertyKey];
+        if (schema.type === 'array' && schema.items.$ref) {
+            const parameterType = getParameterType(schema.items);
+            for (const propertyValue of valueToLoad.reverse()){
+                const parameterBlock = parameterType === 'component' ? generateBlockFromComponent(propertyValue, workspace, library, schema.items.$ref) : generateBlockFromPins(propertyValue, workspace);
+                const sceneInputConnection = componentBlock.getInput(propertyKey).connection;
+                connectBlock(parameterBlock, sceneInputConnection);
+            }
+        } else {
+            const parameterBlock = generateParameterBlock(schema, valueToLoad, workspace, library);
+            const sceneInputConnection = componentBlock.getInput(propertyKey).connection;
+            connectBlock(parameterBlock, sceneInputConnection);
+        }
+    }
+    componentBlock.render();
+    return componentBlock;
+}
+function generateParameterBlock(schema, valueToLoad, workspace, library) {
+    if (valueToLoad === undefined) {
+        return;
+    }
+    const parameterType = typeof valueToLoad === 'string' ? 'string' : getParameterType(schema);
+    let arrayInputConnection;
+    let paramBlock;
+    switch(parameterType){
+        case 'string':
+            paramBlock = workspace.newBlock('text_multiline');
+            if (valueToLoad === undefined) {
+                console.log(`[getParameterType] - valueToLoad is undefined in case string`);
+                break;
+            }
+            paramBlock.setFieldValue(valueToLoad, 'TEXT');
+            break;
+        case 'number':
+            paramBlock = workspace.newBlock('math_number');
+            if (valueToLoad === undefined) {
+                console.log(`[getParameterType] - valueToLoad is undefined in case number`);
+                break;
+            }
+            paramBlock.getField('NUM').setValue(valueToLoad);
+            break;
+        case 'boolean':
+            paramBlock = workspace.newBlock('logic_boolean');
+            if (valueToLoad === true) {
+                paramBlock.getField('BOOL').setValue('TRUE');
+            } else if (valueToLoad === false) {
+                paramBlock.getField('BOOL').setValue('FALSE');
+            } else {
+                console.log(`[getParameterType] - valueToLoad is undefined in case boolean`);
+                break;
+            }
+            break;
+        case 'array':
+            paramBlock = workspace.newBlock('array');
+            paramBlock.initSvg();
+            paramBlock.render();
+            arrayInputConnection = paramBlock.getInput('MEMBERS').connection;
+            for(let key = valueToLoad.length - 1; key >= 0; key--){
+                const memberBlock = workspace.newBlock('array-input');
+                memberBlock.initSvg();
+                memberBlock.render();
+                const parentConnection = memberBlock.getInput('MEMBER_VALUE').connection;
+                const newBlock = generateParameterBlock(schema.items, valueToLoad[key], workspace, library);
+                connectBlock(newBlock, parentConnection);
+                memberBlock.initSvg();
+                memberBlock.render();
+                connectBlock(memberBlock, arrayInputConnection);
+            }
+            break;
+        case 'component':
+            paramBlock = generateBlockFromComponent(valueToLoad, workspace, library, schema.$ref);
+            break;
+        case 'pins':
+            paramBlock = generateBlockFromPins(valueToLoad, workspace);
+            break;
+        case 'object':
+            paramBlock = generateBlockFromJson(valueToLoad, workspace);
+            break;
+        default:
+            paramBlock = workspace.newBlock('unknown-format');
+            break;
+    }
+    return paramBlock;
+}
+function getParameterType(schema) {
+    let typeToReturn = 'unknown-type';
+    const basicTypes = [
+        'string',
+        'number',
+        'boolean',
+        'array',
+        'object'
+    ];
+    if (schema !== null && typeof schema !== 'undefined') {
+        if (Object.prototype.hasOwnProperty.call(schema, 'type')) {
+            if (basicTypes.includes(schema.type)) {
+                typeToReturn = schema.type;
+            }
+        } else if (Object.prototype.hasOwnProperty.call(schema, '$ref')) {
+            if (schema.$ref.includes('#/components/schemas/')) {
+                typeToReturn = 'component';
+            } else typeToReturn = 'pins';
+        }
+    }
+    return typeToReturn;
+}
+function getLibraryFromName(name) {
+    const library = libraries.find((library)=>library.info.title === name);
+    return library;
+}
+function connectBlock(targetBlock, parentConnection) {
+    if (parentConnection) {
+        const childConnection = (targetBlock == null ? void 0 : targetBlock.outputConnection) || (targetBlock == null ? void 0 : targetBlock.previousConnection);
+        parentConnection.connect(childConnection);
+    }
+    targetBlock == null ? void 0 : targetBlock.initSvg();
+    targetBlock == null ? void 0 : targetBlock.render();
+}
+function generateBlockFromJson(json_structure, workspace) {
+    if (json_structure === null) {
+        const targetBlock = workspace.newBlock('logic_null');
+        return targetBlock;
+    }
+    const type = typeof json_structure;
+    let targetBlock;
+    let memberInputConnection;
+    switch(type){
+        case 'string':
+            targetBlock = workspace.newBlock('text_multiline');
+            targetBlock.setFieldValue(json_structure, 'TEXT');
+            break;
+        case 'number':
+            targetBlock = workspace.newBlock('math_number');
+            targetBlock.setFieldValue(String(json_structure), 'NUM');
+            break;
+        case 'boolean':
+            targetBlock = workspace.newBlock('logic_boolean');
+            targetBlock.setFieldValue(json_structure ? 'TRUE' : 'FALSE', 'BOOL');
+            break;
+        case 'object':
+            if (Array.isArray(json_structure)) {
+                targetBlock = workspace.newBlock('array');
+                targetBlock.initSvg();
+                targetBlock.render();
+                memberInputConnection = targetBlock.getInput('MEMBERS').connection;
+                for(let key = json_structure.length - 1; key >= 0; key--){
+                    const memberBlock = workspace.newBlock('array-input');
+                    memberBlock.initSvg();
+                    memberBlock.render();
+                    const parentConnection = memberBlock.getInput('MEMBER_VALUE').connection;
+                    const newBlock = generateBlockFromJson(json_structure[key], workspace);
+                    connectBlock(newBlock, parentConnection);
+                    memberBlock.initSvg();
+                    memberBlock.render();
+                    connectBlock(memberBlock, memberInputConnection);
+                }
+            } else {
+                targetBlock = workspace.newBlock('object');
+                targetBlock.initSvg();
+                targetBlock.render();
+                memberInputConnection = targetBlock.getInput('MEMBERS').connection;
+                const keys = Object.keys(json_structure);
+                for(let key = keys.length - 1; key >= 0; key--){
+                    const memberBlock = workspace.newBlock('member');
+                    memberBlock.setFieldValue(keys[key], 'MEMBER_NAME');
+                    memberBlock.initSvg();
+                    memberBlock.render();
+                    const parentConnection = memberBlock.getInput('MEMBER_VALUE').connection;
+                    const newBlock = generateBlockFromJson(json_structure[keys[key]], workspace);
+                    connectBlock(newBlock, parentConnection);
+                    memberBlock.initSvg();
+                    memberBlock.render();
+                    connectBlock(memberBlock, memberInputConnection);
+                }
+            }
+            break;
+    }
+    return targetBlock;
+}
+function itemListFromPinsSettings(pinsSettings, pinsDefinition) {
+    const inputArray = [];
+    if (!pinsSettings || !pinsDefinition) {
+        console.log('[itemListFromPinsSettings] - Undefined pinsSettings or pinsDefinition');
+        return inputArray;
+    }
+    if (pinsDefinition.parameters && pinsSettings.properties) {
+        for (const parameter of pinsDefinition.parameters){
+            if (!Object.prototype.hasOwnProperty.call(pinsSettings.properties, parameter.name)) {
+                continue;
+            }
+            inputArray.push({
+                id: parameter.name,
+                name: parameter.summary || parameter.name
+            });
+        }
+    }
+    if (pinsDefinition.tags && pinsDefinition.tags.includes('needPins')) {
+        inputArray.push({
+            id: 'pins',
+            name: 'pins'
+        });
+    }
+    if (pinsDefinition['x-events'] && pinsSettings.events) {
+        for (const event of pinsDefinition['x-events']){
+            if (!Object.prototype.hasOwnProperty.call(pinsSettings.events, event.name)) {
+                continue;
+            }
+            inputArray.push({
+                id: '__EVENT__/' + event.name,
+                name: '@' + (event.summary || event.name)
+            });
+        }
+    }
+    return inputArray;
+}
+function itemListFromComponentSettings(componentSettings, componentDefinition) {
+    const inputArray = [];
+    for (const [propertyKey, _propertyValue] of Object.entries(componentDefinition.properties)){
+        if (!Object.prototype.hasOwnProperty.call(componentSettings, propertyKey)) {
+            continue;
+        }
+        inputArray.push({
+            id: propertyKey,
+            name: propertyKey
+        });
+    }
+    return inputArray;
+}
+function itemListFromSceneSettings(sceneSettings, sceneDefinition) {
+    const inputArray = [];
+    if (sceneDefinition.parameters && sceneSettings.properties) {
+        for (const parameter of sceneDefinition.parameters){
+            if (!Object.prototype.hasOwnProperty.call(sceneSettings.properties, parameter.name)) {
+                continue;
+            }
+            inputArray.push({
+                id: parameter.name,
+                name: parameter.name
+            });
+        }
+    }
+    return inputArray;
+}
+
+const Toastify$1 = toastify;
+const BASE_URL = 'https://cdn.jsdelivr.net/npm';
+const BLOCKLY_VERSION = '10.4.3';
+let jsonGenerator, generateBlocklyBlockFromLibraries, generateToolboxFromLibraries, initializeMutator;
+class GenericSceneElement extends s {
+    createRenderRoot() {
+        return this;
+    }
+    connectedCallback() {
+        super.connectedCallback();
+        this.initialize();
+    }
+    async initialize() {
+        const link = document.createElement('link');
+        link.rel = 'stylesheet';
+        link.href = `${BASE_URL}/toastify-js/src/toastify.min.css`;
+        link.type = 'text/css';
+        document.head.appendChild(link);
+        let script, promise;
+        script = document.createElement('script');
+        script.src = `${BASE_URL}/blockly@${BLOCKLY_VERSION}/blockly_compressed.js`;
+        promise = new Promise((resolve)=>{
+            script.onload = resolve;
+        });
+        document.head.appendChild(script);
+        await promise;
+        script = document.createElement('script');
+        script.src = `${BASE_URL}/blockly@${BLOCKLY_VERSION}/blocks_compressed.js`;
+        promise = new Promise((resolve)=>{
+            script.onload = resolve;
+        });
+        document.head.appendChild(script);
+        await promise;
+        script = document.createElement('script');
+        script.src = `${BASE_URL}/blockly@${BLOCKLY_VERSION}/msg/en.js`;
+        promise = new Promise((resolve)=>{
+            script.onload = resolve;
+        });
+        document.head.appendChild(script);
+        await promise;
+        const blocklyToJson = await import('./blockly-to-json.esm.js');
+        jsonGenerator = blocklyToJson.jsonGenerator;
+        const pinsToBlockly = await import('./pins-to-blockly.esm.js');
+        generateBlocklyBlockFromLibraries = pinsToBlockly.generateBlocklyBlockFromLibraries;
+        generateToolboxFromLibraries = pinsToBlockly.generateToolboxFromLibraries;
+        initializeMutator = pinsToBlockly.initializeMutator;
+        setTimeout(()=>this.loadScene(this.digipair, this.reasoning), 1);
+        this.addEventListener('setReasoning', ({ detail })=>this.loadReasoning(detail));
+    }
+    loadReasoning(detail) {
+        const scene = _extends({}, detail, {
+            properties: _extends({}, (detail.properties.trigger || []).reduce((acc, { name, value })=>_extends({}, acc, {
+                    [name]: value
+                }), {}), {
+                actions: detail.properties.actions.map((action)=>{
+                    var _action_properties;
+                    return _extends({}, action, {
+                        properties: (_action_properties = action.properties) == null ? void 0 : _action_properties.reduce((acc, { name, value })=>_extends({}, acc, {
+                                [name]: value
+                            }), {})
+                    });
+                }),
+                conditions: detail.properties.conditions.map((action)=>{
+                    var _action_properties;
+                    return _extends({}, action, {
+                        properties: (_action_properties = action.properties) == null ? void 0 : _action_properties.reduce((acc, { name, value })=>_extends({}, acc, {
+                                [name]: value
+                            }), {})
+                    });
+                }),
+                pins: []
+            })
+        });
+        Blockly.Events.disable();
+        initializeWorkspaceFromPinsAndLibraries(scene, this.workspace, this.librariesToLoad);
+        Blockly.Events.enable();
+    }
+    async getReasoning(digipair, reasoning) {
+        const response = await fetch(`${window.origin}/admin/reasoning-read`, {
+            headers: {
+                'content-type': 'application/json'
+            },
+            body: JSON.stringify({
+                digipair,
+                reasoning
+            }),
+            method: 'POST'
+        });
+        const content = await response.json();
+        return content;
+    }
+    async getLibraries(libraries) {
+        const list = await Promise.all(Object.keys(libraries).map(async (library, i)=>// fetch(`${BASE_URL}/${library}@${libraries[library]}/schema.json`).then(res => res.json()),
+            // @todo: to replace
+            fetch(`http://localhost:4000/${library.split('/')[1]}/schema.json`).then((res)=>res.json())));
+        return list;
+    }
+    async loadScene(digipair, reasoning) {
+        this.reasoningData = await this.getReasoning(digipair, reasoning);
+        const scene = this.reasoningData.content;
+        this.librariesToLoad = await this.getLibraries(this.reasoningData.libraries);
+        this.loadBlockly(scene);
+        if (!scene) {
+            return;
+        }
+        this.canSave = this.verifyCanSaveAndGetCode();
+    }
+    verifyCanSaveAndGetCode() {
+        const code = jsonGenerator.workspaceToCode(this.workspace);
+        try {
+            this.codeInWorkspace = _extends({
+                type: this.reasoningData.content.type,
+                name: this.reasoning,
+                description: this.reasoningData.content.description
+            }, JSON.parse(code));
+            return true;
+        } catch (e) {
+            return false;
+        }
+    }
+    async saveScene() {
+        if (this.canSave == true) {
+            this.dispatchEvent(new CustomEvent('save', {
+                detail: {
+                    digipair: this.digipair,
+                    reasoning: this.reasoning,
+                    value: this.codeInWorkspace
+                }
+            }));
+        } else {
+            Toastify$1({
+                text: 'Your scene cannot be saved, invalid format',
+                position: 'center',
+                style: {
+                    'font-family': 'Arial, Helvetica, sans- serif',
+                    background: 'linear-gradient(90deg, rgba(121,9,9,1) 0%, rgba(203,62,62,1) 100%)'
+                },
+                duration: 3000
+            }).showToast();
+        }
+    }
+    loadBlockly(scene) {
+        initializeMutator();
+        const generatedBlocks = generateBlocklyBlockFromLibraries(this.librariesToLoad, blocksLegacy);
+        this.blocks = Blockly.common.createBlockDefinitionsFromJsonArray(generatedBlocks);
+        this.toolbox = generateToolboxFromLibraries(this.librariesToLoad);
+        Blockly.common.defineBlocks(this.blocks);
+        const container = this.renderRoot.querySelector('[data-scene]');
+        this.workspace = Blockly.inject(container, {
+            toolbox: this.toolbox,
+            scrollbars: true,
+            infiniteBlocks: true,
+            trashcan: false,
+            move: {
+                scrollbars: true,
+                drag: true,
+                wheel: true
+            }
+        });
+        this.workspace.addChangeListener((e)=>{
+            if (e.isUiEvent || e.type == Blockly.Events.FINISHED_LOADING) {
+                return;
+            }
+            if (this.workspace.isDragging()) {
+                return;
+            }
+            this.canSave = this.verifyCanSaveAndGetCode();
+        });
+        Blockly.Events.disable();
+        initializeWorkspaceFromPinsAndLibraries(scene, this.workspace, this.librariesToLoad);
+        Blockly.Events.enable();
+    }
+    render() {
+        return x`
+    <style>
+      .blocklyToolboxDiv {
+        background-color: #09121d;
+        color: white;
+        width: 370px;
+      }
+
+      .header {
+        position: unset !important;
+      }
+
+      .menu-item > a::after {
+        content: '> ';
+        margin-left: 30px;
+      }
+
+      .header__logo {
+        margin-left: 80px;
+      }
+
+      .header .main-nav {
+        position: unset;
+        margin-top: 50px;
+        margin-left: 60px;
+      }
+
+      .header .container {
+        margin: 0;
+      }
+
+      .blocklyTreeRow {
+        height: 30px;
+        line-height: 30px;
+      }
+    </style>
+
+    <link href="https://fonts.googleapis.com/icon?family=Material+Icons" rel="stylesheet" />
+    <div>
+      <div style="position: fixed; top: 0; right: 0; bottom: 0; left: 0;" data-scene></div>
+      <div 
+        style ="position: absolute;
+          top: 24px;
+          right: 24px;
+          border-radius: 100%;
+          color: #fff;
+          width: 56px;
+          height: 56px;
+          line-height: 56px;
+          box-shadow: 0 1px 4px rgba(0, 0, 0, 0.4);
+          transition: box-shadow 0.3s ease-in-out;
+          text-align: center;
+          font-weight: 500;
+          background-color:${this.canSave ? '#12b5cd' : '#5F5F5F'} ;
+          cursor: pointer;"
+        class="material-icons"
+        aria-hidden="true"
+        @click=${()=>this.saveScene()}>save</div>
+      </div>
+    </div>
+   `;
+    }
+    constructor(...args){
+        super(...args);
+        this.canSave = false;
+    }
+}
+__decorate([
+    n(),
+    __metadata("design:type", String)
+], GenericSceneElement.prototype, "digipair", void 0);
+__decorate([
+    n(),
+    __metadata("design:type", String)
+], GenericSceneElement.prototype, "reasoning", void 0);
+__decorate([
+    r()
+], GenericSceneElement.prototype, "canSave", void 0);
+GenericSceneElement = __decorate([
+    t('digipair-editor')
+], GenericSceneElement);
+
+const Toastify = toastify;
+let EditorService = class EditorService {
+    async information(params, _pinsSettingsList, _context) {
+        const { message } = params;
+        Toastify({
+            text: message,
+            position: 'center',
+            style: {
+                'font-family': 'Arial, Helvetica, sans- serif',
+                background: 'linear-gradient(90deg, rgba(7,99,101,1) 0%, rgba(4,129,58,1) 100%)'
+            },
+            duration: 3000
+        }).showToast();
+    }
+    async error(params, _pinsSettingsList, _context) {
+        const { message } = params;
+        Toastify({
+            text: message,
+            position: 'center',
+            style: {
+                'font-family': 'Arial, Helvetica, sans- serif',
+                background: 'linear-gradient(90deg, rgba(121,9,9,1) 0%, rgba(203,62,62,1) 100%)'
+            },
+            duration: 3000
+        }).showToast();
+    }
+};
+const information = (params, pinsSettingsList, context)=>new EditorService().information(params, pinsSettingsList, context);
+const error = (params, pinsSettingsList, context)=>new EditorService().error(params, pinsSettingsList, context);
+
+export { GenericSceneElement as G, _extends as _, error as e, information as i };