@nebula.js/stardust
Version:
Product and framework agnostic integration API for Qlik's Associative Engine
1,435 lines (1,309 loc) • 1.68 MB
JavaScript
/*
* @nebula.js/stardust v5.17.0
* Copyright (c) 2025 QlikTech International AB
* Released under the MIT license.
*/
import * as React from 'react';
import React__default, { useState as useState$1, useEffect as useEffect$1, forwardRef, useMemo as useMemo$1, useImperativeHandle as useImperativeHandle$1, useContext, useReducer, useCallback, useLayoutEffect as useLayoutEffect$1, PureComponent, useRef as useRef$1, createElement, Component } from 'react';
import ReactDOM$1 from 'react-dom';
import { CacheProvider, Global, ThemeContext as ThemeContext$1, css, keyframes } from '@emotion/react';
import { Checkbox, Radio, Typography, FormControlLabel, Box, Grid, Tooltip, Paper, IconButton, styled as styled$3, Popover, MenuList, MenuItem, ListItemIcon, Divider, OutlinedInput, InputAdornment, Badge, List, ListItem, Button, ButtonBase, CircularProgress, Icon } from '@mui/material';
import styled$2 from '@emotion/styled';
var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
function getDefaultExportFromCjs (x) {
return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
}
function getAugmentedNamespace(n) {
if (Object.prototype.hasOwnProperty.call(n, '__esModule')) return n;
var f = n.default;
if (typeof f == "function") {
var a = function a () {
var isInstance = false;
try {
isInstance = this instanceof a;
} catch {}
if (isInstance) {
return Reflect.construct(f, arguments, this.constructor);
}
return f.apply(this, arguments);
};
a.prototype = f.prototype;
} else a = {};
Object.defineProperty(a, '__esModule', {value: true});
Object.keys(n).forEach(function (k) {
var d = Object.getOwnPropertyDescriptor(n, k);
Object.defineProperty(a, k, d.get ? d : {
enumerable: true,
get: function () {
return n[k];
}
});
});
return a;
}
var runtime = {exports: {}};
/**
* Copyright (c) 2014-present, Facebook, Inc.
*
* 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;
};
// 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();
}
// 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();
function _asyncIterator(r) {
var n,
t,
o,
e = 2;
for ("undefined" != typeof Symbol && (t = Symbol.asyncIterator, o = Symbol.iterator); e--;) {
if (t && null != (n = r[t])) return n.call(r);
if (o && null != (n = r[o])) return new AsyncFromSyncIterator(n.call(r));
t = "@@asyncIterator", o = "@@iterator";
}
throw new TypeError("Object is not async iterable");
}
function AsyncFromSyncIterator(r) {
function AsyncFromSyncIteratorContinuation(r) {
if (Object(r) !== r) return Promise.reject(new TypeError(r + " is not an object."));
var n = r.done;
return Promise.resolve(r.value).then(function (r) {
return {
value: r,
done: n
};
});
}
return AsyncFromSyncIterator = function (r) {
this.s = r, this.n = r.next;
}, AsyncFromSyncIterator.prototype = {
s: null,
n: null,
next: function () {
return AsyncFromSyncIteratorContinuation(this.n.apply(this.s, arguments));
},
return: function (r) {
var n = this.s.return;
return void 0 === n ? Promise.resolve({
value: r,
done: true
}) : AsyncFromSyncIteratorContinuation(n.apply(this.s, arguments));
},
throw: function (r) {
var n = this.s.return;
return void 0 === n ? Promise.reject(r) : AsyncFromSyncIteratorContinuation(n.apply(this.s, arguments));
}
}, new AsyncFromSyncIterator(r);
}
function _defineProperty(e, r, t) {
return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, {
value: t,
enumerable: true,
configurable: true,
writable: true
}) : e[r] = t, e;
}
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$2.apply(null, arguments);
}
function ownKeys(e, r) {
var t = Object.keys(e);
if (Object.getOwnPropertySymbols) {
var o = Object.getOwnPropertySymbols(e);
r && (o = o.filter(function (r) {
return Object.getOwnPropertyDescriptor(e, r).enumerable;
})), t.push.apply(t, o);
}
return t;
}
function _objectSpread2(e) {
for (var r = 1; r < arguments.length; r++) {
var t = null != arguments[r] ? arguments[r] : {};
r % 2 ? ownKeys(Object(t), true).forEach(function (r) {
_defineProperty(e, r, t[r]);
}) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) {
Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r));
});
}
return e;
}
function _objectWithoutProperties(e, t) {
if (null == e) return {};
var o,
r,
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$1(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 t;
}
function _toPrimitive(t, r) {
if ("object" != typeof t || !t) return t;
var e = t[Symbol.toPrimitive];
if (void 0 !== e) {
var i = e.call(t, r);
if ("object" != typeof i) return i;
throw new TypeError("@@toPrimitive must return a primitive value.");
}
return ("string" === r ? String : Number)(t);
}
function _toPropertyKey(t) {
var i = _toPrimitive(t, "string");
return "symbol" == typeof i ? i : i + "";
}
const format = function () {
let message = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '';
let args = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
const arr = typeof args === 'string' || typeof args === 'number' ? [args] : args;
return message.replace(/\{(\d+)\}/g, (match, number) => typeof arr[number] !== 'undefined' ? arr[number] : match);
};
function translator() {
let {
initial = 'en-US',
fallback = 'en-US'
} = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
const dictionaries = {};
let currentLocale = initial;
/**
* @class Translator
*/
const api = /** @lends Translator# */{
/**
* Returns current locale.
* @param {string=} lang - language Locale to updated the currentLocale value
* @returns {string} current locale.
*/
language: lang => {
if (lang) {
currentLocale = lang;
}
return currentLocale;
},
/**
* Registers a string in multiple locales
* @param {object} item
* @param {string} item.id
* @param {object<string,string>} item.locale
* @example
* translator.add({
* id: 'company.hello_user',
* locale: {
* 'en-US': 'Hello {0}',
* 'sv-SE': 'Hej {0}'
* }
* });
* translator.get('company.hello_user', ['John']); // Hello John
*/
add: item => {
// TODO - disallow override?
const {
id,
locale
} = item;
Object.keys(locale).forEach(lang => {
if (!dictionaries[lang]) {
dictionaries[lang] = {};
}
dictionaries[lang][id] = locale[lang];
});
},
/**
* Translates a string for current locale.
* @param {string} str - ID of the registered string.
* @param {Array<string>=} args - Values passed down for string interpolation.
* @returns {string} The translated string.
*/
get(str, args) {
let v;
if (dictionaries[currentLocale] && typeof dictionaries[currentLocale][str] !== 'undefined') {
v = dictionaries[currentLocale][str];
} else if (dictionaries[fallback] && typeof dictionaries[fallback][str] !== 'undefined') {
v = dictionaries[fallback][str];
} else {
v = str;
}
return typeof args !== 'undefined' ? format(v, args) : v;
}
};
return api;
}
const locale = function () {
let {
initial = 'en-US',
fallback = 'en-US'
} = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
const t = translator({
initial,
fallback
});
return {
translator: t
};
};
var Accessibility_Object_NoTitle = {
id: "Accessibility.Object.NoTitle",
locale: {
"de-DE": "Kein Titel",
"en-US": "No title",
"es-ES": "Sin título",
"fr-FR": "Pas de titre",
"it-IT": "Nessun titolo",
"ja-JP": "タイトルなし",
"ko-KR": "제목 없음",
"nl-NL": "Geen titel",
"pl-PL": "Brak tytułu",
"pt-BR": "Sem título",
"ru-RU": "Без заголовка",
"sv-SE": "Ingen rubrik",
"tr-TR": "Başlık yok",
"zh-CN": "无标题",
"zh-TW": "無標題"
}
};
var Cancel$1 = {
id: "Cancel",
locale: {
"de-DE": "Abbrechen",
"en-US": "Cancel",
"es-ES": "Cancelar",
"fr-FR": "Annuler",
"it-IT": "Annulla",
"ja-JP": "キャンセル",
"ko-KR": "취소",
"nl-NL": "Annuleren",
"pl-PL": "Anuluj",
"pt-BR": "Cancelar",
"ru-RU": "Отмена",
"sv-SE": "Avbryt",
"tr-TR": "İptal",
"zh-CN": "取消",
"zh-TW": "取消"
}
};
var CurrentSelections_All = {
id: "CurrentSelections.All",
locale: {
"de-DE": "ALLES",
"en-US": "ALL",
"es-ES": "TODOS",
"fr-FR": "TOUS",
"it-IT": "TUTTI",
"ja-JP": "すべて",
"ko-KR": "모두",
"nl-NL": "ALLE",
"pl-PL": "WSZYSTKO",
"pt-BR": "TODOS",
"ru-RU": "ВСЕ",
"sv-SE": "ALLA",
"tr-TR": "TÜMÜ",
"zh-CN": "全部",
"zh-TW": "全部"
}
};
var CurrentSelections_Of = {
id: "CurrentSelections.Of",
locale: {
"de-DE": "{0} von {1}",
"en-US": "{0} of {1}",
"es-ES": "{0} de {1}",
"fr-FR": "{0} sur {1}",
"it-IT": "{0} di {1}",
"ja-JP": "{0}/ {1}",
"ko-KR": "{0} / {1}",
"nl-NL": "{0} van {1}",
"pl-PL": "{0} z {1}",
"pt-BR": "{0} de {1}",
"ru-RU": "{0} из {1}",
"sv-SE": "{0} av {1}",
"tr-TR": "{0} / {1}",
"zh-CN": "{0}/ {1}",
"zh-TW": "{0}/ {1}"
}
};
var Listbox_Clear_Search = {
id: "Listbox.Clear.Search",
locale: {
"de-DE": "Suche löschen",
"en-US": "Clear search",
"es-ES": "Borrar búsqueda",
"fr-FR": "Effacer la recherche",
"it-IT": "Cancella ricerca",
"ja-JP": "検索をクリア",
"ko-KR": "검색 지우기",
"nl-NL": "Zoekopdracht wissen",
"pl-PL": "Wyczyść wyszukiwanie",
"pt-BR": "Limpar pesquisa",
"ru-RU": "Очистить поиск",
"sv-SE": "Radera sökning",
"tr-TR": "Aramayı temizle",
"zh-CN": "清除搜索",
"zh-TW": "清除搜尋"
}
};
var Listbox_Cyclic = {
id: "Listbox.Cyclic",
locale: {
"de-DE": "Zyklische Dimension",
"en-US": "Cyclic dimension",
"es-ES": "Dimensión cíclica",
"fr-FR": "Dimension cyclique",
"it-IT": "Dimensione ciclica",
"ja-JP": "サイクリック軸",
"ko-KR": "순환 차원",
"nl-NL": "Cyclische dimensie",
"pl-PL": "Wymiar cykliczny",
"pt-BR": "Dimensão cíclica",
"ru-RU": "Циклическое измерение",
"sv-SE": "Cyklisk dimension",
"tr-TR": "Döngüsel boyut",
"zh-CN": "循环维度",
"zh-TW": "循環維度"
}
};
var Listbox_Dismiss = {
id: "Listbox.Dismiss",
locale: {
"de-DE": "Schließen",
"en-US": "Dismiss",
"es-ES": "Descartar",
"fr-FR": "Ignorer",
"it-IT": "Ignora",
"ja-JP": "却下",
"ko-KR": "해제",
"nl-NL": "Overslaan",
"pl-PL": "Zamknij",
"pt-BR": "Ignorar",
"ru-RU": "Пропустить",
"sv-SE": "Hoppa över",
"tr-TR": "Kapat",
"zh-CN": "离开",
"zh-TW": "解除"
}
};
var Listbox_DrillDown = {
id: "Listbox.DrillDown",
locale: {
"de-DE": "Drilldown-Dimension",
"en-US": "Drill-down dimension",
"es-ES": "Dimensión jerárquica",
"fr-FR": "Dimension hiérarchique",
"it-IT": "Dimensione drill-down",
"ja-JP": "軸のドリルダウン",
"ko-KR": "드릴다운 차원",
"nl-NL": "Drill-downdimensie",
"pl-PL": "Wymiar hierarchiczny",
"pt-BR": "Dimensão de detalhamento",
"ru-RU": "Детализированное измерение",
"sv-SE": "Hierarkisk dimension",
"tr-TR": "Detaya inme boyutu",
"zh-CN": "钻取维度",
"zh-TW": "向下探查維度"
}
};
var Listbox_ItemsOverflow = {
id: "Listbox.ItemsOverflow",
locale: {
"de-DE": "Derzeit wird ein eingeschränkter Datensatz angezeigt, verwenden Sie die Suche, um die Größe zu reduzieren",
"en-US": "Currently showing a limited data set, use search to reduce the size",
"es-ES": "Actualmente se muestra un conjunto de datos limitado, utilice la búsqueda para reducir el tamaño",
"fr-FR": "Ensemble de données limité actuellement affiché. Utilisez la rechercher pour réduire la taille.",
"it-IT": "Attualmente visualizzato un set di dati limitato; utilizzare la ricerca per ridurre le dimensioni",
"ja-JP": "現在表示されているデータ セットは制限されているため、検索を使ってサイズを縮小してください",
"ko-KR": "현재 제한된 데이터 집합이 표시되고 있습니다. 검색을 사용하여 크기를 줄이십시오.",
"nl-NL": "Er wordt momenteel een beperkte gegevensverzameling getoond, gebruik Zoeken om de omvang te verkleinen",
"pl-PL": "Wyświetlany jest ograniczony zestaw danych. Użyj wyszukiwania, aby zmniejszyć rozmiar.",
"pt-BR": "Atualmente mostrando um conjunto de dados limitado, use a pesquisa para reduzir o tamanho",
"ru-RU": "Сейчас отображается ограниченный набор данных. Используйте поиск, чтобы уменьшить размер.",
"sv-SE": "En begränsad datauppsättning visas. Använd sök för att minska storleken",
"tr-TR": "Şu anda sınırlı bir veri kümesi gösteriliyor. Boyutu azaltmak için arama işlevini kullanın",
"zh-CN": "目前显示有限的数据集，使用搜索来减少大小",
"zh-TW": "目前顯示有限資料集，請使用搜尋減少大小"
}
};
var Listbox_Lock = {
id: "Listbox.Lock",
locale: {
"de-DE": "Auswahlen sperren",
"en-US": "Lock selections",
"es-ES": "Bloquear selecciones",
"fr-FR": "Verrouiller les sélections",
"it-IT": "Blocca selezioni",
"ja-JP": "選択をロック",
"ko-KR": "선택 내용 잠금",
"nl-NL": "Selecties vergrendelen",
"pl-PL": "Zablokuj wybory",
"pt-BR": "Bloquear seleções",
"ru-RU": "Заблокировать выборки",
"sv-SE": "Lås urval",
"tr-TR": "Seçimleri kilitle",
"zh-CN": "锁定选择项",
"zh-TW": "鎖定選項"
}
};
var Listbox_NoMatchesForYourTerms = {
id: "Listbox.NoMatchesForYourTerms",
locale: {
"de-DE": "Für Ihre Suche wurden keine Übereinstimmungen gefunden.",
"en-US": "There are no matches for your search.",
"es-ES": "No hay resultados para su búsqueda.",
"fr-FR": "Aucun résultat ne correspond à votre recherche.",
"it-IT": "Non è stata trovata alcuna corrispondenza per questa ricerca.",
"ja-JP": "検索に一致するものがありません。",
"ko-KR": "검색에 대해 일치하는 항목이 없습니다.",
"nl-NL": "Er zijn geen overeenkomsten voor uw zoekopdracht.",
"pl-PL": "Brak dopasowań dla tego wyszukiwania.",
"pt-BR": "Não há correspondências para sua pesquisa.",
"ru-RU": "Нет совпадений по вашему поисковому запросу.",
"sv-SE": "Det finns inga matchningar för din sökning.",
"tr-TR": "Aramanızla eşleşen sonuç yok.",
"zh-CN": "您的搜索条件没有任何匹配结果。",
"zh-TW": "沒有與您搜尋相符的項目。"
}
};
var Listbox_ResultFilterLabel = {
id: "Listbox.ResultFilterLabel",
locale: {
"de-DE": "Suchergebnisfilter",
"en-US": "Search Results Filter",
"es-ES": "Filtro de resultados de búsqueda",
"fr-FR": "Filtre de résultats de recherche",
"it-IT": "Filtro risultati Ricerca",
"ja-JP": "検索結果フィルター",
"ko-KR": "검색 결과 필터",
"nl-NL": "Filter voor zoekresultaten",
"pl-PL": "Filtr wyników wyszukiwania",
"pt-BR": "Filtro de resultados da pesquisa",
"ru-RU": "Фильтр результатов поиска",
"sv-SE": "Filter för sökresultat",
"tr-TR": "Arama Sonuçları Filtresi",
"zh-CN": "搜索结果筛选器",
"zh-TW": "搜尋結果篩選"
}
};
var Listbox_ScreenReader_SearchThenSelectionsMenu_WithAccSelMenu = {
id: "Listbox.ScreenReader.SearchThenSelectionsMenu.WithAccSelMenu",
locale: {
"de-DE": "Drücken Sie die Umschalttaste zusammen mit der Tabulatortaste, um den Fokus in die Suchleiste zu setzen, und dann erneut beide Tasten, um den Fokus in das Auswahlmenü zu setzen.",
"en-US": "Press Shift plus Tab to set focus on the search bar, then Shift plus Tab again to set focus on the selections menu.",
"es-ES": "Pulse Mayús + Tabulador para establecer el foco en la barra de búsqueda, luego Mayús + Tabulador nuevamente para establecer el foco en el menú de selecciones.",
"fr-FR": "Appuyez sur Maj + Tab pour mettre le focus sur la barre de recherche, puis de nouveau sur Maj + Tab pour mettre le focus sur le menu de sélections.",
"it-IT": "Premere MAIUSC+TAB per impostare lo stato attivo sulla barra di ricerca, quindi premere nuovamente MAIUSC+TAB per impostare lo stato attivo sul menu selezioni.",
"ja-JP": "Shift + Tab を押して検索バーにフォーカスを設定し、Shift + Tab をもう一度押して選択メニューにフォーカスを設定します。",
"ko-KR": "Shift+Tab을 눌러 검색 막대에 초점을 맞춘 다음 Shift+Tab을 다시 눌러 선택 메뉴에 초점을 맞추십시오.",
"nl-NL": "Druk op Shift + Tab om de focus in te stellen op de zoekbalk, druk vervolgens nogmaals op Shift + Tab om de focus in te stellen op het selectiemenu.",
"pl-PL": "Naciśnij Shift i Tab, aby ustawić ostrość na pasku wyszukiwania. Następnie ponownie użyj tej kombinacji klawiszy, aby ustawić ostrość na menu wyboru.",
"pt-BR": "Pressione Shift + Tab para definir o foco na barra de pesquisa e Shift + Tab novamente para definir o foco no menu de seleções.",
"ru-RU": "Нажмите клавиши SHIFT+TAB, чтобы переключиться на строку поиска. Затем снова нажмите клавиши SHIFT+TAB, чтобы переключиться на меню выбора.",
"sv-SE": "Tryck på Skift plus Tabb för att ställa in fokus på sökfältet, sedan Skift plus Tabb igen för att ställa in fokus på urvalsmenyn.",
"tr-TR": "Odağı arama çubuğuna ayarlamak için Shift ve Sekme tuşlarına birlikte basın, ardından bu tuşlara birlikte tekrar basarak odağı seçim menüsüne ayarlayın.",
"zh-CN": "按 Shift+Tab 在搜索栏上设置焦点，然后再次按 Shift+Tab 在“选择”菜单上设置焦点。",
"zh-TW": "按下 Shift 加 Tab 鍵以設定搜尋列上的焦點，然後再次按下 Shift 加 Tab 鍵，以設定選項功能表上的焦點。"
}
};
var Listbox_ScreenReader_SelectionMenu_WithAccSelMenu = {
id: "Listbox.ScreenReader.SelectionMenu.WithAccSelMenu",
locale: {
"de-DE": "Drücken Sie gleichzeitig die Umschalt- und die Tabulatortaste, um den Fokus in das Auswahlmenü zu setzen.",
"en-US": "Press Shift plus Tab to set focus on the selections menu.",
"es-ES": "Pulse Mayús + Tabulador para establecer el foco en el menú de selecciones.",
"fr-FR": "Appuyez sur Maj + Tab pour mettre le focus sur le menu de sélections.",
"it-IT": "Premere i tasti MAIUSC+TAB per evidenziare il menu di selezione.",
"ja-JP": "Shift キー + Tab キーを押して選択メニューにフォーカスを設定します。",
"ko-KR": "선택 메뉴에 초점을 설정하려면 Shift+Tab을 누르십시오.",
"nl-NL": "Druk op Shift + Tab om de focus in te stellen op het selectiemenu.",
"pl-PL": "Naciśnij Shift i Tab, aby ustawić ostrość na menu wyboru.",
"pt-BR": "Pressione Shift + Tab para definir o foco sobre o menu de seleções.",
"ru-RU": "Нажмите клавиши SHIFT+TAB, чтобы переключиться на меню выбора.",
"sv-SE": "Tryck på Skift plus Tabb när du vill ställa in fokus på urvalsmenyn.",
"tr-TR": "Odağı seçim menüsüne ayarlamak için Shift ve Sekme tuşlarına birlikte basın.",
"zh-CN": "按下 Shift 加 Tab 以将焦点设置在选择菜单上。",
"zh-TW": "按下 Shift 加 Tab 以在選項功能表上設定焦點。"
}
};
var Listbox_ScreenReaderInstructions = {
id: "Listbox.ScreenReaderInstructions",
locale: {
"de-DE": "Bei Aktivierung der Elemente unten wird der Seiteninhalt aktualisiert",
"en-US": "Activating the elements below will cause content on the page to be updated",
"es-ES": "La activación de los elementos siguientes hará que se actualice el contenido en la página",
"fr-FR": "L'activation des éléments ci-dessous actualisera le contenu de la page.",
"it-IT": "L'attivazione degli elementi sottostanti causerà l'aggiornamento del contenuto della pagina",
"ja-JP": "下記の要素をアクティブ化すると、ページのコンテンツが更新されます",
"ko-KR": "아래 요소를 활성화하면 페이지의 콘텐츠가 업데이트됩니다.",
"nl-NL": "Door de onderstaande elementen te activeren wordt de inhoud op de pagina bijgewerkt",
"pl-PL": "Aktywacja poniższych elementów spowoduje aktualizację zawartości na stronie",
"pt-BR": "A ativação dos elementos abaixo fará com que o conteúdo da página seja atualizado",
"ru-RU": "Активация приведенных ниже элементов приведет к обновлению содержимого страницы",
"sv-SE": "Om du aktiverar elementen nedan kommer innehåll på sidan att uppdateras",
"tr-TR": "Aşağıdaki öğeleri etkinleştirmek sayfadaki içeriğin güncellenmesine neden olur",
"zh-CN": "激活下面的元素将导致页面上的内容更新",
"zh-TW": "啟用以下元素將會造成更新頁面上的內容"
}
};
var Listbox_Search = {
id: "Listbox.Search",
locale: {
"de-DE": "In Listenfeld suchen",
"en-US": "Search in listbox",
"es-ES": "Buscar en cuadro de lista",
"fr-FR": "Rechercher dans la liste de sélection",
"it-IT": "Cerca nella casella di elenco",
"ja-JP": "リストボックス内を検索",
"ko-KR": "목록 상자에서 검색",
"nl-NL": "Zoeken in keuzelijst",
"pl-PL": "Wyszukaj w liście wartości",
"pt-BR": "Pesquisar na caixa de listagem",
"ru-RU": "Поиск в списке",
"sv-SE": "Sök i listruta",
"tr-TR": "Liste kutusunda ara",
"zh-CN": "在列表框中搜索",
"zh-TW": "在清單方塊中搜尋"
}
};
var Listbox_Search_ScreenReaderInstructions = {
id: "Listbox.Search.ScreenReaderInstructions",
locale: {
"de-DE": "Über das folgende Suchfeld werden Ergebnisse während der Eingabe gefiltert",
"en-US": "The following search field filters results below as you type",
"es-ES": "El siguiente campo de búsqueda filtra los resultados siguientes a medida que escribe",
"fr-FR": "Le champ de recherche suivant filtrer les résultats ci-dessous à mesure de votre saisie.",
"it-IT": "Il seguente campo di ricerca filtra i risultati man mano che vengono digitati",
"ja-JP": "次の検索フィールドは、入力と同時に下記の結果をフィルターします",
"ko-KR": "다음 검색 필드는 입력할 때 아래의 결과를 필터링합니다.",
"nl-NL": "Het volgende zoekveld filtert resultaten terwijl u typt",
"pl-PL": "Następujące pole wyszukiwania filtruje wyniki poniżej w miarę pisania",
"pt-BR": "O campo de pesquisa a seguir filtra os resultados abaixo conforme você digita",
"ru-RU": "Следующее поле поиска фильтрует результаты ниже по мере ввода текста",
"sv-SE": "Följande sökfält filtrerar resultaten nedan medan du skriver",
"tr-TR": "Aşağıdaki arama alanı siz yazarken aşağıdaki sonuçları filtreler",
"zh-CN": "键入时，以下搜索字段筛选结果如下",
"zh-TW": "下列搜尋欄位在您輸入時篩選以下結果"
}
};
var Listbox_Unlock = {
id: "Listbox.Unlock",
locale: {
"de-DE": "Auswahlen entsperren",
"en-US": "Unlock selections",
"es-ES": "Desbloquear selecciones",
"fr-FR": "Déverrouiller les sélections",
"it-IT": "Sblocca selezioni",
"ja-JP": "選択をロック解除",
"ko-KR": "선택 내용 잠금 해제",
"nl-NL": "Selecties ontgrendelen",
"pl-PL": "Odblokuj wybory",
"pt-BR": "Desbloquear seleções",
"ru-RU": "Разблокировать выборки",
"sv-SE": "Lås upp urval",
"tr-TR": "Seçimlerin kilidini aç",
"zh-CN": "将选择项解锁",
"zh-TW": "解鎖選項"
}
};
var Menu_More = {
id: "Menu.More",
locale: {
"de-DE": "Mehr",
"en-US": "More",
"es-ES": "Más",
"fr-FR": "Plus",
"it-IT": "Altro",
"ja-JP": "詳細",
"ko-KR": "자세히",
"nl-NL": "Meer",
"pl-PL": "Więcej",
"pt-BR": "Mais",
"ru-RU": "Дополнительно",
"sv-SE": "Mer",
"tr-TR": "Daha fazla",
"zh-CN": "更多",
"zh-TW": "更多"
}
};
var Navigate_Back = {
id: "Navigate.Back",
locale: {
"de-DE": "Schritt zurück",
"en-US": "Step back",
"es-ES": "Atrás",
"fr-FR": "Retour en arrière",
"it-IT": "Torna indietro",
"ja-JP": "1 段階戻る",
"ko-KR": "이전 단계",
"nl-NL": "Stap terug",
"pl-PL": "Krok do tyłu",
"pt-BR": "Voltar uma etapa",
"ru-RU": "Шаг назад",
"sv-SE": "Gå bakåt",
"tr-TR": "Bir adım geri",
"zh-CN": "后退",
"zh-TW": "倒退"
}
};
var Navigate_Forward = {
id: "Navigate.Forward",
locale: {