@glance-networks/agent-plugin
Version:
Glance Networks Agent Plugin
1,289 lines (1,288 loc) • 1.71 MB
JavaScript
var __defProp = Object.defineProperty;
var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
var _a, _b, _c, _d, _e;
import * as React from "react";
import React__default, { useState, useEffect, useRef, useMemo, cloneElement, useLayoutEffect, useCallback } from "react";
import { createPortal } from "react-dom";
function getDefaultExportFromCjs(x2) {
return x2 && x2.__esModule && Object.prototype.hasOwnProperty.call(x2, "default") ? x2["default"] : x2;
}
var jsxRuntime = { exports: {} };
var reactJsxRuntime_production_min = {};
/**
* @license React
* react-jsx-runtime.production.min.js
*
* Copyright (c) Facebook, Inc. and its affiliates.
*
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree.
*/
var hasRequiredReactJsxRuntime_production_min;
function requireReactJsxRuntime_production_min() {
if (hasRequiredReactJsxRuntime_production_min) return reactJsxRuntime_production_min;
hasRequiredReactJsxRuntime_production_min = 1;
var f = React__default, k = Symbol.for("react.element"), l = Symbol.for("react.fragment"), m = Object.prototype.hasOwnProperty, n = f.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED.ReactCurrentOwner, p = { key: true, ref: true, __self: true, __source: true };
function q(c, a, g) {
var b, d = {}, e = null, h = null;
void 0 !== g && (e = "" + g);
void 0 !== a.key && (e = "" + a.key);
void 0 !== a.ref && (h = a.ref);
for (b in a) m.call(a, b) && !p.hasOwnProperty(b) && (d[b] = a[b]);
if (c && c.defaultProps) for (b in a = c.defaultProps, a) void 0 === d[b] && (d[b] = a[b]);
return { $$typeof: k, type: c, key: e, ref: h, props: d, _owner: n.current };
}
reactJsxRuntime_production_min.Fragment = l;
reactJsxRuntime_production_min.jsx = q;
reactJsxRuntime_production_min.jsxs = q;
return reactJsxRuntime_production_min;
}
var reactJsxRuntime_development = {};
/**
* @license React
* react-jsx-runtime.development.js
*
* Copyright (c) Facebook, Inc. and its affiliates.
*
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree.
*/
var hasRequiredReactJsxRuntime_development;
function requireReactJsxRuntime_development() {
if (hasRequiredReactJsxRuntime_development) return reactJsxRuntime_development;
hasRequiredReactJsxRuntime_development = 1;
if (process.env.NODE_ENV !== "production") {
(function() {
var React2 = React__default;
var REACT_ELEMENT_TYPE = Symbol.for("react.element");
var REACT_PORTAL_TYPE = Symbol.for("react.portal");
var REACT_FRAGMENT_TYPE = Symbol.for("react.fragment");
var REACT_STRICT_MODE_TYPE = Symbol.for("react.strict_mode");
var REACT_PROFILER_TYPE = Symbol.for("react.profiler");
var REACT_PROVIDER_TYPE = Symbol.for("react.provider");
var REACT_CONTEXT_TYPE = Symbol.for("react.context");
var REACT_FORWARD_REF_TYPE = Symbol.for("react.forward_ref");
var REACT_SUSPENSE_TYPE = Symbol.for("react.suspense");
var REACT_SUSPENSE_LIST_TYPE = Symbol.for("react.suspense_list");
var REACT_MEMO_TYPE = Symbol.for("react.memo");
var REACT_LAZY_TYPE = Symbol.for("react.lazy");
var REACT_OFFSCREEN_TYPE = Symbol.for("react.offscreen");
var MAYBE_ITERATOR_SYMBOL = Symbol.iterator;
var FAUX_ITERATOR_SYMBOL = "@@iterator";
function getIteratorFn(maybeIterable) {
if (maybeIterable === null || typeof maybeIterable !== "object") {
return null;
}
var maybeIterator = MAYBE_ITERATOR_SYMBOL && maybeIterable[MAYBE_ITERATOR_SYMBOL] || maybeIterable[FAUX_ITERATOR_SYMBOL];
if (typeof maybeIterator === "function") {
return maybeIterator;
}
return null;
}
var ReactSharedInternals = React2.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
function error(format2) {
{
{
for (var _len2 = arguments.length, args = new Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) {
args[_key2 - 1] = arguments[_key2];
}
printWarning("error", format2, args);
}
}
}
function printWarning(level, format2, args) {
{
var ReactDebugCurrentFrame2 = ReactSharedInternals.ReactDebugCurrentFrame;
var stack = ReactDebugCurrentFrame2.getStackAddendum();
if (stack !== "") {
format2 += "%s";
args = args.concat([stack]);
}
var argsWithFormat = args.map(function(item) {
return String(item);
});
argsWithFormat.unshift("Warning: " + format2);
Function.prototype.apply.call(console[level], console, argsWithFormat);
}
}
var enableScopeAPI = false;
var enableCacheElement = false;
var enableTransitionTracing = false;
var enableLegacyHidden = false;
var enableDebugTracing = false;
var REACT_MODULE_REFERENCE;
{
REACT_MODULE_REFERENCE = Symbol.for("react.module.reference");
}
function isValidElementType(type) {
if (typeof type === "string" || typeof type === "function") {
return true;
}
if (type === REACT_FRAGMENT_TYPE || type === REACT_PROFILER_TYPE || enableDebugTracing || type === REACT_STRICT_MODE_TYPE || type === REACT_SUSPENSE_TYPE || type === REACT_SUSPENSE_LIST_TYPE || enableLegacyHidden || type === REACT_OFFSCREEN_TYPE || enableScopeAPI || enableCacheElement || enableTransitionTracing) {
return true;
}
if (typeof type === "object" && type !== null) {
if (type.$$typeof === REACT_LAZY_TYPE || type.$$typeof === REACT_MEMO_TYPE || type.$$typeof === REACT_PROVIDER_TYPE || type.$$typeof === REACT_CONTEXT_TYPE || type.$$typeof === REACT_FORWARD_REF_TYPE || // This needs to include all possible module reference object
// types supported by any Flight configuration anywhere since
// we don't know which Flight build this will end up being used
// with.
type.$$typeof === REACT_MODULE_REFERENCE || type.getModuleId !== void 0) {
return true;
}
}
return false;
}
function getWrappedName(outerType, innerType, wrapperName) {
var displayName = outerType.displayName;
if (displayName) {
return displayName;
}
var functionName = innerType.displayName || innerType.name || "";
return functionName !== "" ? wrapperName + "(" + functionName + ")" : wrapperName;
}
function getContextName(type) {
return type.displayName || "Context";
}
function getComponentNameFromType(type) {
if (type == null) {
return null;
}
{
if (typeof type.tag === "number") {
error("Received an unexpected object in getComponentNameFromType(). This is likely a bug in React. Please file an issue.");
}
}
if (typeof type === "function") {
return type.displayName || type.name || null;
}
if (typeof type === "string") {
return type;
}
switch (type) {
case REACT_FRAGMENT_TYPE:
return "Fragment";
case REACT_PORTAL_TYPE:
return "Portal";
case REACT_PROFILER_TYPE:
return "Profiler";
case REACT_STRICT_MODE_TYPE:
return "StrictMode";
case REACT_SUSPENSE_TYPE:
return "Suspense";
case REACT_SUSPENSE_LIST_TYPE:
return "SuspenseList";
}
if (typeof type === "object") {
switch (type.$$typeof) {
case REACT_CONTEXT_TYPE:
var context = type;
return getContextName(context) + ".Consumer";
case REACT_PROVIDER_TYPE:
var provider = type;
return getContextName(provider._context) + ".Provider";
case REACT_FORWARD_REF_TYPE:
return getWrappedName(type, type.render, "ForwardRef");
case REACT_MEMO_TYPE:
var outerName = type.displayName || null;
if (outerName !== null) {
return outerName;
}
return getComponentNameFromType(type.type) || "Memo";
case REACT_LAZY_TYPE: {
var lazyComponent = type;
var payload = lazyComponent._payload;
var init2 = lazyComponent._init;
try {
return getComponentNameFromType(init2(payload));
} catch (x2) {
return null;
}
}
}
}
return null;
}
var assign2 = Object.assign;
var disabledDepth = 0;
var prevLog;
var prevInfo;
var prevWarn;
var prevError;
var prevGroup;
var prevGroupCollapsed;
var prevGroupEnd;
function disabledLog() {
}
disabledLog.__reactDisabledLog = true;
function disableLogs() {
{
if (disabledDepth === 0) {
prevLog = console.log;
prevInfo = console.info;
prevWarn = console.warn;
prevError = console.error;
prevGroup = console.group;
prevGroupCollapsed = console.groupCollapsed;
prevGroupEnd = console.groupEnd;
var props = {
configurable: true,
enumerable: true,
value: disabledLog,
writable: true
};
Object.defineProperties(console, {
info: props,
log: props,
warn: props,
error: props,
group: props,
groupCollapsed: props,
groupEnd: props
});
}
disabledDepth++;
}
}
function reenableLogs() {
{
disabledDepth--;
if (disabledDepth === 0) {
var props = {
configurable: true,
enumerable: true,
writable: true
};
Object.defineProperties(console, {
log: assign2({}, props, {
value: prevLog
}),
info: assign2({}, props, {
value: prevInfo
}),
warn: assign2({}, props, {
value: prevWarn
}),
error: assign2({}, props, {
value: prevError
}),
group: assign2({}, props, {
value: prevGroup
}),
groupCollapsed: assign2({}, props, {
value: prevGroupCollapsed
}),
groupEnd: assign2({}, props, {
value: prevGroupEnd
})
});
}
if (disabledDepth < 0) {
error("disabledDepth fell below zero. This is a bug in React. Please file an issue.");
}
}
}
var ReactCurrentDispatcher = ReactSharedInternals.ReactCurrentDispatcher;
var prefix2;
function describeBuiltInComponentFrame(name, source, ownerFn) {
{
if (prefix2 === void 0) {
try {
throw Error();
} catch (x2) {
var match = x2.stack.trim().match(/\n( *(at )?)/);
prefix2 = match && match[1] || "";
}
}
return "\n" + prefix2 + name;
}
}
var reentry = false;
var componentFrameCache;
{
var PossiblyWeakMap = typeof WeakMap === "function" ? WeakMap : Map;
componentFrameCache = new PossiblyWeakMap();
}
function describeNativeComponentFrame(fn, construct) {
if (!fn || reentry) {
return "";
}
{
var frame = componentFrameCache.get(fn);
if (frame !== void 0) {
return frame;
}
}
var control;
reentry = true;
var previousPrepareStackTrace = Error.prepareStackTrace;
Error.prepareStackTrace = void 0;
var previousDispatcher;
{
previousDispatcher = ReactCurrentDispatcher.current;
ReactCurrentDispatcher.current = null;
disableLogs();
}
try {
if (construct) {
var Fake = function() {
throw Error();
};
Object.defineProperty(Fake.prototype, "props", {
set: function() {
throw Error();
}
});
if (typeof Reflect === "object" && Reflect.construct) {
try {
Reflect.construct(Fake, []);
} catch (x2) {
control = x2;
}
Reflect.construct(fn, [], Fake);
} else {
try {
Fake.call();
} catch (x2) {
control = x2;
}
fn.call(Fake.prototype);
}
} else {
try {
throw Error();
} catch (x2) {
control = x2;
}
fn();
}
} catch (sample) {
if (sample && control && typeof sample.stack === "string") {
var sampleLines = sample.stack.split("\n");
var controlLines = control.stack.split("\n");
var s = sampleLines.length - 1;
var c = controlLines.length - 1;
while (s >= 1 && c >= 0 && sampleLines[s] !== controlLines[c]) {
c--;
}
for (; s >= 1 && c >= 0; s--, c--) {
if (sampleLines[s] !== controlLines[c]) {
if (s !== 1 || c !== 1) {
do {
s--;
c--;
if (c < 0 || sampleLines[s] !== controlLines[c]) {
var _frame = "\n" + sampleLines[s].replace(" at new ", " at ");
if (fn.displayName && _frame.includes("<anonymous>")) {
_frame = _frame.replace("<anonymous>", fn.displayName);
}
{
if (typeof fn === "function") {
componentFrameCache.set(fn, _frame);
}
}
return _frame;
}
} while (s >= 1 && c >= 0);
}
break;
}
}
}
} finally {
reentry = false;
{
ReactCurrentDispatcher.current = previousDispatcher;
reenableLogs();
}
Error.prepareStackTrace = previousPrepareStackTrace;
}
var name = fn ? fn.displayName || fn.name : "";
var syntheticFrame = name ? describeBuiltInComponentFrame(name) : "";
{
if (typeof fn === "function") {
componentFrameCache.set(fn, syntheticFrame);
}
}
return syntheticFrame;
}
function describeFunctionComponentFrame(fn, source, ownerFn) {
{
return describeNativeComponentFrame(fn, false);
}
}
function shouldConstruct(Component) {
var prototype = Component.prototype;
return !!(prototype && prototype.isReactComponent);
}
function describeUnknownElementTypeFrameInDEV(type, source, ownerFn) {
if (type == null) {
return "";
}
if (typeof type === "function") {
{
return describeNativeComponentFrame(type, shouldConstruct(type));
}
}
if (typeof type === "string") {
return describeBuiltInComponentFrame(type);
}
switch (type) {
case REACT_SUSPENSE_TYPE:
return describeBuiltInComponentFrame("Suspense");
case REACT_SUSPENSE_LIST_TYPE:
return describeBuiltInComponentFrame("SuspenseList");
}
if (typeof type === "object") {
switch (type.$$typeof) {
case REACT_FORWARD_REF_TYPE:
return describeFunctionComponentFrame(type.render);
case REACT_MEMO_TYPE:
return describeUnknownElementTypeFrameInDEV(type.type, source, ownerFn);
case REACT_LAZY_TYPE: {
var lazyComponent = type;
var payload = lazyComponent._payload;
var init2 = lazyComponent._init;
try {
return describeUnknownElementTypeFrameInDEV(init2(payload), source, ownerFn);
} catch (x2) {
}
}
}
}
return "";
}
var hasOwnProperty = Object.prototype.hasOwnProperty;
var loggedTypeFailures = {};
var ReactDebugCurrentFrame = ReactSharedInternals.ReactDebugCurrentFrame;
function setCurrentlyValidatingElement(element2) {
{
if (element2) {
var owner = element2._owner;
var stack = describeUnknownElementTypeFrameInDEV(element2.type, element2._source, owner ? owner.type : null);
ReactDebugCurrentFrame.setExtraStackFrame(stack);
} else {
ReactDebugCurrentFrame.setExtraStackFrame(null);
}
}
}
function checkPropTypes(typeSpecs, values, location, componentName, element2) {
{
var has2 = Function.call.bind(hasOwnProperty);
for (var typeSpecName in typeSpecs) {
if (has2(typeSpecs, typeSpecName)) {
var error$1 = void 0;
try {
if (typeof typeSpecs[typeSpecName] !== "function") {
var err = Error((componentName || "React class") + ": " + location + " type `" + typeSpecName + "` is invalid; it must be a function, usually from the `prop-types` package, but received `" + typeof typeSpecs[typeSpecName] + "`.This often happens because of typos such as `PropTypes.function` instead of `PropTypes.func`.");
err.name = "Invariant Violation";
throw err;
}
error$1 = typeSpecs[typeSpecName](values, typeSpecName, componentName, location, null, "SECRET_DO_NOT_PASS_THIS_OR_YOU_WILL_BE_FIRED");
} catch (ex) {
error$1 = ex;
}
if (error$1 && !(error$1 instanceof Error)) {
setCurrentlyValidatingElement(element2);
error("%s: type specification of %s `%s` is invalid; the type checker function must return `null` or an `Error` but returned a %s. You may have forgotten to pass an argument to the type checker creator (arrayOf, instanceOf, objectOf, oneOf, oneOfType, and shape all require an argument).", componentName || "React class", location, typeSpecName, typeof error$1);
setCurrentlyValidatingElement(null);
}
if (error$1 instanceof Error && !(error$1.message in loggedTypeFailures)) {
loggedTypeFailures[error$1.message] = true;
setCurrentlyValidatingElement(element2);
error("Failed %s type: %s", location, error$1.message);
setCurrentlyValidatingElement(null);
}
}
}
}
}
var isArrayImpl = Array.isArray;
function isArray(a) {
return isArrayImpl(a);
}
function typeName(value) {
{
var hasToStringTag = typeof Symbol === "function" && Symbol.toStringTag;
var type = hasToStringTag && value[Symbol.toStringTag] || value.constructor.name || "Object";
return type;
}
}
function willCoercionThrow(value) {
{
try {
testStringCoercion(value);
return false;
} catch (e) {
return true;
}
}
}
function testStringCoercion(value) {
return "" + value;
}
function checkKeyStringCoercion(value) {
{
if (willCoercionThrow(value)) {
error("The provided key is an unsupported type %s. This value must be coerced to a string before before using it here.", typeName(value));
return testStringCoercion(value);
}
}
}
var ReactCurrentOwner = ReactSharedInternals.ReactCurrentOwner;
var RESERVED_PROPS = {
key: true,
ref: true,
__self: true,
__source: true
};
var specialPropKeyWarningShown;
var specialPropRefWarningShown;
function hasValidRef(config) {
{
if (hasOwnProperty.call(config, "ref")) {
var getter = Object.getOwnPropertyDescriptor(config, "ref").get;
if (getter && getter.isReactWarning) {
return false;
}
}
}
return config.ref !== void 0;
}
function hasValidKey(config) {
{
if (hasOwnProperty.call(config, "key")) {
var getter = Object.getOwnPropertyDescriptor(config, "key").get;
if (getter && getter.isReactWarning) {
return false;
}
}
}
return config.key !== void 0;
}
function warnIfStringRefCannotBeAutoConverted(config, self2) {
{
if (typeof config.ref === "string" && ReactCurrentOwner.current && self2) ;
}
}
function defineKeyPropWarningGetter(props, displayName) {
{
var warnAboutAccessingKey = function() {
if (!specialPropKeyWarningShown) {
specialPropKeyWarningShown = true;
error("%s: `key` is not a prop. Trying to access it will result in `undefined` being returned. If you need to access the same value within the child component, you should pass it as a different prop. (https://reactjs.org/link/special-props)", displayName);
}
};
warnAboutAccessingKey.isReactWarning = true;
Object.defineProperty(props, "key", {
get: warnAboutAccessingKey,
configurable: true
});
}
}
function defineRefPropWarningGetter(props, displayName) {
{
var warnAboutAccessingRef = function() {
if (!specialPropRefWarningShown) {
specialPropRefWarningShown = true;
error("%s: `ref` is not a prop. Trying to access it will result in `undefined` being returned. If you need to access the same value within the child component, you should pass it as a different prop. (https://reactjs.org/link/special-props)", displayName);
}
};
warnAboutAccessingRef.isReactWarning = true;
Object.defineProperty(props, "ref", {
get: warnAboutAccessingRef,
configurable: true
});
}
}
var ReactElement = function(type, key, ref, self2, source, owner, props) {
var element2 = {
// This tag allows us to uniquely identify this as a React Element
$$typeof: REACT_ELEMENT_TYPE,
// Built-in properties that belong on the element
type,
key,
ref,
props,
// Record the component responsible for creating this element.
_owner: owner
};
{
element2._store = {};
Object.defineProperty(element2._store, "validated", {
configurable: false,
enumerable: false,
writable: true,
value: false
});
Object.defineProperty(element2, "_self", {
configurable: false,
enumerable: false,
writable: false,
value: self2
});
Object.defineProperty(element2, "_source", {
configurable: false,
enumerable: false,
writable: false,
value: source
});
if (Object.freeze) {
Object.freeze(element2.props);
Object.freeze(element2);
}
}
return element2;
};
function jsxDEV(type, config, maybeKey, source, self2) {
{
var propName;
var props = {};
var key = null;
var ref = null;
if (maybeKey !== void 0) {
{
checkKeyStringCoercion(maybeKey);
}
key = "" + maybeKey;
}
if (hasValidKey(config)) {
{
checkKeyStringCoercion(config.key);
}
key = "" + config.key;
}
if (hasValidRef(config)) {
ref = config.ref;
warnIfStringRefCannotBeAutoConverted(config, self2);
}
for (propName in config) {
if (hasOwnProperty.call(config, propName) && !RESERVED_PROPS.hasOwnProperty(propName)) {
props[propName] = config[propName];
}
}
if (type && type.defaultProps) {
var defaultProps2 = type.defaultProps;
for (propName in defaultProps2) {
if (props[propName] === void 0) {
props[propName] = defaultProps2[propName];
}
}
}
if (key || ref) {
var displayName = typeof type === "function" ? type.displayName || type.name || "Unknown" : type;
if (key) {
defineKeyPropWarningGetter(props, displayName);
}
if (ref) {
defineRefPropWarningGetter(props, displayName);
}
}
return ReactElement(type, key, ref, self2, source, ReactCurrentOwner.current, props);
}
}
var ReactCurrentOwner$1 = ReactSharedInternals.ReactCurrentOwner;
var ReactDebugCurrentFrame$1 = ReactSharedInternals.ReactDebugCurrentFrame;
function setCurrentlyValidatingElement$1(element2) {
{
if (element2) {
var owner = element2._owner;
var stack = describeUnknownElementTypeFrameInDEV(element2.type, element2._source, owner ? owner.type : null);
ReactDebugCurrentFrame$1.setExtraStackFrame(stack);
} else {
ReactDebugCurrentFrame$1.setExtraStackFrame(null);
}
}
}
var propTypesMisspellWarningShown;
{
propTypesMisspellWarningShown = false;
}
function isValidElement(object) {
{
return typeof object === "object" && object !== null && object.$$typeof === REACT_ELEMENT_TYPE;
}
}
function getDeclarationErrorAddendum() {
{
if (ReactCurrentOwner$1.current) {
var name = getComponentNameFromType(ReactCurrentOwner$1.current.type);
if (name) {
return "\n\nCheck the render method of `" + name + "`.";
}
}
return "";
}
}
function getSourceInfoErrorAddendum(source) {
{
return "";
}
}
var ownerHasKeyUseWarning = {};
function getCurrentComponentErrorInfo(parentType) {
{
var info = getDeclarationErrorAddendum();
if (!info) {
var parentName = typeof parentType === "string" ? parentType : parentType.displayName || parentType.name;
if (parentName) {
info = "\n\nCheck the top-level render call using <" + parentName + ">.";
}
}
return info;
}
}
function validateExplicitKey(element2, parentType) {
{
if (!element2._store || element2._store.validated || element2.key != null) {
return;
}
element2._store.validated = true;
var currentComponentErrorInfo = getCurrentComponentErrorInfo(parentType);
if (ownerHasKeyUseWarning[currentComponentErrorInfo]) {
return;
}
ownerHasKeyUseWarning[currentComponentErrorInfo] = true;
var childOwner = "";
if (element2 && element2._owner && element2._owner !== ReactCurrentOwner$1.current) {
childOwner = " It was passed a child from " + getComponentNameFromType(element2._owner.type) + ".";
}
setCurrentlyValidatingElement$1(element2);
error('Each child in a list should have a unique "key" prop.%s%s See https://reactjs.org/link/warning-keys for more information.', currentComponentErrorInfo, childOwner);
setCurrentlyValidatingElement$1(null);
}
}
function validateChildKeys(node, parentType) {
{
if (typeof node !== "object") {
return;
}
if (isArray(node)) {
for (var i = 0; i < node.length; i++) {
var child = node[i];
if (isValidElement(child)) {
validateExplicitKey(child, parentType);
}
}
} else if (isValidElement(node)) {
if (node._store) {
node._store.validated = true;
}
} else if (node) {
var iteratorFn = getIteratorFn(node);
if (typeof iteratorFn === "function") {
if (iteratorFn !== node.entries) {
var iterator = iteratorFn.call(node);
var step;
while (!(step = iterator.next()).done) {
if (isValidElement(step.value)) {
validateExplicitKey(step.value, parentType);
}
}
}
}
}
}
}
function validatePropTypes(element2) {
{
var type = element2.type;
if (type === null || type === void 0 || typeof type === "string") {
return;
}
var propTypes2;
if (typeof type === "function") {
propTypes2 = type.propTypes;
} else if (typeof type === "object" && (type.$$typeof === REACT_FORWARD_REF_TYPE || // Note: Memo only checks outer props here.
// Inner props are checked in the reconciler.
type.$$typeof === REACT_MEMO_TYPE)) {
propTypes2 = type.propTypes;
} else {
return;
}
if (propTypes2) {
var name = getComponentNameFromType(type);
checkPropTypes(propTypes2, element2.props, "prop", name, element2);
} else if (type.PropTypes !== void 0 && !propTypesMisspellWarningShown) {
propTypesMisspellWarningShown = true;
var _name = getComponentNameFromType(type);
error("Component %s declared `PropTypes` instead of `propTypes`. Did you misspell the property assignment?", _name || "Unknown");
}
if (typeof type.getDefaultProps === "function" && !type.getDefaultProps.isReactClassApproved) {
error("getDefaultProps is only used on classic React.createClass definitions. Use a static property named `defaultProps` instead.");
}
}
}
function validateFragmentProps(fragment) {
{
var keys = Object.keys(fragment.props);
for (var i = 0; i < keys.length; i++) {
var key = keys[i];
if (key !== "children" && key !== "key") {
setCurrentlyValidatingElement$1(fragment);
error("Invalid prop `%s` supplied to `React.Fragment`. React.Fragment can only have `key` and `children` props.", key);
setCurrentlyValidatingElement$1(null);
break;
}
}
if (fragment.ref !== null) {
setCurrentlyValidatingElement$1(fragment);
error("Invalid attribute `ref` supplied to `React.Fragment`.");
setCurrentlyValidatingElement$1(null);
}
}
}
var didWarnAboutKeySpread = {};
function jsxWithValidation(type, props, key, isStaticChildren, source, self2) {
{
var validType = isValidElementType(type);
if (!validType) {
var info = "";
if (type === void 0 || typeof type === "object" && type !== null && Object.keys(type).length === 0) {
info += " You likely forgot to export your component from the file it's defined in, or you might have mixed up default and named imports.";
}
var sourceInfo = getSourceInfoErrorAddendum();
if (sourceInfo) {
info += sourceInfo;
} else {
info += getDeclarationErrorAddendum();
}
var typeString;
if (type === null) {
typeString = "null";
} else if (isArray(type)) {
typeString = "array";
} else if (type !== void 0 && type.$$typeof === REACT_ELEMENT_TYPE) {
typeString = "<" + (getComponentNameFromType(type.type) || "Unknown") + " />";
info = " Did you accidentally export a JSX literal instead of a component?";
} else {
typeString = typeof type;
}
error("React.jsx: type is invalid -- expected a string (for built-in components) or a class/function (for composite components) but got: %s.%s", typeString, info);
}
var element2 = jsxDEV(type, props, key, source, self2);
if (element2 == null) {
return element2;
}
if (validType) {
var children2 = props.children;
if (children2 !== void 0) {
if (isStaticChildren) {
if (isArray(children2)) {
for (var i = 0; i < children2.length; i++) {
validateChildKeys(children2[i], type);
}
if (Object.freeze) {
Object.freeze(children2);
}
} else {
error("React.jsx: Static children should always be an array. You are likely explicitly calling React.jsxs or React.jsxDEV. Use the Babel transform instead.");
}
} else {
validateChildKeys(children2, type);
}
}
}
{
if (hasOwnProperty.call(props, "key")) {
var componentName = getComponentNameFromType(type);
var keys = Object.keys(props).filter(function(k) {
return k !== "key";
});
var beforeExample = keys.length > 0 ? "{key: someKey, " + keys.join(": ..., ") + ": ...}" : "{key: someKey}";
if (!didWarnAboutKeySpread[componentName + beforeExample]) {
var afterExample = keys.length > 0 ? "{" + keys.join(": ..., ") + ": ...}" : "{}";
error('A props object containing a "key" prop is being spread into JSX:\n let props = %s;\n <%s {...props} />\nReact keys must be passed directly to JSX without using spread:\n let props = %s;\n <%s key={someKey} {...props} />', beforeExample, componentName, afterExample, componentName);
didWarnAboutKeySpread[componentName + beforeExample] = true;
}
}
}
if (type === REACT_FRAGMENT_TYPE) {
validateFragmentProps(element2);
} else {
validatePropTypes(element2);
}
return element2;
}
}
function jsxWithValidationStatic(type, props, key) {
{
return jsxWithValidation(type, props, key, true);
}
}
function jsxWithValidationDynamic(type, props, key) {
{
return jsxWithValidation(type, props, key, false);
}
}
var jsx = jsxWithValidationDynamic;
var jsxs = jsxWithValidationStatic;
reactJsxRuntime_development.Fragment = REACT_FRAGMENT_TYPE;
reactJsxRuntime_development.jsx = jsx;
reactJsxRuntime_development.jsxs = jsxs;
})();
}
return reactJsxRuntime_development;
}
if (process.env.NODE_ENV === "production") {
jsxRuntime.exports = requireReactJsxRuntime_production_min();
} else {
jsxRuntime.exports = requireReactJsxRuntime_development();
}
var jsxRuntimeExports = jsxRuntime.exports;
const Cobrowse = (props) => {
return /* @__PURE__ */ jsxRuntimeExports.jsx(
"iframe",
{
src: props.url,
className: "glance-cobrowse-iframe",
title: "Cobrowse",
referrerPolicy: "no-referrer-when-downgrade",
allowFullScreen: true,
allow: "camera *;microphone *"
}
);
};
const baseurl = {
dev: "dev-www-build.myglance.org",
//To be changed to 'dev-www.myglance.org'
dw1: "dw1.myglance.org",
dw2: "dw2.myglance.org",
dw3: "dw3.myglance.org",
dw4: "dw4.myglance.org",
qa: "qa.myglance.org",
staging: "www.myglance.net",
beta: "beta.glance.net",
production: "www.glance.net"
};
const Logo$1 = (props) => {
const color2 = props.color || "#019ada";
return /* @__PURE__ */ jsxRuntimeExports.jsxs(
"svg",
{
className: "glance-logo",
id: "uuid-3dcb1d1f-954e-41f3-87a8-da702614a98d",
xmlns: "http://www.w3.org/2000/svg",
viewBox: "0 0 191 294",
children: [
/* @__PURE__ */ jsxRuntimeExports.jsx(
"rect",
{
className: "uuid-872a4a21-0cac-4dba-9ba0-c09d2a317485",
fill: color2,
x: "105",
y: "105",
width: "84",
height: "84"
}
),
/* @__PURE__ */ jsxRuntimeExports.jsx(
"path",
{
className: "uuid-872a4a21-0cac-4dba-9ba0-c09d2a317485",
fill: color2,
d: "m105,209h84c0,46.361-37.639,84-84,84h0v-84h0Z"
}
),
/* @__PURE__ */ jsxRuntimeExports.jsx(
"path",
{
className: "uuid-872a4a21-0cac-4dba-9ba0-c09d2a317485",
fill: color2,
d: "m105,1h0c46.361,0,84,37.639,84,84h-84V1h0Z"
}
),
/* @__PURE__ */ jsxRuntimeExports.jsx(
"path",
{
className: "uuid-872a4a21-0cac-4dba-9ba0-c09d2a317485",
fill: color2,
d: "m1,105h84v84h0C38.639,189,1,151.361,1,105h0Z"
}
),
/* @__PURE__ */ jsxRuntimeExports.jsx(
"path",
{
className: "uuid-872a4a21-0cac-4dba-9ba0-c09d2a317485",
fill: color2,
d: "m1,209h84v84h0c-46.361,0-84-37.639-84-84h0Z"
}
),
/* @__PURE__ */ jsxRuntimeExports.jsx(
"path",
{
className: "uuid-872a4a21-0cac-4dba-9ba0-c09d2a317485",
fill: color2,
d: "m85,1h0v84H1C1,38.639,38.639,1,85,1Z"
}
)
]
}
);
};
const sessionInvite = async (config, invite) => {
const url = `https://${config.baseUrl}/api/SessionInvitation/smsInvite?groupid=${config.groupId}`;
const headers = {
Authorization: `Bearer GKEY ${config.groupId}&${encodeURIComponent(
config.puid
)}&${config.loginKey}`,
"Content-Type": "application/json"
};
const response = await fetch(url, {
method: "POST",
headers,
body: JSON.stringify(invite)
});
if (response == null ? void 0 : response.ok) {
const result2 = response.json();
return result2;
} else {
const rejectReason = new Error("ExternalServiceError");
if (response == null ? void 0 : response.status) {
const responseDetails = await response.json();
if (["ExternalError", "InvalidParameter"].includes(responseDetails == null ? void 0 : responseDetails.code)) {
rejectReason.name = "ExternalServiceHandledError";
rejectReason.message = responseDetails == null ? void 0 : responseDetails.detail;
}
}
return new Promise((resolve, reject) => {
reject(rejectReason);
});
}
};
const GlanceAgent = function() {
var goog = goog || {};
goog.global = this || self;
goog.exportPath_ = function($name$$, $object$$, $overwriteImplicit$$, $cur_objectToExportTo$$) {
$name$$ = $name$$.split(".");
$cur_objectToExportTo$$ = $cur_objectToExportTo$$ || goog.global;
$name$$[0] in $cur_objectToExportTo$$ || "undefined" == typeof $cur_objectToExportTo$$.execScript || $cur_objectToExportTo$$.execScript("var " + $name$$[0]);
for (var $part$$; $name$$.length && ($part$$ = $name$$.shift()); ) {
if ($name$$.length || void 0 === $object$$) {
$cur_objectToExportTo$$ = $cur_objectToExportTo$$[$part$$] && $cur_objectToExportTo$$[$part$$] !== Object.prototype[$part$$] ? $cur_objectToExportTo$$[$part$$] : $cur_objectToExportTo$$[$part$$] = {};
} else {
if (!$overwriteImplicit$$ && goog.isObject($object$$) && goog.isObject($cur_objectToExportTo$$[$part$$])) {
for (var $prop$$ in $object$$) {
$object$$.hasOwnProperty($prop$$) && ($cur_objectToExportTo$$[$part$$][$prop$$] = $object$$[$prop$$]);
}
} else {
$cur_objectToExportTo$$[$part$$] = $object$$;
}
}
}
};
goog.define = function($name$$, $defaultValue$jscomp$2_value$$) {
return $defaultValue$jscomp$2_value$$;
};
goog.FEATURESET_YEAR = 2012;
goog.DEBUG = true;
goog.LOCALE = "en";
goog.TRUSTED_SITE = true;
goog.DISALLOW_TEST_ONLY_CODE = !goog.DEBUG;
goog.ENABLE_CHROME_APP_SAFE_SCRIPT_LOADING = false;
goog.provide = function($name$$) {
if (goog.isInModuleLoader_()) {
throw Error("goog.provide cannot be used within a module.");
}
goog.constructNamespace_($name$$);
};
goog.constructNamespace_ = function($name$$, $object$$, $overwriteImplicit$$) {
goog.exportPath_($name$$, $object$$, $overwriteImplicit$$);
};
goog.getScriptNonce = function($opt_window$$) {
if ($opt_window$$ && $opt_window$$ != goog.global) {
return goog.getScriptNonce_($opt_window$$.document);
}
null === goog.cspNonce_ && (goog.cspNonce_ = goog.getScriptNonce_(goog.global.document));
return goog.cspNonce_;
};
goog.NONCE_PATTERN_ = /^[\w+/_-]+[=]{0,2}$/;
goog.cspNonce_ = null;
goog.getScriptNonce_ = function($doc_nonce_script$$) {
return ($doc_nonce_script$$ = $doc_nonce_script$$.querySelector && $doc_nonce_script$$.querySelector("script[nonce]")) && ($doc_nonce_script$$ = $doc_nonce_script$$.nonce || $doc_nonce_script$$.getAttribute("nonce")) && goog.NONCE_PATTERN_.test($doc_nonce_script$$) ? $doc_nonce_script$$ : "";
};
goog.VALID_MODULE_RE_ = /^[a-zA-Z_$][a-zA-Z0-9._$]*$/;
goog.module = function($name$$) {
if ("string" !== typeof $name$$ || !$name$$ || -1 == $name$$.search(goog.VALID_MODULE_RE_)) {
throw Error("Invalid module identifier");
}
if (!goog.isInGoogModuleLoader_()) {
throw Error(
"Module " + $name$$ + " has been loaded incorrectly. Note, modules cannot be loaded as normal scripts. They require some kind of pre-processing step. You're likely trying to load a module via a script tag or as a part of a concatenated bundle without rewriting the module. For more info see: https://github.com/google/closure-library/wiki/goog.module:-an-ES6-module-like-alternative-to-goog.provide."
);
}
if (goog.moduleLoaderState_.moduleName) {
throw Error("goog.module may only be called once per module.");
}
goog.moduleLoaderState_.moduleName = $name$$;
};
goog.module.get = function($name$$) {
return goog.module.getInternal_($name$$);
};
goog.module.getInternal_ = function($name$$) {
return null;
};
goog.ModuleType = { ES6: "es6", GOOG: "goog" };
goog.moduleLoaderState_ = null;
goog.isInModuleLoader_ = function() {
return goog.isInGoogModuleLoader_() || goog.isInEs6ModuleLoader_();
};
goog.isInGoogModuleLoader_ = function() {
return !!goog.moduleLoaderState_ && goog.moduleLoaderState_.type == goog.ModuleType.GOOG;
};
goog.isInEs6ModuleLoader_ = function() {
if (goog.moduleLoaderState_ && goog.moduleLoaderState_.type == goog.ModuleType.ES6) {
return true;
}
var $jscomp$$ = goog.global.$jscomp;
return $jscomp$$ ? "function" != typeof $jscomp$$.getCurrentModulePath ? false : !!$jscomp$$.getCurrentModulePath() : false;
};
goog.module.declareLegacyNamespace = function() {
goog.moduleLoaderState_.declareLegacyNamespace = true;
};
goog.declareModuleId = function($namespace$$) {
if (goog.moduleLoaderState_) {
goog.moduleLoaderState_.moduleName = $namespace$$;
} else {
var $exports_jscomp$$ = goog.global.$jscomp;
if (!$exports_jscomp$$ || "function" != typeof $exports_jscomp$$.getCurrentModulePath) {
throw Error(
'Module with namespace "' + $namespace$$ + '" has been loaded incorrectly.'
);
}
$exports_jscomp$$ = $exports_jscomp$$.require(
$exports_jscomp$$.getCurrentModulePath()
);
goog.loadedModules_[$namespace$$] = {
exports: $exports_jscomp$$,
type: goog.ModuleType.ES6,
moduleId: $namespace$$
};
}
};
goog.setTestOnly = function($opt_message$$) {
if (goog.DISALLOW_TEST_ONLY_CODE) {
throw $opt_message$$ = $opt_message$$ || "", Error(
"Importing test-only code into non-debug environment" + ($opt_message$$ ? ": " + $opt_message$$ : ".")
);
}
};
goog.forwardDeclare = function($name$$) {
};
goog.getObjectByName = function($name$jscomp$83_parts$$, $cur$$) {
$name$jscomp$83_parts$$ = $name$jscomp$83_parts$$.split(".");
$cur$$ = $cur$$ || goog.global;
for (var $i$$ = 0; $i$$ < $name$jscomp$83_parts$$.length; $i$$++) {
if ($cur$$ = $cur$$[$name$jscomp$83_parts$$[$i$$]], null == $cur$$) {
return null;
}
}
return $cur$$;
};
goog.addDependency = function($relPath$$, $provides$$, $requires$$, $opt_loadFlags$$) {
};
goog.ENABLE_DEBUG_LOADER = true;
goog.logToConsole_ = function($msg$$) {
goog.global.console && goog.global.console.error($msg$$);
};
goog.require = function($namespace$$) {
};
goog.requireType = function($namespace$$) {
return {};
};
goog.basePath = "";
goog.nullFunction = function() {
};
goog.abstractMethod = function() {
throw Error("unimplemented abstract method");
};
goog.addSingletonGetter = function($ctor$$) {
$ctor$$.instance_ = void 0;
$ctor$$.getInstance = function() {
if ($ctor$$.instance_) {
return $ctor$$.instance_;
}
goog.DEBUG && (goog.instantiatedSingletons_[goog.instantiatedSingletons_.length] = $ctor$$);
return $ctor$$.instance_ = new $ctor$$();
};
};
goog.instantiatedSingletons_ = [];
goog.LOAD_MODULE_USING_EVAL = true;
goog.SEAL_MODULE_EXPORTS = goog.DEBUG;
goog.loadedModules_ = {};
goog.DEPENDENCIES_ENABLED = false;
goog.TRANSPILE = "detect";
goog.ASSUME_ES_MODULES_TRANSPILED = false;
goog.TRANSPILE_TO_LANGUAGE = "";
goog.TRANSPILER = "transpile.js";
goog.hasBadLetScoping = null;
goog.loadModule = function($moduleDef$$) {
var $previousState$$ = goog.moduleLoaderState_;
try {
goog.moduleLoaderState_ = {
moduleName: "",
declareLegacyNamespace: false,
type: goog.ModuleType.GOOG
};
var $origExports$$ = {}, $exports$$2 = $origExports$$;
if ("function" === typeof $moduleDef$$) {
$exports$$2 = $moduleDef$$.call(void 0, $exports$$2);
} else if ("string" === typeof $moduleDef$$) {
$exports$$2 = goog.loadModuleFromSource_.call(
void 0,
$exports$$2,
$moduleDef$$
);
} else {
throw Error("Invalid module definition");
}
var $moduleName$$ = goog.moduleLoaderState_.moduleName;
if ("string" === typeof $moduleName$$ && $moduleName$$) {
goog.moduleLoaderState_.declareLegacyNamespace ? goog.constructNamespace_(
$moduleName$$,
$exports$$2,
$origExports$$ !== $exports$$2
) : goog.SEAL_MODULE_EXPORTS && Object.seal && "object" == typeof $exports$$2 && null != $exports$$2 && Object.seal($exports$$2), goog.loadedModules_[$moduleName$$] = {
exports: $exports$$2,
type: goog.ModuleType.GOOG,
moduleId: goog.moduleLoaderState_.moduleName
};
} else {
throw Error('Invalid module name "' + $moduleName$$ + '"');
}
} finally {
goog.moduleLoaderState_ = $previousState$$;
}
};
goog.loadModuleFromSource_ = function($exports$$, $JSCompiler_OptimizeArgumentsArray_p0$$) {
eval(
goog.CLOSURE_EVAL_PREFILTER_.createScript(
$JSCompiler_OptimizeArgumentsArray_p0$$
)
);
return $exports$$;
};
goog.normalizePath_ = function($components_path$$) {
$components_path$$ = $components_path$$.split("/");
for (var $i$$ = 0; $i$$ < $components_path$$.length; ) {
"." == $components_path$$[$i$$] ? $components_path$$.splice($i$$, 1) : $i$$ && ".." == $components_path$$[$i$$] && $components_path$$[$i$$ - 1] && ".." != $components_path$$[$i$$ - 1] ? $components_path$$.splice(--$i$$, 2) : $i$$++;
}
return $components_path$$.join("/");
};
goog.loadFileSync_ = function($src$$) {
if (goog.global.CLOSURE_LOAD_FILE_SYNC) {
return goog.global.CLOSURE_LOAD_FILE_SYNC($src$$);
}
try {
var $xhr$$ = new goog.global.XMLHttpRequest();
$xhr$$.open("get", $src$$, false);
$xhr$$.send();
return 0 == $xhr$$.status || 200 == $xhr$$.status ? $xhr$$.responseText : null;
} catch ($err$$) {
return null;
}
};
goog.transpile_ = function($code$jscomp$0$$, $path$jscomp$0$$, $target$$) {
var $jscomp$$ = goog.global.$jscomp;
$jscomp$$ || (goog.global.$jscomp = $jscomp$$ = {});
var $transpile$$ = $jscomp$$.transpile;