@nebula.js/stardust 5.12.6 → 5.13.0

package/core/esm/dev.js

@@ -1,5 +1,5 @@
 /*
-* @nebula.js/stardust v5.12.6
+* @nebula.js/stardust v5.13.0
 * Copyright (c) 2025 QlikTech International AB
 * Released under the MIT license.
 */
@@ -48,671 +48,768 @@ var runtime = {exports: {}};
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  */
+
 var hasRequiredRuntime;
-function requireRuntime() {
-  if (hasRequiredRuntime) return runtime.exports;
-  hasRequiredRuntime = 1;
-  (function (module) {
-    var runtime = function (exports) {
-
-      var Op = Object.prototype;
-      var hasOwn = Op.hasOwnProperty;
-      var defineProperty = Object.defineProperty || function (obj, key, desc) {
-        obj[key] = desc.value;
-      };
-      var undefined$1; // More compressible than void 0.
-      var $Symbol = typeof Symbol === "function" ? Symbol : {};
-      var iteratorSymbol = $Symbol.iterator || "@@iterator";
-      var asyncIteratorSymbol = $Symbol.asyncIterator || "@@asyncIterator";
-      var toStringTagSymbol = $Symbol.toStringTag || "@@toStringTag";
-      function define(obj, key, value) {
-        Object.defineProperty(obj, key, {
-          value: value,
-          enumerable: true,
-          configurable: true,
-          writable: true
-        });
-        return obj[key];
-      }
-      try {
-        // IE 8 has a broken Object.defineProperty that only works on DOM objects.
-        define({}, "");
-      } catch (err) {
-        define = function (obj, key, value) {
-          return obj[key] = value;
-        };
-      }
-      function wrap(innerFn, outerFn, self, tryLocsList) {
-        // If outerFn provided and outerFn.prototype is a Generator, then outerFn.prototype instanceof Generator.
-        var protoGenerator = outerFn && outerFn.prototype instanceof Generator ? outerFn : Generator;
-        var generator = Object.create(protoGenerator.prototype);
-        var context = new Context(tryLocsList || []);
 
-        // The ._invoke method unifies the implementations of the .next,
-        // .throw, and .return methods.
-        defineProperty(generator, "_invoke", {
-          value: makeInvokeMethod(innerFn, self, context)
-        });
-        return generator;
-      }
-      exports.wrap = wrap;
-
-      // Try/catch helper to minimize deoptimizations. Returns a completion
-      // record like context.tryEntries[i].completion. This interface could
-      // have been (and was previously) designed to take a closure to be
-      // invoked without arguments, but in all the cases we care about we
-      // already have an existing method we want to call, so there's no need
-      // to create a new function object. We can even get away with assuming
-      // the method takes exactly one argument, since that happens to be true
-      // in every case, so we don't have to touch the arguments object. The
-      // only additional allocation required is the completion record, which
-      // has a stable shape and so hopefully should be cheap to allocate.
-      function tryCatch(fn, obj, arg) {
-        try {
-          return {
-            type: "normal",
-            arg: fn.call(obj, arg)
-          };
-        } catch (err) {
-          return {
-            type: "throw",
-            arg: err
-          };
-        }
-      }
-      var GenStateSuspendedStart = "suspendedStart";
-      var GenStateSuspendedYield = "suspendedYield";
-      var GenStateExecuting = "executing";
-      var GenStateCompleted = "completed";
-
-      // Returning this object from the innerFn has the same effect as
-      // breaking out of the dispatch switch statement.
-      var ContinueSentinel = {};
-
-      // Dummy constructor functions that we use as the .constructor and
-      // .constructor.prototype properties for functions that return Generator
-      // objects. For full spec compliance, you may wish to configure your
-      // minifier not to mangle the names of these two functions.
-      function Generator() {}
-      function GeneratorFunction() {}
-      function GeneratorFunctionPrototype() {}
-
-      // This is a polyfill for %IteratorPrototype% for environments that
-      // don't natively support it.
-      var IteratorPrototype = {};
-      define(IteratorPrototype, iteratorSymbol, function () {
-        return this;
-      });
-      var getProto = Object.getPrototypeOf;
-      var NativeIteratorPrototype = getProto && getProto(getProto(values([])));
-      if (NativeIteratorPrototype && NativeIteratorPrototype !== Op && hasOwn.call(NativeIteratorPrototype, iteratorSymbol)) {
-        // This environment has a native %IteratorPrototype%; use it instead
-        // of the polyfill.
-        IteratorPrototype = NativeIteratorPrototype;
-      }
-      var Gp = GeneratorFunctionPrototype.prototype = Generator.prototype = Object.create(IteratorPrototype);
-      GeneratorFunction.prototype = GeneratorFunctionPrototype;
-      defineProperty(Gp, "constructor", {
-        value: GeneratorFunctionPrototype,
-        configurable: true
-      });
-      defineProperty(GeneratorFunctionPrototype, "constructor", {
-        value: GeneratorFunction,
-        configurable: true
-      });
-      GeneratorFunction.displayName = define(GeneratorFunctionPrototype, toStringTagSymbol, "GeneratorFunction");
-
-      // Helper for defining the .next, .throw, and .return methods of the
-      // Iterator interface in terms of a single ._invoke method.
-      function defineIteratorMethods(prototype) {
-        ["next", "throw", "return"].forEach(function (method) {
-          define(prototype, method, function (arg) {
-            return this._invoke(method, arg);
-          });
-        });
-      }
-      exports.isGeneratorFunction = function (genFun) {
-        var ctor = typeof genFun === "function" && genFun.constructor;
-        return ctor ? ctor === GeneratorFunction ||
-        // For the native GeneratorFunction constructor, the best we can
-        // do is to check its .name property.
-        (ctor.displayName || ctor.name) === "GeneratorFunction" : false;
-      };
-      exports.mark = function (genFun) {
-        if (Object.setPrototypeOf) {
-          Object.setPrototypeOf(genFun, GeneratorFunctionPrototype);
-        } else {
-          genFun.__proto__ = GeneratorFunctionPrototype;
-          define(genFun, toStringTagSymbol, "GeneratorFunction");
-        }
-        genFun.prototype = Object.create(Gp);
-        return genFun;
-      };
+function requireRuntime () {
+	if (hasRequiredRuntime) return runtime.exports;
+	hasRequiredRuntime = 1;
+	(function (module) {
+		var runtime = (function (exports) {
+
+		  var Op = Object.prototype;
+		  var hasOwn = Op.hasOwnProperty;
+		  var defineProperty = Object.defineProperty || function (obj, key, desc) { obj[key] = desc.value; };
+		  var undefined$1; // More compressible than void 0.
+		  var $Symbol = typeof Symbol === "function" ? Symbol : {};
+		  var iteratorSymbol = $Symbol.iterator || "@@iterator";
+		  var asyncIteratorSymbol = $Symbol.asyncIterator || "@@asyncIterator";
+		  var toStringTagSymbol = $Symbol.toStringTag || "@@toStringTag";
+
+		  function define(obj, key, value) {
+		    Object.defineProperty(obj, key, {
+		      value: value,
+		      enumerable: true,
+		      configurable: true,
+		      writable: true
+		    });
+		    return obj[key];
+		  }
+		  try {
+		    // IE 8 has a broken Object.defineProperty that only works on DOM objects.
+		    define({}, "");
+		  } catch (err) {
+		    define = function(obj, key, value) {
+		      return obj[key] = value;
+		    };
+		  }
 
-      // Within the body of any async function, `await x` is transformed to
-      // `yield regeneratorRuntime.awrap(x)`, so that the runtime can test
-      // `hasOwn.call(value, "__await")` to determine if the yielded value is
-      // meant to be awaited.
-      exports.awrap = function (arg) {
-        return {
-          __await: arg
-        };
-      };
-      function AsyncIterator(generator, PromiseImpl) {
-        function invoke(method, arg, resolve, reject) {
-          var record = tryCatch(generator[method], generator, arg);
-          if (record.type === "throw") {
-            reject(record.arg);
-          } else {
-            var result = record.arg;
-            var value = result.value;
-            if (value && typeof value === "object" && hasOwn.call(value, "__await")) {
-              return PromiseImpl.resolve(value.__await).then(function (value) {
-                invoke("next", value, resolve, reject);
-              }, function (err) {
-                invoke("throw", err, resolve, reject);
-              });
-            }
-            return PromiseImpl.resolve(value).then(function (unwrapped) {
-              // When a yielded Promise is resolved, its final value becomes
-              // the .value of the Promise<{value,done}> result for the
-              // current iteration.
-              result.value = unwrapped;
-              resolve(result);
-            }, function (error) {
-              // If a rejected Promise was yielded, throw the rejection back
-              // into the async generator function so it can be handled there.
-              return invoke("throw", error, resolve, reject);
-            });
-          }
-        }
-        var previousPromise;
-        function enqueue(method, arg) {
-          function callInvokeWithMethodAndArg() {
-            return new PromiseImpl(function (resolve, reject) {
-              invoke(method, arg, resolve, reject);
-            });
-          }
-          return previousPromise =
-          // If enqueue has been called before, then we want to wait until
-          // all previous Promises have been resolved before calling invoke,
-          // so that results are always delivered in the correct order. If
-          // enqueue has not been called before, then it is important to
-          // call invoke immediately, without waiting on a callback to fire,
-          // so that the async generator function has the opportunity to do
-          // any necessary setup in a predictable way. This predictability
-          // is why the Promise constructor synchronously invokes its
-          // executor callback, and why async functions synchronously
-          // execute code before the first await. Since we implement simple
-          // async functions in terms of async generators, it is especially
-          // important to get this right, even though it requires care.
-          previousPromise ? previousPromise.then(callInvokeWithMethodAndArg,
-          // Avoid propagating failures to Promises returned by later
-          // invocations of the iterator.
-          callInvokeWithMethodAndArg) : callInvokeWithMethodAndArg();
-        }
+		  function wrap(innerFn, outerFn, self, tryLocsList) {
+		    // If outerFn provided and outerFn.prototype is a Generator, then outerFn.prototype instanceof Generator.
+		    var protoGenerator = outerFn && outerFn.prototype instanceof Generator ? outerFn : Generator;
+		    var generator = Object.create(protoGenerator.prototype);
+		    var context = new Context(tryLocsList || []);
 
-        // Define the unified helper method that is used to implement .next,
-        // .throw, and .return (see defineIteratorMethods).
-        defineProperty(this, "_invoke", {
-          value: enqueue
-        });
-      }
-      defineIteratorMethods(AsyncIterator.prototype);
-      define(AsyncIterator.prototype, asyncIteratorSymbol, function () {
-        return this;
-      });
-      exports.AsyncIterator = AsyncIterator;
-
-      // Note that simple async functions are implemented on top of
-      // AsyncIterator objects; they just return a Promise for the value of
-      // the final result produced by the iterator.
-      exports.async = function (innerFn, outerFn, self, tryLocsList, PromiseImpl) {
-        if (PromiseImpl === void 0) PromiseImpl = Promise;
-        var iter = new AsyncIterator(wrap(innerFn, outerFn, self, tryLocsList), PromiseImpl);
-        return exports.isGeneratorFunction(outerFn) ? iter // If outerFn is a generator, return the full iterator.
-        : iter.next().then(function (result) {
-          return result.done ? result.value : iter.next();
-        });
-      };
-      function makeInvokeMethod(innerFn, self, context) {
-        var state = GenStateSuspendedStart;
-        return function invoke(method, arg) {
-          if (state === GenStateExecuting) {
-            throw new Error("Generator is already running");
-          }
-          if (state === GenStateCompleted) {
-            if (method === "throw") {
-              throw arg;
-            }
+		    // The ._invoke method unifies the implementations of the .next,
+		    // .throw, and .return methods.
+		    defineProperty(generator, "_invoke", { value: makeInvokeMethod(innerFn, self, context) });
 
-            // Be forgiving, per GeneratorResume behavior specified since ES2015:
-            // ES2015 spec, step 3: https://262.ecma-international.org/6.0/#sec-generatorresume
-            // Latest spec, step 2: https://tc39.es/ecma262/#sec-generatorresume
-            return doneResult();
-          }
-          context.method = method;
-          context.arg = arg;
-          while (true) {
-            var delegate = context.delegate;
-            if (delegate) {
-              var delegateResult = maybeInvokeDelegate(delegate, context);
-              if (delegateResult) {
-                if (delegateResult === ContinueSentinel) continue;
-                return delegateResult;
-              }
-            }
-            if (context.method === "next") {
-              // Setting context._sent for legacy support of Babel's
-              // function.sent implementation.
-              context.sent = context._sent = context.arg;
-            } else if (context.method === "throw") {
-              if (state === GenStateSuspendedStart) {
-                state = GenStateCompleted;
-                throw context.arg;
-              }
-              context.dispatchException(context.arg);
-            } else if (context.method === "return") {
-              context.abrupt("return", context.arg);
-            }
-            state = GenStateExecuting;
-            var record = tryCatch(innerFn, self, context);
-            if (record.type === "normal") {
-              // If an exception is thrown from innerFn, we leave state ===
-              // GenStateExecuting and loop back for another invocation.
-              state = context.done ? GenStateCompleted : GenStateSuspendedYield;
-              if (record.arg === ContinueSentinel) {
-                continue;
-              }
-              return {
-                value: record.arg,
-                done: context.done
-              };
-            } else if (record.type === "throw") {
-              state = GenStateCompleted;
-              // Dispatch the exception by looping back around to the
-              // context.dispatchException(context.arg) call above.
-              context.method = "throw";
-              context.arg = record.arg;
-            }
-          }
-        };
-      }
+		    return generator;
+		  }
+		  exports.wrap = wrap;
+
+		  // Try/catch helper to minimize deoptimizations. Returns a completion
+		  // record like context.tryEntries[i].completion. This interface could
+		  // have been (and was previously) designed to take a closure to be
+		  // invoked without arguments, but in all the cases we care about we
+		  // already have an existing method we want to call, so there's no need
+		  // to create a new function object. We can even get away with assuming
+		  // the method takes exactly one argument, since that happens to be true
+		  // in every case, so we don't have to touch the arguments object. The
+		  // only additional allocation required is the completion record, which
+		  // has a stable shape and so hopefully should be cheap to allocate.
+		  function tryCatch(fn, obj, arg) {
+		    try {
+		      return { type: "normal", arg: fn.call(obj, arg) };
+		    } catch (err) {
+		      return { type: "throw", arg: err };
+		    }
+		  }
 
-      // Call delegate.iterator[context.method](context.arg) and handle the
-      // result, either by returning a { value, done } result from the
-      // delegate iterator, or by modifying context.method and context.arg,
-      // setting context.delegate to null, and returning the ContinueSentinel.
-      function maybeInvokeDelegate(delegate, context) {
-        var methodName = context.method;
-        var method = delegate.iterator[methodName];
-        if (method === undefined$1) {
-          // A .throw or .return when the delegate iterator has no .throw
-          // method, or a missing .next method, always terminate the
-          // yield* loop.
-          context.delegate = null;
-
-          // Note: ["return"] must be used for ES3 parsing compatibility.
-          if (methodName === "throw" && delegate.iterator["return"]) {
-            // If the delegate iterator has a return method, give it a
-            // chance to clean up.
-            context.method = "return";
-            context.arg = undefined$1;
-            maybeInvokeDelegate(delegate, context);
-            if (context.method === "throw") {
-              // If maybeInvokeDelegate(context) changed context.method from
-              // "return" to "throw", let that override the TypeError below.
-              return ContinueSentinel;
-            }
-          }
-          if (methodName !== "return") {
-            context.method = "throw";
-            context.arg = new TypeError("The iterator does not provide a '" + methodName + "' method");
-          }
-          return ContinueSentinel;
-        }
-        var record = tryCatch(method, delegate.iterator, context.arg);
-        if (record.type === "throw") {
-          context.method = "throw";
-          context.arg = record.arg;
-          context.delegate = null;
-          return ContinueSentinel;
-        }
-        var info = record.arg;
-        if (!info) {
-          context.method = "throw";
-          context.arg = new TypeError("iterator result is not an object");
-          context.delegate = null;
-          return ContinueSentinel;
-        }
-        if (info.done) {
-          // Assign the result of the finished delegate to the temporary
-          // variable specified by delegate.resultName (see delegateYield).
-          context[delegate.resultName] = info.value;
-
-          // Resume execution at the desired location (see delegateYield).
-          context.next = delegate.nextLoc;
-
-          // If context.method was "throw" but the delegate handled the
-          // exception, let the outer generator proceed normally. If
-          // context.method was "next", forget context.arg since it has been
-          // "consumed" by the delegate iterator. If context.method was
-          // "return", allow the original .return call to continue in the
-          // outer generator.
-          if (context.method !== "return") {
-            context.method = "next";
-            context.arg = undefined$1;
-          }
-        } else {
-          // Re-yield the result returned by the delegate method.
-          return info;
-        }
+		  var GenStateSuspendedStart = "suspendedStart";
+		  var GenStateSuspendedYield = "suspendedYield";
+		  var GenStateExecuting = "executing";
+		  var GenStateCompleted = "completed";
+
+		  // Returning this object from the innerFn has the same effect as
+		  // breaking out of the dispatch switch statement.
+		  var ContinueSentinel = {};
+
+		  // Dummy constructor functions that we use as the .constructor and
+		  // .constructor.prototype properties for functions that return Generator
+		  // objects. For full spec compliance, you may wish to configure your
+		  // minifier not to mangle the names of these two functions.
+		  function Generator() {}
+		  function GeneratorFunction() {}
+		  function GeneratorFunctionPrototype() {}
+
+		  // This is a polyfill for %IteratorPrototype% for environments that
+		  // don't natively support it.
+		  var IteratorPrototype = {};
+		  define(IteratorPrototype, iteratorSymbol, function () {
+		    return this;
+		  });
+
+		  var getProto = Object.getPrototypeOf;
+		  var NativeIteratorPrototype = getProto && getProto(getProto(values([])));
+		  if (NativeIteratorPrototype &&
+		      NativeIteratorPrototype !== Op &&
+		      hasOwn.call(NativeIteratorPrototype, iteratorSymbol)) {
+		    // This environment has a native %IteratorPrototype%; use it instead
+		    // of the polyfill.
+		    IteratorPrototype = NativeIteratorPrototype;
+		  }
 
-        // The delegate iterator is finished, so forget it and continue with
-        // the outer generator.
-        context.delegate = null;
-        return ContinueSentinel;
-      }
+		  var Gp = GeneratorFunctionPrototype.prototype =
+		    Generator.prototype = Object.create(IteratorPrototype);
+		  GeneratorFunction.prototype = GeneratorFunctionPrototype;
+		  defineProperty(Gp, "constructor", { value: GeneratorFunctionPrototype, configurable: true });
+		  defineProperty(
+		    GeneratorFunctionPrototype,
+		    "constructor",
+		    { value: GeneratorFunction, configurable: true }
+		  );
+		  GeneratorFunction.displayName = define(
+		    GeneratorFunctionPrototype,
+		    toStringTagSymbol,
+		    "GeneratorFunction"
+		  );
+
+		  // Helper for defining the .next, .throw, and .return methods of the
+		  // Iterator interface in terms of a single ._invoke method.
+		  function defineIteratorMethods(prototype) {
+		    ["next", "throw", "return"].forEach(function(method) {
+		      define(prototype, method, function(arg) {
+		        return this._invoke(method, arg);
+		      });
+		    });
+		  }
 
-      // Define Generator.prototype.{next,throw,return} in terms of the
-      // unified ._invoke helper method.
-      defineIteratorMethods(Gp);
-      define(Gp, toStringTagSymbol, "Generator");
+		  exports.isGeneratorFunction = function(genFun) {
+		    var ctor = typeof genFun === "function" && genFun.constructor;
+		    return ctor
+		      ? ctor === GeneratorFunction ||
+		        // For the native GeneratorFunction constructor, the best we can
+		        // do is to check its .name property.
+		        (ctor.displayName || ctor.name) === "GeneratorFunction"
+		      : false;
+		  };
 
-      // A Generator should always return itself as the iterator object when the
-      // @@iterator function is called on it. Some browsers' implementations of the
-      // iterator prototype chain incorrectly implement this, causing the Generator
-      // object to not be returned from this call. This ensures that doesn't happen.
-      // See https://github.com/facebook/regenerator/issues/274 for more details.
-      define(Gp, iteratorSymbol, function () {
-        return this;
-      });
-      define(Gp, "toString", function () {
-        return "[object Generator]";
-      });
-      function pushTryEntry(locs) {
-        var entry = {
-          tryLoc: locs[0]
-        };
-        if (1 in locs) {
-          entry.catchLoc = locs[1];
-        }
-        if (2 in locs) {
-          entry.finallyLoc = locs[2];
-          entry.afterLoc = locs[3];
-        }
-        this.tryEntries.push(entry);
-      }
-      function resetTryEntry(entry) {
-        var record = entry.completion || {};
-        record.type = "normal";
-        delete record.arg;
-        entry.completion = record;
-      }
-      function Context(tryLocsList) {
-        // The root entry object (effectively a try statement without a catch
-        // or a finally block) gives us a place to store values thrown from
-        // locations where there is no enclosing try statement.
-        this.tryEntries = [{
-          tryLoc: "root"
-        }];
-        tryLocsList.forEach(pushTryEntry, this);
-        this.reset(true);
-      }
-      exports.keys = function (val) {
-        var object = Object(val);
-        var keys = [];
-        for (var key in object) {
-          keys.push(key);
-        }
-        keys.reverse();
-
-        // Rather than returning an object with a next method, we keep
-        // things simple and return the next function itself.
-        return function next() {
-          while (keys.length) {
-            var key = keys.pop();
-            if (key in object) {
-              next.value = key;
-              next.done = false;
-              return next;
-            }
-          }
+		  exports.mark = function(genFun) {
+		    if (Object.setPrototypeOf) {
+		      Object.setPrototypeOf(genFun, GeneratorFunctionPrototype);
+		    } else {
+		      genFun.__proto__ = GeneratorFunctionPrototype;
+		      define(genFun, toStringTagSymbol, "GeneratorFunction");
+		    }
+		    genFun.prototype = Object.create(Gp);
+		    return genFun;
+		  };
 
-          // To avoid creating an additional object, we just hang the .value
-          // and .done properties off the next function object itself. This
-          // also ensures that the minifier will not anonymize the function.
-          next.done = true;
-          return next;
-        };
-      };
-      function values(iterable) {
-        if (iterable != null) {
-          var iteratorMethod = iterable[iteratorSymbol];
-          if (iteratorMethod) {
-            return iteratorMethod.call(iterable);
-          }
-          if (typeof iterable.next === "function") {
-            return iterable;
-          }
-          if (!isNaN(iterable.length)) {
-            var i = -1,
-              next = function next() {
-                while (++i < iterable.length) {
-                  if (hasOwn.call(iterable, i)) {
-                    next.value = iterable[i];
-                    next.done = false;
-                    return next;
-                  }
-                }
-                next.value = undefined$1;
-                next.done = true;
-                return next;
-              };
-            return next.next = next;
-          }
-        }
-        throw new TypeError(typeof iterable + " is not iterable");
-      }
-      exports.values = values;
-      function doneResult() {
-        return {
-          value: undefined$1,
-          done: true
-        };
-      }
-      Context.prototype = {
-        constructor: Context,
-        reset: function (skipTempReset) {
-          this.prev = 0;
-          this.next = 0;
-          // Resetting context._sent for legacy support of Babel's
-          // function.sent implementation.
-          this.sent = this._sent = undefined$1;
-          this.done = false;
-          this.delegate = null;
-          this.method = "next";
-          this.arg = undefined$1;
-          this.tryEntries.forEach(resetTryEntry);
-          if (!skipTempReset) {
-            for (var name in this) {
-              // Not sure about the optimal order of these conditions:
-              if (name.charAt(0) === "t" && hasOwn.call(this, name) && !isNaN(+name.slice(1))) {
-                this[name] = undefined$1;
-              }
-            }
-          }
-        },
-        stop: function () {
-          this.done = true;
-          var rootEntry = this.tryEntries[0];
-          var rootRecord = rootEntry.completion;
-          if (rootRecord.type === "throw") {
-            throw rootRecord.arg;
-          }
-          return this.rval;
-        },
-        dispatchException: function (exception) {
-          if (this.done) {
-            throw exception;
-          }
-          var context = this;
-          function handle(loc, caught) {
-            record.type = "throw";
-            record.arg = exception;
-            context.next = loc;
-            if (caught) {
-              // If the dispatched exception was caught by a catch block,
-              // then let that catch block handle the exception normally.
-              context.method = "next";
-              context.arg = undefined$1;
-            }
-            return !!caught;
-          }
-          for (var i = this.tryEntries.length - 1; i >= 0; --i) {
-            var entry = this.tryEntries[i];
-            var record = entry.completion;
-            if (entry.tryLoc === "root") {
-              // Exception thrown outside of any try block that could handle
-              // it, so set the completion value of the entire function to
-              // throw the exception.
-              return handle("end");
-            }
-            if (entry.tryLoc <= this.prev) {
-              var hasCatch = hasOwn.call(entry, "catchLoc");
-              var hasFinally = hasOwn.call(entry, "finallyLoc");
-              if (hasCatch && hasFinally) {
-                if (this.prev < entry.catchLoc) {
-                  return handle(entry.catchLoc, true);
-                } else if (this.prev < entry.finallyLoc) {
-                  return handle(entry.finallyLoc);
-                }
-              } else if (hasCatch) {
-                if (this.prev < entry.catchLoc) {
-                  return handle(entry.catchLoc, true);
-                }
-              } else if (hasFinally) {
-                if (this.prev < entry.finallyLoc) {
-                  return handle(entry.finallyLoc);
-                }
-              } else {
-                throw new Error("try statement without catch or finally");
-              }
-            }
-          }
-        },
-        abrupt: function (type, arg) {
-          for (var i = this.tryEntries.length - 1; i >= 0; --i) {
-            var entry = this.tryEntries[i];
-            if (entry.tryLoc <= this.prev && hasOwn.call(entry, "finallyLoc") && this.prev < entry.finallyLoc) {
-              var finallyEntry = entry;
-              break;
-            }
-          }
-          if (finallyEntry && (type === "break" || type === "continue") && finallyEntry.tryLoc <= arg && arg <= finallyEntry.finallyLoc) {
-            // Ignore the finally entry if control is not jumping to a
-            // location outside the try/catch block.
-            finallyEntry = null;
-          }
-          var record = finallyEntry ? finallyEntry.completion : {};
-          record.type = type;
-          record.arg = arg;
-          if (finallyEntry) {
-            this.method = "next";
-            this.next = finallyEntry.finallyLoc;
-            return ContinueSentinel;
-          }
-          return this.complete(record);
-        },
-        complete: function (record, afterLoc) {
-          if (record.type === "throw") {
-            throw record.arg;
-          }
-          if (record.type === "break" || record.type === "continue") {
-            this.next = record.arg;
-          } else if (record.type === "return") {
-            this.rval = this.arg = record.arg;
-            this.method = "return";
-            this.next = "end";
-          } else if (record.type === "normal" && afterLoc) {
-            this.next = afterLoc;
-          }
-          return ContinueSentinel;
-        },
-        finish: function (finallyLoc) {
-          for (var i = this.tryEntries.length - 1; i >= 0; --i) {
-            var entry = this.tryEntries[i];
-            if (entry.finallyLoc === finallyLoc) {
-              this.complete(entry.completion, entry.afterLoc);
-              resetTryEntry(entry);
-              return ContinueSentinel;
-            }
-          }
-        },
-        "catch": function (tryLoc) {
-          for (var i = this.tryEntries.length - 1; i >= 0; --i) {
-            var entry = this.tryEntries[i];
-            if (entry.tryLoc === tryLoc) {
-              var record = entry.completion;
-              if (record.type === "throw") {
-                var thrown = record.arg;
-                resetTryEntry(entry);
-              }
-              return thrown;
-            }
-          }
+		  // Within the body of any async function, `await x` is transformed to
+		  // `yield regeneratorRuntime.awrap(x)`, so that the runtime can test
+		  // `hasOwn.call(value, "__await")` to determine if the yielded value is
+		  // meant to be awaited.
+		  exports.awrap = function(arg) {
+		    return { __await: arg };
+		  };
 
-          // The context.catch method must only be called with a location
-          // argument that corresponds to a known catch block.
-          throw new Error("illegal catch attempt");
-        },
-        delegateYield: function (iterable, resultName, nextLoc) {
-          this.delegate = {
-            iterator: values(iterable),
-            resultName: resultName,
-            nextLoc: nextLoc
-          };
-          if (this.method === "next") {
-            // Deliberately forget the last sent value so that we don't
-            // accidentally pass it on to the delegate.
-            this.arg = undefined$1;
-          }
-          return ContinueSentinel;
-        }
-      };
+		  function AsyncIterator(generator, PromiseImpl) {
+		    function invoke(method, arg, resolve, reject) {
+		      var record = tryCatch(generator[method], generator, arg);
+		      if (record.type === "throw") {
+		        reject(record.arg);
+		      } else {
+		        var result = record.arg;
+		        var value = result.value;
+		        if (value &&
+		            typeof value === "object" &&
+		            hasOwn.call(value, "__await")) {
+		          return PromiseImpl.resolve(value.__await).then(function(value) {
+		            invoke("next", value, resolve, reject);
+		          }, function(err) {
+		            invoke("throw", err, resolve, reject);
+		          });
+		        }
 
-      // Regardless of whether this script is executing as a CommonJS module
-      // or not, return the runtime object so that we can declare the variable
-      // regeneratorRuntime in the outer scope, which allows this module to be
-      // injected easily by `bin/regenerator --include-runtime script.js`.
-      return exports;
-    }(
-    // If this script is executing as a CommonJS module, use module.exports
-    // as the regeneratorRuntime namespace. Otherwise create a new empty
-    // object. Either way, the resulting object will be used to initialize
-    // the regeneratorRuntime variable at the top of this file.
-    module.exports );
-    try {
-      regeneratorRuntime = runtime;
-    } catch (accidentalStrictMode) {
-      // This module should not be running in strict mode, so the above
-      // assignment should always work unless something is misconfigured. Just
-      // in case runtime.js accidentally runs in strict mode, in modern engines
-      // we can explicitly access globalThis. In older engines we can escape
-      // strict mode using a global Function call. This could conceivably fail
-      // if a Content Security Policy forbids using Function, but in that case
-      // the proper solution is to fix the accidental strict mode problem. If
-      // you've misconfigured your bundler to force strict mode and applied a
-      // CSP to forbid Function, and you're not willing to fix either of those
-      // problems, please detail your unique predicament in a GitHub issue.
-      if (typeof globalThis === "object") {
-        globalThis.regeneratorRuntime = runtime;
-      } else {
-        Function("r", "regeneratorRuntime = r")(runtime);
-      }
-    }
-  })(runtime);
-  return runtime.exports;
+		        return PromiseImpl.resolve(value).then(function(unwrapped) {
+		          // When a yielded Promise is resolved, its final value becomes
+		          // the .value of the Promise<{value,done}> result for the
+		          // current iteration.
+		          result.value = unwrapped;
+		          resolve(result);
+		        }, function(error) {
+		          // If a rejected Promise was yielded, throw the rejection back
+		          // into the async generator function so it can be handled there.
+		          return invoke("throw", error, resolve, reject);
+		        });
+		      }
+		    }
+
+		    var previousPromise;
+
+		    function enqueue(method, arg) {
+		      function callInvokeWithMethodAndArg() {
+		        return new PromiseImpl(function(resolve, reject) {
+		          invoke(method, arg, resolve, reject);
+		        });
+		      }
+
+		      return previousPromise =
+		        // If enqueue has been called before, then we want to wait until
+		        // all previous Promises have been resolved before calling invoke,
+		        // so that results are always delivered in the correct order. If
+		        // enqueue has not been called before, then it is important to
+		        // call invoke immediately, without waiting on a callback to fire,
+		        // so that the async generator function has the opportunity to do
+		        // any necessary setup in a predictable way. This predictability
+		        // is why the Promise constructor synchronously invokes its
+		        // executor callback, and why async functions synchronously
+		        // execute code before the first await. Since we implement simple
+		        // async functions in terms of async generators, it is especially
+		        // important to get this right, even though it requires care.
+		        previousPromise ? previousPromise.then(
+		          callInvokeWithMethodAndArg,
+		          // Avoid propagating failures to Promises returned by later
+		          // invocations of the iterator.
+		          callInvokeWithMethodAndArg
+		        ) : callInvokeWithMethodAndArg();
+		    }
+
+		    // Define the unified helper method that is used to implement .next,
+		    // .throw, and .return (see defineIteratorMethods).
+		    defineProperty(this, "_invoke", { value: enqueue });
+		  }
+
+		  defineIteratorMethods(AsyncIterator.prototype);
+		  define(AsyncIterator.prototype, asyncIteratorSymbol, function () {
+		    return this;
+		  });
+		  exports.AsyncIterator = AsyncIterator;
+
+		  // Note that simple async functions are implemented on top of
+		  // AsyncIterator objects; they just return a Promise for the value of
+		  // the final result produced by the iterator.
+		  exports.async = function(innerFn, outerFn, self, tryLocsList, PromiseImpl) {
+		    if (PromiseImpl === void 0) PromiseImpl = Promise;
+
+		    var iter = new AsyncIterator(
+		      wrap(innerFn, outerFn, self, tryLocsList),
+		      PromiseImpl
+		    );
+
+		    return exports.isGeneratorFunction(outerFn)
+		      ? iter // If outerFn is a generator, return the full iterator.
+		      : iter.next().then(function(result) {
+		          return result.done ? result.value : iter.next();
+		        });
+		  };
+
+		  function makeInvokeMethod(innerFn, self, context) {
+		    var state = GenStateSuspendedStart;
+
+		    return function invoke(method, arg) {
+		      if (state === GenStateExecuting) {
+		        throw new Error("Generator is already running");
+		      }
+
+		      if (state === GenStateCompleted) {
+		        if (method === "throw") {
+		          throw arg;
+		        }
+
+		        // Be forgiving, per GeneratorResume behavior specified since ES2015:
+		        // ES2015 spec, step 3: https://262.ecma-international.org/6.0/#sec-generatorresume
+		        // Latest spec, step 2: https://tc39.es/ecma262/#sec-generatorresume
+		        return doneResult();
+		      }
+
+		      context.method = method;
+		      context.arg = arg;
+
+		      while (true) {
+		        var delegate = context.delegate;
+		        if (delegate) {
+		          var delegateResult = maybeInvokeDelegate(delegate, context);
+		          if (delegateResult) {
+		            if (delegateResult === ContinueSentinel) continue;
+		            return delegateResult;
+		          }
+		        }
+
+		        if (context.method === "next") {
+		          // Setting context._sent for legacy support of Babel's
+		          // function.sent implementation.
+		          context.sent = context._sent = context.arg;
+
+		        } else if (context.method === "throw") {
+		          if (state === GenStateSuspendedStart) {
+		            state = GenStateCompleted;
+		            throw context.arg;
+		          }
+
+		          context.dispatchException(context.arg);
+
+		        } else if (context.method === "return") {
+		          context.abrupt("return", context.arg);
+		        }
+
+		        state = GenStateExecuting;
+
+		        var record = tryCatch(innerFn, self, context);
+		        if (record.type === "normal") {
+		          // If an exception is thrown from innerFn, we leave state ===
+		          // GenStateExecuting and loop back for another invocation.
+		          state = context.done
+		            ? GenStateCompleted
+		            : GenStateSuspendedYield;
+
+		          if (record.arg === ContinueSentinel) {
+		            continue;
+		          }
+
+		          return {
+		            value: record.arg,
+		            done: context.done
+		          };
+
+		        } else if (record.type === "throw") {
+		          state = GenStateCompleted;
+		          // Dispatch the exception by looping back around to the
+		          // context.dispatchException(context.arg) call above.
+		          context.method = "throw";
+		          context.arg = record.arg;
+		        }
+		      }
+		    };
+		  }
+
+		  // Call delegate.iterator[context.method](context.arg) and handle the
+		  // result, either by returning a { value, done } result from the
+		  // delegate iterator, or by modifying context.method and context.arg,
+		  // setting context.delegate to null, and returning the ContinueSentinel.
+		  function maybeInvokeDelegate(delegate, context) {
+		    var methodName = context.method;
+		    var method = delegate.iterator[methodName];
+		    if (method === undefined$1) {
+		      // A .throw or .return when the delegate iterator has no .throw
+		      // method, or a missing .next method, always terminate the
+		      // yield* loop.
+		      context.delegate = null;
+
+		      // Note: ["return"] must be used for ES3 parsing compatibility.
+		      if (methodName === "throw" && delegate.iterator["return"]) {
+		        // If the delegate iterator has a return method, give it a
+		        // chance to clean up.
+		        context.method = "return";
+		        context.arg = undefined$1;
+		        maybeInvokeDelegate(delegate, context);
+
+		        if (context.method === "throw") {
+		          // If maybeInvokeDelegate(context) changed context.method from
+		          // "return" to "throw", let that override the TypeError below.
+		          return ContinueSentinel;
+		        }
+		      }
+		      if (methodName !== "return") {
+		        context.method = "throw";
+		        context.arg = new TypeError(
+		          "The iterator does not provide a '" + methodName + "' method");
+		      }
+
+		      return ContinueSentinel;
+		    }
+
+		    var record = tryCatch(method, delegate.iterator, context.arg);
+
+		    if (record.type === "throw") {
+		      context.method = "throw";
+		      context.arg = record.arg;
+		      context.delegate = null;
+		      return ContinueSentinel;
+		    }
+
+		    var info = record.arg;
+
+		    if (! info) {
+		      context.method = "throw";
+		      context.arg = new TypeError("iterator result is not an object");
+		      context.delegate = null;
+		      return ContinueSentinel;
+		    }
+
+		    if (info.done) {
+		      // Assign the result of the finished delegate to the temporary
+		      // variable specified by delegate.resultName (see delegateYield).
+		      context[delegate.resultName] = info.value;
+
+		      // Resume execution at the desired location (see delegateYield).
+		      context.next = delegate.nextLoc;
+
+		      // If context.method was "throw" but the delegate handled the
+		      // exception, let the outer generator proceed normally. If
+		      // context.method was "next", forget context.arg since it has been
+		      // "consumed" by the delegate iterator. If context.method was
+		      // "return", allow the original .return call to continue in the
+		      // outer generator.
+		      if (context.method !== "return") {
+		        context.method = "next";
+		        context.arg = undefined$1;
+		      }
+
+		    } else {
+		      // Re-yield the result returned by the delegate method.
+		      return info;
+		    }
+
+		    // The delegate iterator is finished, so forget it and continue with
+		    // the outer generator.
+		    context.delegate = null;
+		    return ContinueSentinel;
+		  }
+
+		  // Define Generator.prototype.{next,throw,return} in terms of the
+		  // unified ._invoke helper method.
+		  defineIteratorMethods(Gp);
+
+		  define(Gp, toStringTagSymbol, "Generator");
+
+		  // A Generator should always return itself as the iterator object when the
+		  // @@iterator function is called on it. Some browsers' implementations of the
+		  // iterator prototype chain incorrectly implement this, causing the Generator
+		  // object to not be returned from this call. This ensures that doesn't happen.
+		  // See https://github.com/facebook/regenerator/issues/274 for more details.
+		  define(Gp, iteratorSymbol, function() {
+		    return this;
+		  });
+
+		  define(Gp, "toString", function() {
+		    return "[object Generator]";
+		  });
+
+		  function pushTryEntry(locs) {
+		    var entry = { tryLoc: locs[0] };
+
+		    if (1 in locs) {
+		      entry.catchLoc = locs[1];
+		    }
+
+		    if (2 in locs) {
+		      entry.finallyLoc = locs[2];
+		      entry.afterLoc = locs[3];
+		    }
+
+		    this.tryEntries.push(entry);
+		  }
+
+		  function resetTryEntry(entry) {
+		    var record = entry.completion || {};
+		    record.type = "normal";
+		    delete record.arg;
+		    entry.completion = record;
+		  }
+
+		  function Context(tryLocsList) {
+		    // The root entry object (effectively a try statement without a catch
+		    // or a finally block) gives us a place to store values thrown from
+		    // locations where there is no enclosing try statement.
+		    this.tryEntries = [{ tryLoc: "root" }];
+		    tryLocsList.forEach(pushTryEntry, this);
+		    this.reset(true);
+		  }
+
+		  exports.keys = function(val) {
+		    var object = Object(val);
+		    var keys = [];
+		    for (var key in object) {
+		      keys.push(key);
+		    }
+		    keys.reverse();
+
+		    // Rather than returning an object with a next method, we keep
+		    // things simple and return the next function itself.
+		    return function next() {
+		      while (keys.length) {
+		        var key = keys.pop();
+		        if (key in object) {
+		          next.value = key;
+		          next.done = false;
+		          return next;
+		        }
+		      }
+
+		      // To avoid creating an additional object, we just hang the .value
+		      // and .done properties off the next function object itself. This
+		      // also ensures that the minifier will not anonymize the function.
+		      next.done = true;
+		      return next;
+		    };
+		  };
+
+		  function values(iterable) {
+		    if (iterable != null) {
+		      var iteratorMethod = iterable[iteratorSymbol];
+		      if (iteratorMethod) {
+		        return iteratorMethod.call(iterable);
+		      }
+
+		      if (typeof iterable.next === "function") {
+		        return iterable;
+		      }
+
+		      if (!isNaN(iterable.length)) {
+		        var i = -1, next = function next() {
+		          while (++i < iterable.length) {
+		            if (hasOwn.call(iterable, i)) {
+		              next.value = iterable[i];
+		              next.done = false;
+		              return next;
+		            }
+		          }
+
+		          next.value = undefined$1;
+		          next.done = true;
+
+		          return next;
+		        };
+
+		        return next.next = next;
+		      }
+		    }
+
+		    throw new TypeError(typeof iterable + " is not iterable");
+		  }
+		  exports.values = values;
+
+		  function doneResult() {
+		    return { value: undefined$1, done: true };
+		  }
+
+		  Context.prototype = {
+		    constructor: Context,
+
+		    reset: function(skipTempReset) {
+		      this.prev = 0;
+		      this.next = 0;
+		      // Resetting context._sent for legacy support of Babel's
+		      // function.sent implementation.
+		      this.sent = this._sent = undefined$1;
+		      this.done = false;
+		      this.delegate = null;
+
+		      this.method = "next";
+		      this.arg = undefined$1;
+
+		      this.tryEntries.forEach(resetTryEntry);
+
+		      if (!skipTempReset) {
+		        for (var name in this) {
+		          // Not sure about the optimal order of these conditions:
+		          if (name.charAt(0) === "t" &&
+		              hasOwn.call(this, name) &&
+		              !isNaN(+name.slice(1))) {
+		            this[name] = undefined$1;
+		          }
+		        }
+		      }
+		    },
+
+		    stop: function() {
+		      this.done = true;
+
+		      var rootEntry = this.tryEntries[0];
+		      var rootRecord = rootEntry.completion;
+		      if (rootRecord.type === "throw") {
+		        throw rootRecord.arg;
+		      }
+
+		      return this.rval;
+		    },
+
+		    dispatchException: function(exception) {
+		      if (this.done) {
+		        throw exception;
+		      }
+
+		      var context = this;
+		      function handle(loc, caught) {
+		        record.type = "throw";
+		        record.arg = exception;
+		        context.next = loc;
+
+		        if (caught) {
+		          // If the dispatched exception was caught by a catch block,
+		          // then let that catch block handle the exception normally.
+		          context.method = "next";
+		          context.arg = undefined$1;
+		        }
+
+		        return !! caught;
+		      }
+
+		      for (var i = this.tryEntries.length - 1; i >= 0; --i) {
+		        var entry = this.tryEntries[i];
+		        var record = entry.completion;
+
+		        if (entry.tryLoc === "root") {
+		          // Exception thrown outside of any try block that could handle
+		          // it, so set the completion value of the entire function to
+		          // throw the exception.
+		          return handle("end");
+		        }
+
+		        if (entry.tryLoc <= this.prev) {
+		          var hasCatch = hasOwn.call(entry, "catchLoc");
+		          var hasFinally = hasOwn.call(entry, "finallyLoc");
+
+		          if (hasCatch && hasFinally) {
+		            if (this.prev < entry.catchLoc) {
+		              return handle(entry.catchLoc, true);
+		            } else if (this.prev < entry.finallyLoc) {
+		              return handle(entry.finallyLoc);
+		            }
+
+		          } else if (hasCatch) {
+		            if (this.prev < entry.catchLoc) {
+		              return handle(entry.catchLoc, true);
+		            }
+
+		          } else if (hasFinally) {
+		            if (this.prev < entry.finallyLoc) {
+		              return handle(entry.finallyLoc);
+		            }
+
+		          } else {
+		            throw new Error("try statement without catch or finally");
+		          }
+		        }
+		      }
+		    },
+
+		    abrupt: function(type, arg) {
+		      for (var i = this.tryEntries.length - 1; i >= 0; --i) {
+		        var entry = this.tryEntries[i];
+		        if (entry.tryLoc <= this.prev &&
+		            hasOwn.call(entry, "finallyLoc") &&
+		            this.prev < entry.finallyLoc) {
+		          var finallyEntry = entry;
+		          break;
+		        }
+		      }
+
+		      if (finallyEntry &&
+		          (type === "break" ||
+		           type === "continue") &&
+		          finallyEntry.tryLoc <= arg &&
+		          arg <= finallyEntry.finallyLoc) {
+		        // Ignore the finally entry if control is not jumping to a
+		        // location outside the try/catch block.
+		        finallyEntry = null;
+		      }
+
+		      var record = finallyEntry ? finallyEntry.completion : {};
+		      record.type = type;
+		      record.arg = arg;
+
+		      if (finallyEntry) {
+		        this.method = "next";
+		        this.next = finallyEntry.finallyLoc;
+		        return ContinueSentinel;
+		      }
+
+		      return this.complete(record);
+		    },
+
+		    complete: function(record, afterLoc) {
+		      if (record.type === "throw") {
+		        throw record.arg;
+		      }
+
+		      if (record.type === "break" ||
+		          record.type === "continue") {
+		        this.next = record.arg;
+		      } else if (record.type === "return") {
+		        this.rval = this.arg = record.arg;
+		        this.method = "return";
+		        this.next = "end";
+		      } else if (record.type === "normal" && afterLoc) {
+		        this.next = afterLoc;
+		      }
+
+		      return ContinueSentinel;
+		    },
+
+		    finish: function(finallyLoc) {
+		      for (var i = this.tryEntries.length - 1; i >= 0; --i) {
+		        var entry = this.tryEntries[i];
+		        if (entry.finallyLoc === finallyLoc) {
+		          this.complete(entry.completion, entry.afterLoc);
+		          resetTryEntry(entry);
+		          return ContinueSentinel;
+		        }
+		      }
+		    },
+
+		    "catch": function(tryLoc) {
+		      for (var i = this.tryEntries.length - 1; i >= 0; --i) {
+		        var entry = this.tryEntries[i];
+		        if (entry.tryLoc === tryLoc) {
+		          var record = entry.completion;
+		          if (record.type === "throw") {
+		            var thrown = record.arg;
+		            resetTryEntry(entry);
+		          }
+		          return thrown;
+		        }
+		      }
+
+		      // The context.catch method must only be called with a location
+		      // argument that corresponds to a known catch block.
+		      throw new Error("illegal catch attempt");
+		    },
+
+		    delegateYield: function(iterable, resultName, nextLoc) {
+		      this.delegate = {
+		        iterator: values(iterable),
+		        resultName: resultName,
+		        nextLoc: nextLoc
+		      };
+
+		      if (this.method === "next") {
+		        // Deliberately forget the last sent value so that we don't
+		        // accidentally pass it on to the delegate.
+		        this.arg = undefined$1;
+		      }
+
+		      return ContinueSentinel;
+		    }
+		  };
+
+		  // Regardless of whether this script is executing as a CommonJS module
+		  // or not, return the runtime object so that we can declare the variable
+		  // regeneratorRuntime in the outer scope, which allows this module to be
+		  // injected easily by `bin/regenerator --include-runtime script.js`.
+		  return exports;
+
+		}(
+		  // If this script is executing as a CommonJS module, use module.exports
+		  // as the regeneratorRuntime namespace. Otherwise create a new empty
+		  // object. Either way, the resulting object will be used to initialize
+		  // the regeneratorRuntime variable at the top of this file.
+		  module.exports 
+		));
+
+		try {
+		  regeneratorRuntime = runtime;
+		} catch (accidentalStrictMode) {
+		  // This module should not be running in strict mode, so the above
+		  // assignment should always work unless something is misconfigured. Just
+		  // in case runtime.js accidentally runs in strict mode, in modern engines
+		  // we can explicitly access globalThis. In older engines we can escape
+		  // strict mode using a global Function call. This could conceivably fail
+		  // if a Content Security Policy forbids using Function, but in that case
+		  // the proper solution is to fix the accidental strict mode problem. If
+		  // you've misconfigured your bundler to force strict mode and applied a
+		  // CSP to forbid Function, and you're not willing to fix either of those
+		  // problems, please detail your unique predicament in a GitHub issue.
+		  if (typeof globalThis === "object") {
+		    globalThis.regeneratorRuntime = runtime;
+		  } else {
+		    Function("r", "regeneratorRuntime = r")(runtime);
+		  }
+		} 
+	} (runtime));
+	return runtime.exports;
 }
 
 requireRuntime();
@@ -725,14 +822,14 @@ function _defineProperty(e, r, t) {
     writable: true
   }) : e[r] = t, e;
 }
-function _extends$6() {
-  return _extends$6 = Object.assign ? Object.assign.bind() : function (n) {
+function _extends$2() {
+  return _extends$2 = Object.assign ? Object.assign.bind() : function (n) {
     for (var e = 1; e < arguments.length; e++) {
       var t = arguments[e];
       for (var r in t) ({}).hasOwnProperty.call(t, r) && (n[r] = t[r]);
     }
     return n;
-  }, _extends$6.apply(null, arguments);
+  }, _extends$2.apply(null, arguments);
 }
 function ownKeys(e, r) {
   var t = Object.keys(e);
@@ -759,14 +856,14 @@ function _objectWithoutProperties(e, t) {
   if (null == e) return {};
   var o,
     r,
-    i = _objectWithoutPropertiesLoose$2(e, t);
+    i = _objectWithoutPropertiesLoose$1(e, t);
   if (Object.getOwnPropertySymbols) {
     var n = Object.getOwnPropertySymbols(e);
     for (r = 0; r < n.length; r++) o = n[r], -1 === t.indexOf(o) && {}.propertyIsEnumerable.call(e, o) && (i[o] = e[o]);
   }
   return i;
 }
-function _objectWithoutPropertiesLoose$2(r, e) {
+function _objectWithoutPropertiesLoose$1(r, e) {
   if (null == r) return {};
   var t = {};
   for (var n in r) if ({}.hasOwnProperty.call(r, n)) {
@@ -5556,32 +5653,24 @@ var formatMuiErrorMessage = /*#__PURE__*/Object.freeze({
 
 var THEME_ID = '$$material';
 
-function _extends$5() {
-  _extends$5 = Object.assign ? Object.assign.bind() : function (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];
-        }
-      }
+function _extends$1() {
+  return _extends$1 = Object.assign ? Object.assign.bind() : function (n) {
+    for (var e = 1; e < arguments.length; e++) {
+      var t = arguments[e];
+      for (var r in t) ({}).hasOwnProperty.call(t, r) && (n[r] = t[r]);
     }
-    return target;
-  };
-  return _extends$5.apply(this, arguments);
+    return n;
+  }, _extends$1.apply(null, arguments);
 }
 
-function _objectWithoutPropertiesLoose$1(source, excluded) {
-  if (source == null) return {};
-  var target = {};
-  var sourceKeys = Object.keys(source);
-  var key, i;
-  for (i = 0; i < sourceKeys.length; i++) {
-    key = sourceKeys[i];
-    if (excluded.indexOf(key) >= 0) continue;
-    target[key] = source[key];
+function _objectWithoutPropertiesLoose(r, e) {
+  if (null == r) return {};
+  var t = {};
+  for (var n in r) if ({}.hasOwnProperty.call(r, n)) {
+    if (-1 !== e.indexOf(n)) continue;
+    t[n] = r[n];
   }
-  return target;
+  return t;
 }
 
 /*
@@ -5606,10 +5695,9 @@ styleSheet.flush()
 - empties the stylesheet of all its contents
 
 */
-// $FlowFixMe
+
 function sheetForTag(tag) {
   if (tag.sheet) {
-    // $FlowFixMe
     return tag.sheet;
   } // this weirdness brought to you by firefox
 
@@ -5618,10 +5706,13 @@ function sheetForTag(tag) {
 
   for (var i = 0; i < document.styleSheets.length; i++) {
     if (document.styleSheets[i].ownerNode === tag) {
-      // $FlowFixMe
       return document.styleSheets[i];
     }
-  }
+  } // this function should always return with a value
+  // TS can't understand it though so we make it stop complaining here
+
+
+  return undefined;
 }
 
 function createStyleElement(options) {
@@ -5662,7 +5753,7 @@ var StyleSheet = /*#__PURE__*/function () {
       _this.tags.push(tag);
     };
 
-    this.isSpeedy = options.speedy === undefined ? "production" === 'production' : options.speedy;
+    this.isSpeedy = options.speedy === undefined ? true : options.speedy;
     this.tags = [];
     this.ctr = 0;
     this.nonce = options.nonce; // key is the value of the data-emotion attribute, it's used to identify different sheets
@@ -5707,9 +5798,10 @@ var StyleSheet = /*#__PURE__*/function () {
   };
 
   _proto.flush = function flush() {
-    // $FlowFixMe
     this.tags.forEach(function (tag) {
-      return tag.parentNode && tag.parentNode.removeChild(tag);
+      var _tag$parentNode;
+
+      return (_tag$parentNode = tag.parentNode) == null ? void 0 : _tag$parentNode.removeChild(tag);
     });
     this.tags = [];
     this.ctr = 0;
@@ -6317,11 +6409,11 @@ function rulesheet (callback) {
 }
 
 var weakMemoize = function weakMemoize(func) {
-  // $FlowFixMe flow doesn't include all non-primitive types as allowed for weakmaps
   var cache = new WeakMap();
   return function (arg) {
     if (cache.has(arg)) {
-      // $FlowFixMe
+      // Use non-null assertion because we just checked that the cache `has` it
+      // This allows us to remove `undefined` from the return value
       return cache.get(arg);
     }
 
@@ -6991,49 +7083,6 @@ var styledEngine = /*#__PURE__*/Object.freeze({
 	keyframes: keyframes
 });
 
-function _extends$4() {
-  _extends$4 = Object.assign ? Object.assign.bind() : function (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$4.apply(this, arguments);
-}
-
-function _objectWithoutPropertiesLoose(source, excluded) {
-  if (source == null) return {};
-  var target = {};
-  var sourceKeys = Object.keys(source);
-  var key, i;
-  for (i = 0; i < sourceKeys.length; i++) {
-    key = sourceKeys[i];
-    if (excluded.indexOf(key) >= 0) continue;
-    target[key] = source[key];
-  }
-  return target;
-}
-
-function _extends$3() {
-  _extends$3 = Object.assign ? Object.assign.bind() : function (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$3.apply(this, arguments);
-}
-
 // https://github.com/sindresorhus/is-plain-obj/blob/main/index.js
 function isPlainObject(item) {
   if (typeof item !== 'object' || item === null) {
@@ -7055,7 +7104,7 @@ function deepClone(source) {
 function deepmerge$1(target, source, options = {
   clone: true
 }) {
-  const output = options.clone ? _extends$3({}, target) : target;
+  const output = options.clone ? _extends$1({}, target) : target;
   if (isPlainObject(target) && isPlainObject(source)) {
     Object.keys(source).forEach(key => {
       if ( /*#__PURE__*/React.isValidElement(source[key])) {
@@ -7090,7 +7139,7 @@ const sortBreakpointsValues = values => {
   // Sort in ascending order
   breakpointsAsArray.sort((breakpoint1, breakpoint2) => breakpoint1.val - breakpoint2.val);
   return breakpointsAsArray.reduce((acc, obj) => {
-    return _extends$4({}, acc, {
+    return _extends$1({}, acc, {
       [obj.key]: obj.val
     });
   }, {});
@@ -7147,7 +7196,7 @@ function createBreakpoints(breakpoints) {
     }
     return between(key, keys[keys.indexOf(key) + 1]).replace('@media', '@media not all and');
   }
-  return _extends$4({
+  return _extends$1({
     keys,
     values: sortedValues,
     up,
@@ -8194,15 +8243,15 @@ function createTheme$2(options = {}, ...args) {
     direction: 'ltr',
     components: {},
     // Inject component definitions.
-    palette: _extends$4({
+    palette: _extends$1({
       mode: 'light'
     }, paletteInput),
     spacing,
-    shape: _extends$4({}, shape, shapeInput)
+    shape: _extends$1({}, shape, shapeInput)
   }, other);
   muiTheme.applyStyles = applyStyles;
   muiTheme = args.reduce((acc, argument) => deepmerge$1(acc, argument), muiTheme);
-  muiTheme.unstable_sxConfig = _extends$4({}, defaultSxConfig, other == null ? void 0 : other.unstable_sxConfig);
+  muiTheme.unstable_sxConfig = _extends$1({}, defaultSxConfig, other == null ? void 0 : other.unstable_sxConfig);
   muiTheme.unstable_sx = function sx(props) {
     return styleFunctionSx$1({
       sx: props,
@@ -8267,12 +8316,12 @@ function extendSxProp(props) {
       if (!isPlainObject(result)) {
         return systemProps;
       }
-      return _extends$4({}, systemProps, result);
+      return _extends$1({}, systemProps, result);
     };
   } else {
-    finalSx = _extends$4({}, systemProps, inSx);
+    finalSx = _extends$1({}, systemProps, inSx);
   }
-  return _extends$4({}, otherProps, {
+  return _extends$1({}, otherProps, {
     sx: finalSx
   });
 }
@@ -8431,10 +8480,10 @@ var getDisplayName = /*#__PURE__*/Object.freeze({
  * @returns {object} resolved props
  */
 function resolveProps(defaultProps, props) {
-  const output = _extends$3({}, props);
+  const output = _extends$1({}, props);
   Object.keys(defaultProps).forEach(propName => {
     if (propName.toString().match(/^(components|slots)$/)) {
-      output[propName] = _extends$3({}, defaultProps[propName], output[propName]);
+      output[propName] = _extends$1({}, defaultProps[propName], output[propName]);
     } else if (propName.toString().match(/^(componentsProps|slotProps)$/)) {
       const defaultSlotProps = defaultProps[propName] || {};
       const slotProps = props[propName];
@@ -8446,7 +8495,7 @@ function resolveProps(defaultProps, props) {
         // Reduce the iteration if the default slot props is empty
         output[propName] = slotProps;
       } else {
-        output[propName] = _extends$3({}, slotProps);
+        output[propName] = _extends$1({}, slotProps);
         Object.keys(defaultSlotProps).forEach(slotPropName => {
           output[propName][slotPropName] = resolveProps(defaultSlotProps[slotPropName], slotProps[slotPropName]);
         });
@@ -8476,21 +8525,6 @@ var clamp = /*#__PURE__*/Object.freeze({
 	default: clamp$1
 });
 
-function _extends$2() {
-  _extends$2 = Object.assign ? Object.assign.bind() : function (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$2.apply(this, arguments);
-}
-
 /**
  * Safe chained function.
  *
@@ -8888,7 +8922,7 @@ function mergeOuterLocalTheme(outerTheme, localTheme) {
     const mergedTheme = localTheme(outerTheme);
     return mergedTheme;
   }
-  return _extends$2({}, outerTheme, localTheme);
+  return _extends$1({}, outerTheme, localTheme);
 }
 
 /**
@@ -8922,7 +8956,7 @@ function RtlProvider(_ref) {
       value
     } = _ref,
     props = _objectWithoutPropertiesLoose(_ref, _excluded$d);
-  return /*#__PURE__*/jsxRuntimeExports.jsx(RtlContext.Provider, _extends$4({
+  return /*#__PURE__*/jsxRuntimeExports.jsx(RtlContext.Provider, _extends$1({
     value: value != null ? value : true
   }, props));
 }
@@ -8977,7 +9011,7 @@ function useThemeScoping(themeId, upperTheme, localTheme, isPrivate = false) {
     const resolvedTheme = themeId ? upperTheme[themeId] || upperTheme : upperTheme;
     if (typeof localTheme === 'function') {
       const mergedTheme = localTheme(resolvedTheme);
-      const result = themeId ? _extends$4({}, upperTheme, {
+      const result = themeId ? _extends$1({}, upperTheme, {
         [themeId]: mergedTheme
       }) : mergedTheme;
       // must return a function for the private theme to NOT merge with the upper theme.
@@ -8987,9 +9021,9 @@ function useThemeScoping(themeId, upperTheme, localTheme, isPrivate = false) {
       }
       return result;
     }
-    return themeId ? _extends$4({}, upperTheme, {
+    return themeId ? _extends$1({}, upperTheme, {
       [themeId]: localTheme
-    }) : _extends$4({}, upperTheme, localTheme);
+    }) : _extends$1({}, upperTheme, localTheme);
   }, [themeId, upperTheme, localTheme, isPrivate]);
 }
 
@@ -9037,8 +9071,8 @@ function adaptV4Theme(inputTheme) {
       props = {},
       styleOverrides = {}
     } = inputTheme,
-    other = _objectWithoutPropertiesLoose$1(inputTheme, _excluded$c);
-  const theme = _extends$5({}, other, {
+    other = _objectWithoutPropertiesLoose(inputTheme, _excluded$c);
+  const theme = _extends$1({}, other, {
     components: {}
   });
 
@@ -9072,13 +9106,13 @@ function adaptV4Theme(inputTheme) {
   // theme.mixins.gutters
   const breakpoints = createBreakpoints(inputTheme.breakpoints || {});
   const spacing = theme.spacing;
-  theme.mixins = _extends$5({
+  theme.mixins = _extends$1({
     gutters: (styles = {}) => {
-      return _extends$5({
+      return _extends$1({
         paddingLeft: spacing(2),
         paddingRight: spacing(2)
       }, styles, {
-        [breakpoints.up('sm')]: _extends$5({
+        [breakpoints.up('sm')]: _extends$1({
           paddingLeft: spacing(3),
           paddingRight: spacing(3)
         }, styles[breakpoints.up('sm')])
@@ -9089,9 +9123,9 @@ function adaptV4Theme(inputTheme) {
       type: typeInput,
       mode: modeInput
     } = palette,
-    paletteRest = _objectWithoutPropertiesLoose$1(palette, _excluded2$1);
+    paletteRest = _objectWithoutPropertiesLoose(palette, _excluded2$1);
   const finalMode = modeInput || typeInput || 'light';
-  theme.palette = _extends$5({
+  theme.palette = _extends$1({
     // theme.palette.text.hint
     text: {
       hint: finalMode === 'dark' ? 'rgba(255, 255, 255, 0.5)' : 'rgba(0, 0, 0, 0.38)'
@@ -9103,7 +9137,7 @@ function adaptV4Theme(inputTheme) {
 }
 
 function createMixins(breakpoints, mixins) {
-  return _extends$5({
+  return _extends$1({
     toolbar: {
       minHeight: 56,
       [breakpoints.up('xs')]: {
@@ -9120,22 +9154,22 @@ function createMixins(breakpoints, mixins) {
 
 var colorManipulator = {};
 
-var interopRequireDefault$1 = {exports: {}};
+var interopRequireDefault = {exports: {}};
 
-var hasRequiredInteropRequireDefault$1;
+var hasRequiredInteropRequireDefault;
 
-function requireInteropRequireDefault$1 () {
-	if (hasRequiredInteropRequireDefault$1) return interopRequireDefault$1.exports;
-	hasRequiredInteropRequireDefault$1 = 1;
+function requireInteropRequireDefault () {
+	if (hasRequiredInteropRequireDefault) return interopRequireDefault.exports;
+	hasRequiredInteropRequireDefault = 1;
 	(function (module) {
-		function _interopRequireDefault(obj) {
-		  return obj && obj.__esModule ? obj : {
-		    "default": obj
+		function _interopRequireDefault(e) {
+		  return e && e.__esModule ? e : {
+		    "default": e
 		  };
 		}
 		module.exports = _interopRequireDefault, module.exports.__esModule = true, module.exports["default"] = module.exports; 
-	} (interopRequireDefault$1));
-	return interopRequireDefault$1.exports;
+	} (interopRequireDefault));
+	return interopRequireDefault.exports;
 }
 
 var require$$1 = /*@__PURE__*/getAugmentedNamespace(formatMuiErrorMessage);
@@ -9148,7 +9182,7 @@ function requireColorManipulator () {
 	if (hasRequiredColorManipulator) return colorManipulator;
 	hasRequiredColorManipulator = 1;
 
-	var _interopRequireDefault = requireInteropRequireDefault$1();
+	var _interopRequireDefault = requireInteropRequireDefault();
 	Object.defineProperty(colorManipulator, "__esModule", {
 	  value: true
 	});
@@ -9736,7 +9770,7 @@ function createPalette(palette) {
       contrastThreshold = 3,
       tonalOffset = 0.2
     } = palette,
-    other = _objectWithoutPropertiesLoose$1(palette, _excluded$b);
+    other = _objectWithoutPropertiesLoose(palette, _excluded$b);
   const primary = palette.primary || getDefaultPrimary(mode);
   const secondary = palette.secondary || getDefaultSecondary(mode);
   const error = palette.error || getDefaultError(mode);
@@ -9758,7 +9792,7 @@ function createPalette(palette) {
     lightShade = 300,
     darkShade = 700
   }) => {
-    color = _extends$5({}, color);
+    color = _extends$1({}, color);
     if (!color.main && color[mainShade]) {
       color.main = color[mainShade];
     }
@@ -9779,9 +9813,9 @@ function createPalette(palette) {
     dark: dark$1,
     light: light$1
   };
-  const paletteOutput = deepmerge$1(_extends$5({
+  const paletteOutput = deepmerge$1(_extends$1({
     // A collection of common colors.
-    common: _extends$5({}, common),
+    common: _extends$1({}, common),
     // prevent mutable object.
     // The palette mode, can be light or dark.
     mode,
@@ -9866,10 +9900,10 @@ function createTypography(palette, typography) {
       allVariants,
       pxToRem: pxToRem2
     } = _ref,
-    other = _objectWithoutPropertiesLoose$1(_ref, _excluded$a);
+    other = _objectWithoutPropertiesLoose(_ref, _excluded$a);
   const coef = fontSize / 14;
   const pxToRem = pxToRem2 || (size => `${size / htmlFontSize * coef}rem`);
-  const buildVariant = (fontWeight, size, lineHeight, letterSpacing, casing) => _extends$5({
+  const buildVariant = (fontWeight, size, lineHeight, letterSpacing, casing) => _extends$1({
     fontFamily,
     fontWeight,
     fontSize: pxToRem(size),
@@ -9901,7 +9935,7 @@ function createTypography(palette, typography) {
       letterSpacing: 'inherit'
     }
   };
-  return deepmerge$1(_extends$5({
+  return deepmerge$1(_extends$1({
     htmlFontSize,
     pxToRem,
     fontFamily,
@@ -9968,18 +10002,18 @@ function getAutoHeightDuration(height) {
   return Math.round((4 + 15 * constant ** 0.25 + constant / 5) * 10);
 }
 function createTransitions(inputTransitions) {
-  const mergedEasing = _extends$5({}, easing, inputTransitions.easing);
-  const mergedDuration = _extends$5({}, duration, inputTransitions.duration);
+  const mergedEasing = _extends$1({}, easing, inputTransitions.easing);
+  const mergedDuration = _extends$1({}, duration, inputTransitions.duration);
   const create = (props = ['all'], options = {}) => {
     const {
         duration: durationOption = mergedDuration.standard,
         easing: easingOption = mergedEasing.easeInOut,
         delay = 0
       } = options;
-      _objectWithoutPropertiesLoose$1(options, _excluded$9);
+      _objectWithoutPropertiesLoose(options, _excluded$9);
     return (Array.isArray(props) ? props : [props]).map(animatedProp => `${animatedProp} ${typeof durationOption === 'string' ? durationOption : formatMs(durationOption)} ${easingOption} ${typeof delay === 'string' ? delay : formatMs(delay)}`).join(',');
   };
-  return _extends$5({
+  return _extends$1({
     getAutoHeightDuration,
     create
   }, inputTransitions, {
@@ -10009,7 +10043,7 @@ function createTheme(options = {}, ...args) {
       transitions: transitionsInput = {},
       typography: typographyInput = {}
     } = options,
-    other = _objectWithoutPropertiesLoose$1(options, _excluded$8);
+    other = _objectWithoutPropertiesLoose(options, _excluded$8);
   if (options.vars &&
   // The error should throw only for the root theme creation because user is not allowed to use a custom node `vars`.
   // `generateCssVars` is the closest identifier for checking that the `options` is a result of `extendTheme` with CSS variables so that user can create new theme for nested ThemeProvider.
@@ -10025,11 +10059,11 @@ function createTheme(options = {}, ...args) {
     shadows: shadows.slice(),
     typography: createTypography(palette, typographyInput),
     transitions: createTransitions(transitionsInput),
-    zIndex: _extends$5({}, zIndex)
+    zIndex: _extends$1({}, zIndex)
   });
   muiTheme = deepmerge$1(muiTheme, other);
   muiTheme = args.reduce((acc, argument) => deepmerge$1(acc, argument), muiTheme);
-  muiTheme.unstable_sxConfig = _extends$5({}, defaultSxConfig, other == null ? void 0 : other.unstable_sxConfig);
+  muiTheme.unstable_sxConfig = _extends$1({}, defaultSxConfig, other == null ? void 0 : other.unstable_sxConfig);
   muiTheme.unstable_sx = function sx(props) {
     return styleFunctionSx$1({
       sx: props,
@@ -10048,31 +10082,26 @@ function useTheme$1() {
 
 var createStyled$1 = {};
 
-var _extends$1 = {exports: {}};
+var _extends = {exports: {}};
 
 var hasRequired_extends;
 
 function require_extends () {
-	if (hasRequired_extends) return _extends$1.exports;
+	if (hasRequired_extends) return _extends.exports;
 	hasRequired_extends = 1;
 	(function (module) {
 		function _extends() {
-		  module.exports = _extends = Object.assign ? Object.assign.bind() : function (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 module.exports = _extends = Object.assign ? Object.assign.bind() : function (n) {
+		    for (var e = 1; e < arguments.length; e++) {
+		      var t = arguments[e];
+		      for (var r in t) ({}).hasOwnProperty.call(t, r) && (n[r] = t[r]);
 		    }
-		    return target;
-		  }, module.exports.__esModule = true, module.exports["default"] = module.exports;
-		  return _extends.apply(this, arguments);
+		    return n;
+		  }, module.exports.__esModule = true, module.exports["default"] = module.exports, _extends.apply(null, arguments);
 		}
 		module.exports = _extends, module.exports.__esModule = true, module.exports["default"] = module.exports; 
-	} (_extends$1));
-	return _extends$1.exports;
+	} (_extends));
+	return _extends.exports;
 }
 
 var objectWithoutPropertiesLoose = {exports: {}};
@@ -10083,17 +10112,14 @@ function requireObjectWithoutPropertiesLoose () {
 	if (hasRequiredObjectWithoutPropertiesLoose) return objectWithoutPropertiesLoose.exports;
 	hasRequiredObjectWithoutPropertiesLoose = 1;
 	(function (module) {
-		function _objectWithoutPropertiesLoose(source, excluded) {
-		  if (source == null) return {};
-		  var target = {};
-		  var sourceKeys = Object.keys(source);
-		  var key, i;
-		  for (i = 0; i < sourceKeys.length; i++) {
-		    key = sourceKeys[i];
-		    if (excluded.indexOf(key) >= 0) continue;
-		    target[key] = source[key];
+		function _objectWithoutPropertiesLoose(r, e) {
+		  if (null == r) return {};
+		  var t = {};
+		  for (var n in r) if ({}.hasOwnProperty.call(r, n)) {
+		    if (-1 !== e.indexOf(n)) continue;
+		    t[n] = r[n];
 		  }
-		  return target;
+		  return t;
 		}
 		module.exports = _objectWithoutPropertiesLoose, module.exports.__esModule = true, module.exports["default"] = module.exports; 
 	} (objectWithoutPropertiesLoose));
@@ -10118,7 +10144,7 @@ function requireCreateStyled () {
 	if (hasRequiredCreateStyled) return createStyled$1;
 	hasRequiredCreateStyled = 1;
 
-	var _interopRequireDefault = requireInteropRequireDefault$1();
+	var _interopRequireDefault = requireInteropRequireDefault();
 	Object.defineProperty(createStyled$1, "__esModule", {
 	  value: true
 	});
@@ -10374,21 +10400,21 @@ function ThemeProvider(_ref) {
   let {
       theme: themeInput
     } = _ref,
-    props = _objectWithoutPropertiesLoose$1(_ref, _excluded$7);
+    props = _objectWithoutPropertiesLoose(_ref, _excluded$7);
   const scopedTheme = themeInput[THEME_ID];
   let finalTheme = scopedTheme || themeInput;
   if (typeof themeInput !== 'function') {
     if (scopedTheme && !scopedTheme.vars) {
-      finalTheme = _extends$5({}, scopedTheme, {
+      finalTheme = _extends$1({}, scopedTheme, {
         vars: null
       });
     } else if (themeInput && !themeInput.vars) {
-      finalTheme = _extends$5({}, themeInput, {
+      finalTheme = _extends$1({}, themeInput, {
         vars: null
       });
     }
   }
-  return /*#__PURE__*/jsxRuntimeExports.jsx(ThemeProvider$1, _extends$5({}, props, {
+  return /*#__PURE__*/jsxRuntimeExports.jsx(ThemeProvider$1, _extends$1({}, props, {
     themeId: scopedTheme ? THEME_ID : undefined,
     theme: finalTheme
   }));
@@ -10398,43 +10424,19 @@ function useDefaultProps(params) {
   return useDefaultProps$1(params);
 }
 
-function _extends() {
-  _extends = Object.assign ? Object.assign.bind() : function (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 _setPrototypeOf(o, p) {
-  _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) {
-    o.__proto__ = p;
-    return o;
-  };
-  return _setPrototypeOf(o, p);
+function _setPrototypeOf(t, e) {
+  return _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function (t, e) {
+    return t.__proto__ = e, t;
+  }, _setPrototypeOf(t, e);
 }
 
-function _inheritsLoose(subClass, superClass) {
-  subClass.prototype = Object.create(superClass.prototype);
-  subClass.prototype.constructor = subClass;
-  _setPrototypeOf(subClass, superClass);
+function _inheritsLoose(t, o) {
+  t.prototype = Object.create(o.prototype), t.prototype.constructor = t, _setPrototypeOf(t, o);
 }
 
-function _assertThisInitialized(self) {
-  if (self === void 0) {
-    throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
-  }
-
-  return self;
+function _assertThisInitialized(e) {
+  if (void 0 === e) throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+  return e;
 }
 
 const buttonClasses = generateUtilityClasses('MuiButton', ['root', 'text', 'textInherit', 'textPrimary', 'textSecondary', 'textSuccess', 'textError', 'textInfo', 'textWarning', 'outlined', 'outlinedInherit', 'outlinedPrimary', 'outlinedSecondary', 'outlinedSuccess', 'outlinedError', 'outlinedInfo', 'outlinedWarning', 'contained', 'containedInherit', 'containedPrimary', 'containedSecondary', 'containedSuccess', 'containedError', 'containedInfo', 'containedWarning', 'disableElevation', 'focusVisible', 'disabled', 'colorInherit', 'colorPrimary', 'colorSecondary', 'colorSuccess', 'colorError', 'colorInfo', 'colorWarning', 'textSizeSmall', 'textSizeMedium', 'textSizeLarge', 'outlinedSizeSmall', 'outlinedSizeMedium', 'outlinedSizeLarge', 'containedSizeSmall', 'containedSizeMedium', 'containedSizeLarge', 'sizeMedium', 'sizeSmall', 'sizeLarge', 'fullWidth', 'startIcon', 'endIcon', 'icon', 'iconSizeSmall', 'iconSizeMedium', 'iconSizeLarge']);
@@ -10768,7 +10770,7 @@ function create$3(definition) {
   return cache[key];
 }
 
-const NEBULA_VERSION_HASH = "104b";
+const NEBULA_VERSION_HASH = "c387";
 ClassNameGenerator.configure(componentName => {
   return "njs-".concat(NEBULA_VERSION_HASH, "-").concat(componentName.replace('Mui', ''));
 });
@@ -11009,7 +11011,7 @@ function boot(_ref2) {
   const appRef = React__default.createRef();
   const element = document.createElement('div');
   element.style.display = 'none';
-  element.setAttribute('data-nebulajs-version', "5.12.6");
+  element.setAttribute('data-nebulajs-version', "5.13.0");
   element.setAttribute('data-app-id', app.id);
   document.body.appendChild(element);
   if (context) {
@@ -11031,7 +11033,8 @@ function boot(_ref2) {
   return [{
     toggleFocusOfCells(cellIdToFocus) {
       Object.keys(cells).forEach(i => {
-        cells[i].current.toggleFocus(i === cellIdToFocus);
+        var _cells$i$current;
+        (_cells$i$current = cells[i].current) === null || _cells$i$current === void 0 || _cells$i$current.toggleFocus(i === cellIdToFocus);
       });
     },
     cells,
@@ -11310,7 +11313,23 @@ function useRpc(model, method) {
 }
 
 function useLayout$1(model) {
-  return useRpc(model, 'getLayout');
+  const [layout, {
+    validating,
+    canCancel,
+    canRetry
+  }, longrunning] = useRpc(model, 'getLayout');
+  if (model !== null && model !== void 0 && model.pureLayout) {
+    return [model.pureLayout, {
+      validating,
+      canCancel,
+      canRetry
+    }, longrunning];
+  }
+  return [layout, {
+    validating,
+    canCancel,
+    canRetry
+  }, longrunning];
 }
 function useAppLayout$1(model) {
   return useRpc(model, 'getAppLayout');
@@ -11405,7 +11424,7 @@ function SvgIcon$1(_ref) {
     return (
       /*#__PURE__*/
       // eslint-disable-next-line react/no-array-index-key
-      React__default.createElement(Type, _extends$6({
+      React__default.createElement(Type, _extends$2({
         key: ix
       }, attrs))
     );
@@ -14285,7 +14304,7 @@ function createGridComponent(_ref2) {
         className: className,
         onScroll: this._onScroll,
         ref: this._outerRefSetter,
-        style: _extends({
+        style: _extends$1({
           position: 'relative',
           height: height,
           width: width,
@@ -14784,7 +14803,7 @@ function createListComponent(_ref) {
         className: className,
         onScroll: onScroll,
         ref: this._outerRefSetter,
-        style: _extends({
+        style: _extends$1({
           position: 'relative',
           height: height,
           width: width,
@@ -15339,7 +15358,7 @@ function getListBoxComponents(_ref) {
     local.current.listRef = ref;
     return /*#__PURE__*/React__default.createElement(StyledFixedSizeList
     // eslint-disable-next-line react/jsx-props-no-spreading
-    , _extends$6({}, commonComponentOptions, {
+    , _extends$2({}, commonComponentOptions, {
       dataTestid: "fixed-size-list",
       scrollDisabled: constraints === null || constraints === void 0 ? void 0 : constraints.active,
       height: listHeight,
@@ -15416,7 +15435,7 @@ function getListBoxComponents(_ref) {
     };
     return /*#__PURE__*/React__default.createElement(StyledFixedSizeGrid
     // eslint-disable-next-line react/jsx-props-no-spreading
-    , _extends$6({}, commonComponentOptions, {
+    , _extends$2({}, commonComponentOptions, {
       dataTestid: "fixed-size-grid",
       scrollDisabled: constraints === null || constraints === void 0 ? void 0 : constraints.active,
       height: gridHeight,
@@ -15809,7 +15828,8 @@ const StyledText = styled(Typography, {
   return _objectSpread2({
     minWidth: "".concat(width, "px"),
     textAlign: 'center',
-    fontSize: "".concat(dense ? '12px' : '14px')
+    fontSize: "".concat(dense ? '12px' : '14px'),
+    whiteSpace: 'normal'
   }, dense && {
     textOverflow: 'ellipsis',
     overflow: 'hidden',
@@ -15840,24 +15860,6 @@ function ListBoxDisclaimer(_ref2) {
 
 var Close$1 = {};
 
-var interopRequireDefault = {exports: {}};
-
-var hasRequiredInteropRequireDefault;
-
-function requireInteropRequireDefault () {
-	if (hasRequiredInteropRequireDefault) return interopRequireDefault.exports;
-	hasRequiredInteropRequireDefault = 1;
-	(function (module) {
-		function _interopRequireDefault(obj) {
-		  return obj && obj.__esModule ? obj : {
-		    "default": obj
-		  };
-		}
-		module.exports = _interopRequireDefault, module.exports.__esModule = true, module.exports["default"] = module.exports; 
-	} (interopRequireDefault));
-	return interopRequireDefault.exports;
-}
-
 var createSvgIcon$1 = {};
 
 function getSvgIconUtilityClass(slot) {
@@ -15933,9 +15935,9 @@ const SvgIcon = /*#__PURE__*/React.forwardRef(function SvgIcon(inProps, ref) {
       titleAccess,
       viewBox = '0 0 24 24'
     } = props,
-    other = _objectWithoutPropertiesLoose$1(props, _excluded$5);
+    other = _objectWithoutPropertiesLoose(props, _excluded$5);
   const hasSvgAsChild = /*#__PURE__*/React.isValidElement(children) && children.type === 'svg';
-  const ownerState = _extends$5({}, props, {
+  const ownerState = _extends$1({}, props, {
     color,
     component,
     fontSize,
@@ -15949,7 +15951,7 @@ const SvgIcon = /*#__PURE__*/React.forwardRef(function SvgIcon(inProps, ref) {
     more.viewBox = viewBox;
   }
   const classes = useUtilityClasses(ownerState);
-  return /*#__PURE__*/jsxRuntimeExports.jsxs(SvgIconRoot, _extends$5({
+  return /*#__PURE__*/jsxRuntimeExports.jsxs(SvgIconRoot, _extends$1({
     as: component,
     className: clsx(classes.root, className),
     focusable: "false",
@@ -15968,7 +15970,7 @@ SvgIcon.muiName = 'SvgIcon';
 
 function createSvgIcon(path, displayName) {
   function Component(props, ref) {
-    return /*#__PURE__*/jsxRuntimeExports.jsx(SvgIcon, _extends$5({
+    return /*#__PURE__*/jsxRuntimeExports.jsx(SvgIcon, _extends$1({
       "data-testid": `${displayName}Icon`,
       ref: ref
     }, props, {
@@ -16968,7 +16970,7 @@ const More$1 = React__default.forwardRef((_ref3, ref) => {
   const autoFocusIndex = actions.findIndex(action => !action.disabled);
   return showActions && /*#__PURE__*/React__default.createElement(StyledPopover$1
   // eslint-disable-next-line react/jsx-props-no-spreading
-  , _extends$6({}, popoverProps, {
+  , _extends$2({}, popoverProps, {
     onClose: onCloseOrActionClick,
     ref: ref,
     open: show,
@@ -18178,7 +18180,7 @@ function hasSelections(layout) {
 }
 
 /*
-* qlik-chart-modules v0.85.0
+* qlik-chart-modules v0.92.0
 * Copyright (c) 2025 QlikTech International AB
 * Released under the MIT license.
 */
@@ -20556,7 +20558,7 @@ function ListBoxHeader(_ref2) {
     autoConfirm,
     disablePortal
   });
-  const actionsToolbar = /*#__PURE__*/React__default.createElement(ActionsToolbar, _extends$6({
+  const actionsToolbar = /*#__PURE__*/React__default.createElement(ActionsToolbar, _extends$2({
     isRtl: isRtl,
     layout: layout
   }, toolbarProps));
@@ -22918,13 +22920,13 @@ function Progress(_ref2) {
   const s = SIZES[size];
   return /*#__PURE__*/React__default.createElement(Root, {
     className: classes$3.root
-  }, /*#__PURE__*/React__default.createElement(CircularProgress, _extends$6({
+  }, /*#__PURE__*/React__default.createElement(CircularProgress, _extends$2({
     variant: "determinate",
     value: 100,
     className: classes$3.back,
     size: s,
     thickness: 3
-  }, props)), /*#__PURE__*/React__default.createElement(CircularProgress, _extends$6({
+  }, props)), /*#__PURE__*/React__default.createElement(CircularProgress, _extends$2({
     variant: "indeterminate",
     disableShrink: true,
     className: classes$3.front,
@@ -22974,7 +22976,7 @@ function Cancel(_ref) {
     variant: "h6",
     align: "center",
     "data-tid": "update-active"
-  }, translator.get('Object.Update.Active')))), /*#__PURE__*/React__default.createElement(Grid, _extends$6({
+  }, translator.get('Object.Update.Active')))), /*#__PURE__*/React__default.createElement(Grid, _extends$2({
     item: true
   }, props), /*#__PURE__*/React__default.createElement(Button, {
     variant: "contained",
@@ -23001,7 +23003,7 @@ function Retry(_ref2) {
     "data-tid": "update-cancelled"
   }, translator.get('Object.Update.Cancelled'))), /*#__PURE__*/React__default.createElement(Grid, {
     item: true
-  }, /*#__PURE__*/React__default.createElement(Button, _extends$6({
+  }, /*#__PURE__*/React__default.createElement(Button, _extends$2({
     variant: "contained",
     onClick: retry
   }, props), translator.get('Retry'))));
@@ -23542,6 +23544,16 @@ const CellBody = {
   /** @type {'njs-cell-body'} */
   className: 'njs-cell-body'
 };
+function support(prop, supportObject, layout) {
+  const value = supportObject[prop];
+  if (typeof value === 'function') {
+    return value.call(null, layout);
+  }
+  if (typeof value === 'boolean') {
+    return value;
+  }
+  return false;
+}
 const initialState = err => ({
   loading: false,
   loaded: false,
@@ -23851,6 +23863,7 @@ const Cell = forwardRef((_ref6, ref) => {
     translator,
     language,
     keyboardNavigation,
+    externalFocusManagement,
     disableCellPadding = false
   } = useContext(InstanceContext);
   const [internalEmitter] = useState$1(emitter || createEmitter);
@@ -23890,16 +23903,20 @@ const Cell = forwardRef((_ref6, ref) => {
   });
   useEffect$1(() => {
     eventmixin(focusHandler.current);
+    focusHandler.current.blurCallback = resetFocus => {
+      if (focusHandler.current.onBlurHandler) {
+        focusHandler.current.onBlurHandler(resetFocus);
+        return;
+      }
+      halo.root.toggleFocusOfCells();
+      if (resetFocus && contentNode) {
+        contentNode.focus();
+      }
+    };
+    focusHandler.current.refocusContent = () => {
+      state.sn.component && typeof state.sn.component.focus === 'function' && state.sn.component.focus();
+    };
   }, []);
-  focusHandler.current.blurCallback = resetFocus => {
-    halo.root.toggleFocusOfCells();
-    if (resetFocus && contentNode) {
-      contentNode.focus();
-    }
-  };
-  focusHandler.current.refocusContent = () => {
-    state.sn.component && typeof state.sn.component.focus === 'function' && state.sn.component.focus();
-  };
   const handleOnMouseEnter = () => {
     if (hoveringDebouncer.current.leave) {
       clearTimeout(hoveringDebouncer.current.leave);
@@ -23984,7 +24001,6 @@ const Cell = forwardRef((_ref6, ref) => {
     load(layout.visualization, withVersion);
     return () => {};
   }, [types, state.sn, model, selections, layout, appLayout, language]);
-
   // Long running query
   useEffect$1(() => {
     if (!validating) {
@@ -24001,6 +24017,20 @@ const Cell = forwardRef((_ref6, ref) => {
     getQae() {
       return state.sn.generator.qae;
     },
+    getExtensionDefinition() {
+      return state.sn.generator.definition.ext;
+    },
+    // allow input of supportObject ot override when flipped to table
+    support(type, supportObject, outerLayout) {
+      if (layout && state.loaded && !state.error) {
+        var _state$sn$generator$d;
+        const suppObj = supportObject || ((_state$sn$generator$d = state.sn.generator.definition.ext) === null || _state$sn$generator$d === void 0 ? void 0 : _state$sn$generator$d.support);
+        if (suppObj) {
+          return support(type, suppObj, outerLayout || layout);
+        }
+      }
+      return false;
+    },
     toggleFocus(active) {
       if (typeof state.sn.component.focus === 'function') {
         if (active) {
@@ -24010,6 +24040,9 @@ const Cell = forwardRef((_ref6, ref) => {
         }
       }
     },
+    setOnBlurHandler(cb) {
+      focusHandler.current.onBlurHandler = cb;
+    },
     setSnOptions,
     setSnPlugins,
     setModel,
@@ -24140,8 +24173,8 @@ const Cell = forwardRef((_ref6, ref) => {
     focusHandler: focusHandler.current,
     titleStyles: titleStyles
   }, "\xA0"), /*#__PURE__*/React__default.createElement(Grid, {
-    tabIndex: keyboardNavigation ? 0 : -1,
-    onKeyDown: keyboardNavigation ? handleKeyDown : null,
+    tabIndex: keyboardNavigation && !externalFocusManagement ? 0 : -1,
+    onKeyDown: keyboardNavigation && !externalFocusManagement ? handleKeyDown : null,
     item: true,
     xs: true,
     className: CellBody.className,
@@ -24286,6 +24319,181 @@ const setProperties = (model, newProperties) => {
   return model.setProperties(newProperties);
 };
 
+const getFieldById = (fields, id) => fields.find(field => {
+  var _field$qDef;
+  return ((_field$qDef = field.qDef) === null || _field$qDef === void 0 ? void 0 : _field$qDef.cId) === id;
+}) || null;
+const setFieldProperties = hcFieldProperties => {
+  if (!hcFieldProperties) {
+    return [];
+  }
+  const updatedProperties = [...hcFieldProperties];
+  return updatedProperties.map(field => {
+    var _field$qDef2;
+    if ((_field$qDef2 = field.qDef) !== null && _field$qDef2 !== void 0 && _field$qDef2.autoSort && field.autoSort !== undefined) {
+      return _objectSpread2(_objectSpread2({}, field), {}, {
+        qDef: _objectSpread2(_objectSpread2({}, field.qDef), {}, {
+          autoSort: field.autoSort
+        }),
+        autoSort: undefined
+      });
+    }
+    return field;
+  });
+};
+const getHyperCube = (layout, path) => {
+  if (!layout) {
+    return undefined;
+  }
+  return path && utils(layout, path) ? utils(layout, path).qHyperCube : layout.qHyperCube;
+};
+
+class DataPropertyHandler {
+  constructor(opts) {
+    var _options$dimensionPro, _options$measurePrope;
+    const options = opts || {};
+    this.dimensionDefinition = options.dimensionDefinition || {
+      max: 0
+    };
+    this.measureDefinition = options.measureDefinition || {
+      max: 0
+    };
+    this.dimensionProperties = (_options$dimensionPro = options.dimensionProperties) !== null && _options$dimensionPro !== void 0 ? _options$dimensionPro : {};
+    this.measureProperties = (_options$measurePrope = options.measureProperties) !== null && _options$measurePrope !== void 0 ? _options$measurePrope : {};
+    this.globalChangeListeners = options.globalChangeListeners;
+    this.app = options.app;
+  }
+  setProperties(properties) {
+    var _this$properties;
+    this.properties = properties;
+    this.isAnalysisType = (_this$properties = this.properties) === null || _this$properties === void 0 || (_this$properties = _this$properties.metaData) === null || _this$properties === void 0 ? void 0 : _this$properties.isAnalysisType;
+  }
+  setGlobalChangeListeners(arr) {
+    this.globalChangeListeners = arr;
+  }
+  setLayout(layout) {
+    this.layout = layout;
+  }
+  static type() {
+    throw new Error('Must override this method');
+  }
+
+  // ----------------DIMENSION----------------
+
+  static getDimensions() {
+    return [];
+  }
+  getDimension(id) {
+    const dimensions = this.getDimensions();
+    const alternativeDimensions = this.getAlternativeDimensions();
+    const dim = getFieldById(dimensions, id);
+    const altDim = getFieldById(alternativeDimensions, id);
+    return dim !== null && dim !== void 0 ? dim : altDim;
+  }
+  static getAlternativeDimensions() {
+    throw new Error('Method not implemented.');
+  }
+
+  // ----------------MEASURE----------------
+
+  getMeasure(id) {
+    const measures = this.getMeasures();
+    const alternativeMeasures = this.getAlternativeMeasures();
+    const meas = getFieldById(measures, id);
+    const altMeas = getFieldById(alternativeMeasures, id);
+    return meas !== null && meas !== void 0 ? meas : altMeas;
+  }
+  static getMeasures() {
+    return [];
+  }
+  static getAlternativeMeasures() {
+    throw new Error('Method not implemented.');
+  }
+}
+
+// eslint-disable-next-line import/no-relative-packages
+class HyperCubeHandler extends DataPropertyHandler {
+  constructor(opts) {
+    super(opts);
+    this.path = opts.path;
+  }
+  setProperties(properties) {
+    var _this$hcProperties$qD, _this$hcProperties$qM, _this$hcProperties$qI, _this$hcProperties$qL, _this$hcProperties$qL2, _this$hcProperties$qL3, _this$hcProperties$qL4;
+    if (!properties) {
+      return;
+    }
+    super.setProperties(properties);
+    this.hcProperties = this.path ? utils.getValue(properties, "".concat(this.path, ".qHyperCubeDef")) : properties.qHyperCubeDef;
+    if (!this.hcProperties) {
+      return;
+    }
+
+    // Set defaults
+    this.hcProperties.qDimensions = (_this$hcProperties$qD = this.hcProperties.qDimensions) !== null && _this$hcProperties$qD !== void 0 ? _this$hcProperties$qD : [];
+    this.hcProperties.qMeasures = (_this$hcProperties$qM = this.hcProperties.qMeasures) !== null && _this$hcProperties$qM !== void 0 ? _this$hcProperties$qM : [];
+    this.hcProperties.qInterColumnSortOrder = (_this$hcProperties$qI = this.hcProperties.qInterColumnSortOrder) !== null && _this$hcProperties$qI !== void 0 ? _this$hcProperties$qI : [];
+    this.hcProperties.qLayoutExclude = (_this$hcProperties$qL = this.hcProperties.qLayoutExclude) !== null && _this$hcProperties$qL !== void 0 ? _this$hcProperties$qL : {
+      qHyperCubeDef: {
+        qDimensions: [],
+        qMeasures: []
+      }
+    };
+    this.hcProperties.qLayoutExclude.qHyperCubeDef = (_this$hcProperties$qL2 = this.hcProperties.qLayoutExclude.qHyperCubeDef) !== null && _this$hcProperties$qL2 !== void 0 ? _this$hcProperties$qL2 : {
+      qDimensions: [],
+      qMeasures: []
+    };
+    this.hcProperties.qLayoutExclude.qHyperCubeDef.qDimensions = (_this$hcProperties$qL3 = this.hcProperties.qLayoutExclude.qHyperCubeDef.qDimensions) !== null && _this$hcProperties$qL3 !== void 0 ? _this$hcProperties$qL3 : [];
+    this.hcProperties.qLayoutExclude.qHyperCubeDef.qMeasures = (_this$hcProperties$qL4 = this.hcProperties.qLayoutExclude.qHyperCubeDef.qMeasures) !== null && _this$hcProperties$qL4 !== void 0 ? _this$hcProperties$qL4 : [];
+    if (this.hcProperties.isHCEnabled && this.hcProperties.qDynamicScript.length === 0 && this.hcProperties.qMode === 'S') {
+      // this is only for line chart with forecast
+      this.hcProperties.qDynamicScript = [];
+    }
+
+    // Set auto-sort property (compatibility 0.85 -> 0.9),
+    // can probably be removed in 1.0
+    this.hcProperties.qDimensions = setFieldProperties(this.hcProperties.qDimensions);
+    this.hcProperties.qMeasures = setFieldProperties(this.hcProperties.qMeasures);
+  }
+
+  // ----------------------------------
+  // ----------- DIMENSIONS -----------
+  // ----------------------------------
+
+  getDimensions() {
+    return this.hcProperties ? this.hcProperties.qDimensions : [];
+  }
+  getAlternativeDimensions() {
+    var _this$hcProperties$qL5, _this$hcProperties;
+    return (_this$hcProperties$qL5 = (_this$hcProperties = this.hcProperties) === null || _this$hcProperties === void 0 || (_this$hcProperties = _this$hcProperties.qLayoutExclude) === null || _this$hcProperties === void 0 || (_this$hcProperties = _this$hcProperties.qHyperCubeDef) === null || _this$hcProperties === void 0 ? void 0 : _this$hcProperties.qDimensions) !== null && _this$hcProperties$qL5 !== void 0 ? _this$hcProperties$qL5 : [];
+  }
+  getDimensionLayout(cId) {
+    return this.getDimensionLayouts().filter(item => cId === item.cId)[0];
+  }
+  getDimensionLayouts() {
+    const hc = getHyperCube(this.layout, this.path);
+    return hc ? hc.qDimensionInfo : [];
+  }
+
+  // ----------------------------------
+  // ------------ MEASURES ------------
+  // ----------------------------------
+
+  getMeasures() {
+    return this.hcProperties ? this.hcProperties.qMeasures : [];
+  }
+  getAlternativeMeasures() {
+    var _this$hcProperties$qL6, _this$hcProperties2;
+    return (_this$hcProperties$qL6 = (_this$hcProperties2 = this.hcProperties) === null || _this$hcProperties2 === void 0 || (_this$hcProperties2 = _this$hcProperties2.qLayoutExclude) === null || _this$hcProperties2 === void 0 || (_this$hcProperties2 = _this$hcProperties2.qHyperCubeDef) === null || _this$hcProperties2 === void 0 ? void 0 : _this$hcProperties2.qMeasures) !== null && _this$hcProperties$qL6 !== void 0 ? _this$hcProperties$qL6 : [];
+  }
+  getMeasureLayouts() {
+    const hc = getHyperCube(this.layout, this.path);
+    return hc ? hc.qMeasureInfo : [];
+  }
+  getMeasureLayout(cId) {
+    return this.getMeasureLayouts().filter(item => cId === item.cId)[0];
+  }
+}
+
 /* eslint no-param-reassign: 0, no-restricted-globals: 0 */
 const extend = extend$1.bind(null, true);
 const JSONPatch = {};
@@ -26077,6 +26285,7 @@ function createWithHooks(generator, opts, galaxy) {
       layout: {},
       appLayout: {},
       keyboardNavigation: opts.keyboardNavigation,
+      externalFocusManagement: opts.externalFocusManagement || false,
       focusHandler: opts.focusHandler,
       constraints: forcedConstraints,
       interactions: forcedInteractions,
@@ -26207,6 +26416,11 @@ function createWithHooks(generator, opts, galaxy) {
       return generator.component.runMenu(this, menu, event, menuBuilder);
     },
     focus() {
+      const ref = generator.component.getImperativeHandle(this);
+      if (ref && typeof ref.focus === 'function') {
+        ref.focus();
+        return;
+      }
       generator.component.focus(this);
     },
     blur() {
@@ -26578,7 +26792,9 @@ function generatorFn(UserSN, galaxy) {
       const ss = create$2(generator, params, galaxy);
       return ss;
     },
-    definition: {}
+    definition: galaxy.flags.isEnabled('NEBULA_DATA_HANDLERS') ? {
+      dataHandler: opts => new HyperCubeHandler(opts)
+    } : {}
   };
   Object.keys(sn).forEach(key => {
     if (!generator[key]) {
@@ -26611,6 +26827,7 @@ const saveSoftProperties = (model, prevEffectiveProperties, effectiveProperties)
 
 const noopi$1 = () => {};
 function viz() {
+  var _halo$context;
   let {
     model,
     halo,
@@ -26626,6 +26843,9 @@ function viz() {
   let onMount = null;
   let onRenderResolve = null;
   let viewDataObjectId;
+  let originalExtensionDef;
+  let originalLayout;
+  let successfulRender = false;
   const mounted = new Promise(resolve => {
     onMount = resolve;
   });
@@ -26636,6 +26856,7 @@ function viz() {
     override === null || override === void 0 || override(); // from options.onInitialRender
     onRenderResolve(); // internal promise in viz to wait for render
     onRender(); // from RenderConfig
+    successfulRender = true;
   };
   let initialSnOptions = {};
   let initialSnPlugins = [];
@@ -26668,6 +26889,32 @@ function viz() {
       initialSnPlugins = plugins;
     }
   };
+  let newExperimental = {};
+  if ((_halo$context = halo.context) !== null && _halo$context !== void 0 && _halo$context.enablePrivateExperimental) {
+    // ===== undocumented experimental API - use at own risk ======
+    newExperimental = {
+      /**
+       *  @ignore
+       *  valid types: viewData, cssScaling, snapshot, exportData, exploration
+       *  questionable types: supportRefresh, quickMobile, fullscreen
+       *  deprecated?: sharing
+       *
+       */
+      support(type) {
+        if (mountedReference && successfulRender) {
+          var _originalExtensionDef;
+          return cellRef.current.support(type, (_originalExtensionDef = originalExtensionDef) === null || _originalExtensionDef === void 0 ? void 0 : _originalExtensionDef.support, originalLayout);
+        }
+        return false;
+      },
+      toggleFocus(focus) {
+        cellRef.current.toggleFocus(focus);
+      },
+      setOnBlurHandler(cb) {
+        cellRef.current.setOnBlurHandler(cb);
+      }
+    };
+  }
 
   /**
    * @class
@@ -26680,7 +26927,7 @@ function viz() {
    * });
    * viz.destroy();
    */
-  const api = /** @lends Viz# */{
+  const api = /** @lends Viz# */_objectSpread2(_objectSpread2({
     /**
      * The id of this visualization's generic object.
      * @type {string}
@@ -26798,15 +27045,26 @@ function viz() {
         });
         newModel = await halo.app.createSessionObject(propertyTree.qProperty);
         viewDataObjectId = newModel.id;
+        originalExtensionDef = cellRef.current.getExtensionDefinition();
+        originalLayout = await model.getLayout();
       } else if (viewDataObjectId && showDataView !== true) {
         newModel = model;
         await halo.app.destroySessionObject(viewDataObjectId);
         viewDataObjectId = undefined;
+        originalExtensionDef = undefined;
+        originalLayout = undefined;
       }
       if (newModel) {
         cellRef.current.setModel(newModel);
       }
     },
+    /**
+     * Whether or not the chart has the data view toggled on.
+     * @type {boolean}
+     */
+    get viewDataToggled() {
+      return viewDataObjectId !== undefined;
+    },
     /**
      * Listens to custom events from inside the visualization. See useEmitter
      * @param {string} eventName Event name to listen to
@@ -26840,7 +27098,8 @@ function viz() {
     async takeSnapshot() {
       await rendered;
       return cellRef.current.takeSnapshot();
-    },
+    }
+  }, newExperimental), {}, {
     // ===== unexposed experimental API - use at own risk ======
     __DO_NOT_USE__: {
       mount(element) {
@@ -26951,7 +27210,7 @@ function viz() {
     // setOptions() {}, // applied soft patch
     // resize() {},
     // show() {},
-  };
+  });
   return api;
 }