@telia-ace/widget-conversation-flamingo 1.0.0

package/dist/index-d8edc7b3.js

@@ -0,0 +1,4615 @@
+var Ws = Object.defineProperty, Ms = Object.defineProperties;
+var zs = Object.getOwnPropertyDescriptors;
+var ce = Object.getOwnPropertySymbols;
+var xt = Object.prototype.hasOwnProperty, Ct = Object.prototype.propertyIsEnumerable;
+var Ot = (s, e, t) => e in s ? Ws(s, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : s[e] = t, P = (s, e) => {
+  for (var t in e || (e = {}))
+    xt.call(e, t) && Ot(s, t, e[t]);
+  if (ce)
+    for (var t of ce(e))
+      Ct.call(e, t) && Ot(s, t, e[t]);
+  return s;
+}, W = (s, e) => Ms(s, zs(e));
+var Et = (s, e) => {
+  var t = {};
+  for (var n in s)
+    xt.call(s, n) && e.indexOf(n) < 0 && (t[n] = s[n]);
+  if (s != null && ce)
+    for (var n of ce(s))
+      e.indexOf(n) < 0 && Ct.call(s, n) && (t[n] = s[n]);
+  return t;
+};
+var b = (s, e, t) => new Promise((n, i) => {
+  var r = (c) => {
+    try {
+      a(t.next(c));
+    } catch (l) {
+      i(l);
+    }
+  }, o = (c) => {
+    try {
+      a(t.throw(c));
+    } catch (l) {
+      i(l);
+    }
+  }, a = (c) => c.done ? n(c.value) : Promise.resolve(c.value).then(r, o);
+  a((t = t.apply(s, e)).next());
+});
+const je = (s, e, t, ...n) => {
+  const i = `[${s.get("$environment").name || "webprovisions"}] ${t}`;
+  switch (e) {
+    case "info":
+      console.info(i, ...n);
+      break;
+    case "warning":
+      console.warn(i, ...n);
+      break;
+    case "error":
+      console.error(i, ...n);
+      break;
+  }
+}, Ls = (s) => {
+  const e = s.container || s;
+  return {
+    info: (t, ...n) => je(e, "info", t, ...n),
+    warn: (t, ...n) => je(e, "warning", t, ...n),
+    error: (t, ...n) => je(e, "error", t, ...n)
+  };
+};
+var ie = /* @__PURE__ */ ((s) => (s.Implementation = "implementation", s.Widget = "widget", s))(ie || {}), L = /* @__PURE__ */ ((s) => (s.Pre = "pre", s.Post = "post", s))(L || {});
+const Rs = (s, e, t, n) => {
+  try {
+    const i = new e(t, n);
+    return {
+      name: s,
+      invoke: (r, o) => {
+        let a;
+        return i[r] && (a = i[r].call(i, o)), Promise.resolve(a);
+      },
+      getInstance: () => i
+    };
+  } catch (i) {
+    if (i.message && i.message.indexOf("is not a constructor") >= 0)
+      return {
+        name: s,
+        invoke: (r) => {
+          let o;
+          return r === "initialize" && (o = e(t, n)), Promise.resolve(o);
+        },
+        getInstance: () => e
+      };
+    throw i;
+  }
+};
+function At(s, e) {
+  return typeof s == "undefined" ? e : s;
+}
+let Vs = class {
+  constructor(e = {}) {
+    this.part = e;
+  }
+  createCommand(e, t, n) {
+    let i;
+    typeof t == "function" ? i = {
+      scope: ie.Widget,
+      stage: L.Post,
+      defaultArgs: void 0,
+      handlerResolver: t
+    } : i = {
+      scope: At(t.scope, ie.Widget),
+      stage: At(t.stage, L.Post),
+      defaultArgs: t.defaultArgs,
+      handlerResolver: n
+    };
+    let r = this.part;
+    const o = e.split(".");
+    return o.forEach((a, c) => {
+      c === o.length - 1 ? r[a] || (r[a] = () => i) : r = this.part[a] = this.part[a] || {};
+    }), this;
+  }
+  get() {
+    return this.part;
+  }
+};
+const os = (s) => {
+  const e = new Vs({});
+  return s(e), e.get();
+};
+os((s) => {
+  s.createCommand(
+    "types.register",
+    { scope: ie.Implementation, stage: L.Pre },
+    (e) => (t, n) => {
+      e.container.get("$types")[t] = n;
+    }
+  ).createCommand(
+    "type",
+    { stage: L.Pre },
+    (e) => (t) => {
+      e.container.register("$type", t);
+    }
+  ).createCommand(
+    "settings",
+    { stage: L.Pre, defaultArgs: [null] },
+    (e) => (t) => {
+      e.events.dispatch(
+        "settings:change",
+        t,
+        { bubbles: !0 }
+      ), e.container.register("$settings", t);
+    }
+  ).createCommand(
+    "plugin",
+    { stage: L.Pre },
+    (e) => (t, n, i) => {
+      const { container: r } = e;
+      let o = null, a = t, c = n;
+      typeof t == "string" && (o = t, a = n, c = i);
+      const l = (h) => {
+        const { transformPluginSettings: d } = e.container.get("$environmentOptions"), p = d ? d(
+          c || {},
+          o,
+          e.container,
+          a
+        ) : n;
+        try {
+          const u = Rs(
+            o,
+            a,
+            r,
+            p
+          );
+          r.get("$plugins").push(u), h && u.invoke("initialize", null);
+        } catch (u) {
+          Ls(e).warn("Error when initializing plugin", u);
+        }
+      };
+      e.container.get("$instance") ? l(!0) : e.events.subscribeOnce("widget:instance-created", () => l(!1));
+    }
+  ).createCommand(
+    "container.register",
+    (e) => (t, n) => {
+      e.container.register(t, n);
+    }
+  ).createCommand(
+    "container.registerAsync",
+    (e) => (t, n) => {
+      e.container.registerAsync(t, n);
+    }
+  ).createCommand(
+    "container.registerFactory",
+    (e) => (t, n) => {
+      e.container.registerFactory(t, n);
+    }
+  ).createCommand(
+    "container.touch",
+    (e) => (t, n) => {
+      e.container.touch(t, n);
+    }
+  ).createCommand(
+    "csp",
+    {},
+    (e) => (t) => {
+      e.container.register("csp", t);
+    }
+  );
+});
+const Js = os((s) => {
+  s.createCommand(
+    "ready",
+    { scope: ie.Implementation, stage: L.Pre },
+    (e) => (t) => {
+      const { container: n } = e, i = n.owner;
+      n.get("bootstrapping").ready ? t(i) : i.events.subscribeOnce("bootstrap:ready", () => {
+        t(i);
+      });
+    }
+  );
+}), De = /* @__PURE__ */ new WeakMap();
+function G() {
+  return (s) => (De.has(s) || De.set(s, {}), De.get(s));
+}
+const We = (s, e, t, ...n) => {
+  const i = `[${s.get("$environment").name || "webprovisions"}] ${t}`;
+  switch (e) {
+    case "info":
+      console.info(i, ...n);
+      break;
+    case "warning":
+      console.warn(i, ...n);
+      break;
+    case "error":
+      console.error(i, ...n);
+      break;
+  }
+}, k = (s) => {
+  const e = s.container || s;
+  return {
+    info: (t, ...n) => We(e, "info", t, ...n),
+    warn: (t, ...n) => We(e, "warning", t, ...n),
+    error: (t, ...n) => We(e, "error", t, ...n)
+  };
+}, f = G(), ot = (() => {
+  let s = 0;
+  return () => ++s;
+})(), at = (s, e, t) => {
+  const n = f(s).touchQueue.get(e);
+  n && n.forEach((i) => {
+    i(t, s);
+  });
+};
+let Hs = class {
+  constructor(e, t, n, i) {
+    this.key = e, this.factory = t, this.parent = n, this.container = i, this.id = ot(), this.resolved = !1, this.constructed = !1, this.async = !0;
+  }
+  resolve() {
+    if (!this.constructed) {
+      const e = this.factory(this.parent, this.container);
+      return this.constructed = !0, this.value = Promise.resolve(e).then((t) => (this.resolved = !0, at(this.container, this.key, t), t));
+    }
+    return this.value;
+  }
+}, qs = class {
+  constructor(e, t, n, i) {
+    this.key = e, this.value = t, this.parent = n, this.container = i, this.id = ot(), this.async = !1, this.resolved = !1, this.constructed = !0, this.resolve = () => (this.resolved = !0, at(this.container, this.key, this.value), this.value);
+  }
+}, Fs = class {
+  constructor(e, t, n, i) {
+    this.key = e, this.value = t, this.parent = n, this.container = i, this.id = ot(), this.async = !1, this.resolved = !1, this.constructed = !1, this.resolve = () => {
+      this.resolved = !0, this.constructed = !0;
+      const r = this.value(this.parent, this.container);
+      return at(this.container, this.key, this.value), r;
+    };
+  }
+}, Bs = class as {
+  /**
+   * Creates a new instance of `Container`.
+   * @param owner  The object owning this inctance.
+   * @param name Optional name for the container.
+   * @param parent Parent container this should be a child of.
+   */
+  constructor(e, t, n) {
+    this.owner = e, this.name = t, this.parent = n, f(this).resolvers = /* @__PURE__ */ new Map(), f(this).touchQueue = /* @__PURE__ */ new Map(), f(this).children = [];
+  }
+  /**
+   * Deletes an existing resolver by its unique id.
+   * @param id Resolver id.
+   */
+  delete(e) {
+    const t = f(this).resolvers, n = Array.from(t.values()).find((i) => i.id === e);
+    return n ? (f(this).touchQueue.delete(n.key), Promise.resolve(t.delete(n.key))) : this.parent ? this.parent.delete(e) : Promise.resolve(!1);
+  }
+  /**
+   * Clears the `Container` and any child containers by deleteing all registered resolvers.
+   */
+  clear() {
+    const e = f(this).resolvers, t = Array.from(e.values());
+    return Promise.all(t.map((n) => {
+      if (n.constructed)
+        return Promise.resolve(n.resolve()).then((i) => {
+          if (i !== null && typeof i == "object" && typeof i.dispose == "function")
+            return i.dispose.call(i, this, n);
+        });
+    })).then(() => {
+      t.forEach((n) => this.delete(n.id)), f(this).children.forEach((n) => n.clear());
+    });
+  }
+  /**
+   * Detaches this `Container` instance from its parent, allowing it to be garbage-collected.
+   */
+  detach() {
+    if (this.parent) {
+      const e = f(this.parent).children, t = e.indexOf(this);
+      t > -1 && (e.splice(t, 1), delete this.parent);
+    }
+  }
+  /**
+   * Provides a way of touching a value in the `Container` without forcing it to be resolved.
+   * @param key Key of the resolved value to touch.
+   * @param handler Handler function for touching the resolved value.
+   */
+  touch(e, t) {
+    const n = f(this).resolvers.get(e);
+    if (n && n.constructed)
+      Promise.resolve(n.resolve()).then((i) => {
+        t(i, this);
+      });
+    else {
+      const i = f(this).touchQueue;
+      let r = i.get(e);
+      r || (r = [], i.set(e, r)), r.push(t);
+    }
+    return this.parent && !n ? this.parent.touch(e, t) : Promise.resolve();
+  }
+  /**
+   * Registers an asynchronous resolver.
+   * @param key Key of the resolver.
+   * @param factory Value factory.
+   */
+  registerAsync(e, t) {
+    const n = f(this).resolvers.get(e);
+    n && !n.async && process.env.NODE_ENV !== "production" && k(this).warn(`Mismatching resolver type. You are registering an async resolver with a key ('${e}') previously used by a non-async resolver.`);
+    const i = new Hs(e, t, n, this);
+    return f(this).resolvers.set(e, i), i.id;
+  }
+  /**
+   * Registers a factory resolver for constructing the value to be resolved.
+   * @param key Key of the resolver.
+   * @param factory Value factory.
+   */
+  registerFactory(e, t) {
+    const n = f(this).resolvers.get(e);
+    n && n.async && process.env.NODE_ENV !== "production" && k(this).warn(`Mismatching resolver type. You are registering a non-async resolver with a key ('${e}') previously used by an async resolver.`);
+    const i = new Fs(e, t, n, this);
+    return f(this).resolvers.set(e, i), i.id;
+  }
+  /**
+   * Registers an synchronous resolver.
+   * @param key Key of the resolver.
+   * @param value Value.
+   */
+  register(e, t) {
+    const n = f(this).resolvers.get(e);
+    n && n.async && process.env.NODE_ENV !== "production" && k(this).warn(`Mismatching resolver type. You are registering a non-async resolver with a key ('${e}') previously used by an async resolver.`);
+    const i = new qs(e, t, n, this);
+    return f(this).resolvers.set(e, i), i.id;
+  }
+  /**
+   * Gets the value for a synchronous resolver.
+   * @param key Key of resolver to get.
+   */
+  get(e) {
+    const t = f(this).resolvers.get(e);
+    if (t)
+      return t.async && process.env.NODE_ENV !== "production" && k(this).warn(`You are retrieving an async value (with key '${e}') by the non-async function 'container.get(key)'. This will not be supported in future versions. Use 'container.getAsync(key) instead.'`), t.resolve();
+    if (this.parent)
+      return this.parent.get(e);
+  }
+  /**
+   * Gets the value for a asynchronous resolver.
+   * @param key Key of resolver to get.
+   */
+  getAsync(e) {
+    const t = f(this).resolvers.get(e);
+    if (t) {
+      if (!t.async)
+        throw process.env.NODE_ENV !== "production" && k(this).warn(`You are retrieving a non-async value (with key '${e}') by the async function 'container.getAsync(key)'.Use 'container.get(key) instead.'`), "Mismatching resolver type";
+      return t.resolve();
+    }
+    return this.parent ? this.parent.getAsync(e) : Promise.resolve(void 0);
+  }
+  getMany(...e) {
+    const t = {};
+    return e.forEach((n) => t[n] = this.get(n)), t;
+  }
+  getManyAsync(...e) {
+    const t = {};
+    return Promise.all(e.map((n) => this.getAsync(n).then((i) => t[n] = i))).then(() => t);
+  }
+  createChild(e, t) {
+    const n = new as(e, t, this);
+    return f(this).children.push(n), n;
+  }
+}, St = class {
+  /**
+   * 
+   * @param type Type of event.
+   * @param target The target of the event, which will handle the default behavour.
+   * @param cancelable Whether the event is cancelable by calling preventDefault().
+   * @param bubbles Whether the event will bubble up the parent hierarchy.
+   */
+  constructor(e, t, n = !1, i = !1) {
+    this.type = e, this.target = t, this.cancelable = !!n, this.bubbles = !!i, this.defaultPrevented = !1;
+  }
+  /**
+   * Cancels the default behaviour (if the event is cancelable).
+   */
+  preventDefault() {
+    this.cancelable && (this.defaultPrevented = !0);
+  }
+};
+const S = G(), Nt = (s, e) => [].concat(
+  S(s).listenerLookup.get(e.toLowerCase()) || [],
+  S(s).listenerLookup.get("*") || []
+), _t = (s, e, t, n) => {
+  let i, r;
+  return e instanceof St ? (i = e, r = e.type) : (i = new St(e, s.target, !!t.cancelable, !!t.bubbles), r = e), { event: i, type: r, async: n };
+};
+let Us = class cs {
+  /**
+   * Creates a new Event Manager instance.
+   * @param target The target of events dispatched from this Event Manager instance.
+   * @param parent Parent Event Manager instance.
+   */
+  constructor(e, t) {
+    this.target = e, this.parent = t, S(this).listenerLookup = /* @__PURE__ */ new Map(), S(this).children = [];
+  }
+  /**
+   * Clears registered event listeners in this `EventManager` as well as in any children.
+   */
+  clear() {
+    S(this).listenerLookup.clear(), S(this).children.forEach((e) => e.clear());
+  }
+  /**
+   * Detaches this `EventManager` instance from its parent, allowing it to be garbage-collected.
+   */
+  detach() {
+    if (this.parent) {
+      const e = S(this.parent).children, t = e.indexOf(this);
+      t > -1 && e.splice(t, 1);
+    }
+  }
+  /**
+   * Creates an event subscription by registering an listener for an event type.
+   * @param type Event type to subscribe to.
+   * @param listener Listener for the event.
+   */
+  subscribe(e, t, n) {
+    const i = S(this).listenerLookup, r = e.toLowerCase();
+    return i.has(r) || i.set(r, []), i.get(r).push(t), () => this.unsubscribe(e, t);
+  }
+  /**
+   * Similar to `subscribe()` but immediately removes the subscription after the first call.
+   * @param type Event type to subscribe to.
+   * @param listener Listener for the event.
+   */
+  subscribeOnce(e, t) {
+    const n = this.subscribe(e, (i, r) => (n(), t(i, r)));
+  }
+  /**
+   * Removes a listener for the specified event type.
+   * @param type Event type to remove subscription for.
+   * @param listener Event listener to remove.
+   */
+  unsubscribe(e, t) {
+    const n = S(this).listenerLookup.get(e.toLowerCase());
+    if (n) {
+      const i = n.indexOf(t);
+      i > -1 && n.splice(i, 1);
+    }
+  }
+  /**
+   * Dispatches an asynchonous event to registered event listeners.
+   * @param eventOrType Event type or Event object to dispatch.
+   * @param data Optional data to be passed to event listeners.
+   * @param options Optional event options used if first parameter is an event type.
+   */
+  dispatchAsync(e, t, n = {}) {
+    const { event: i, type: r } = _t(this, e, n, !0), o = Nt(this, r);
+    let a = 0;
+    const c = o.length;
+    let l = Promise.resolve();
+    for (a = 0; a < c; a++)
+      ((h) => {
+        l = l.then((d) => d ? Promise.resolve(!0) : Promise.resolve(h(i, t)).then(() => i.defaultPrevented));
+      })(o[a]);
+    return l.then((h) => !h && i.bubbles && this.parent ? this.parent.dispatchAsync(i, t) : h);
+  }
+  /**
+   * Dispatches an event to registered event listeners.
+   * @param eventOrType Event type or Event object to dispatch.
+   * @param data Optional data to be passed to event listeners.
+   * @param options Optional event options used if first parameter is an event type.
+   */
+  dispatch(e, t, n = {}) {
+    const { event: i, type: r } = _t(this, e, n, !1), o = Nt(this, r);
+    let a = 0;
+    const c = o.length;
+    let l = !1;
+    for (a = 0; a < c; a++)
+      if (o[a](i, t), i.defaultPrevented) {
+        l = !0;
+        break;
+      }
+    return !l && i.bubbles && this.parent && (l = this.parent.dispatch(i, t)), l;
+  }
+  /**
+   * Creates a child instance to the current Event manager.
+   */
+  createChild(e) {
+    const t = new cs(e, this);
+    return S(this).children.push(t), t;
+  }
+};
+const he = (s, e, t) => {
+  const n = s.get("$plugins").map((i) => {
+    try {
+      return i.invoke(e, t);
+    } catch (r) {
+      k(s).error("An error occured when invoking a plugin.", i, r);
+    }
+  });
+  return Promise.all(n);
+};
+let Ks = class {
+  constructor(e) {
+    this.widget = e.get("$widget"), this.events = this.widget.events, this.container = this.widget.container, this.initialized = null, this.activated = null, this.initialize = this.initialize.bind(this), this.activate = this.activate.bind(this), this.deactivate = this.deactivate.bind(this), this.invoke = this.invoke.bind(this), this.createInstance();
+  }
+  createInstance() {
+    if (!this.widget.container.get("$instance")) {
+      const e = this.widget.container.get("$types"), t = this.widget.container.get("$type");
+      !t && k(this).error("Unable to create widget. No type is specified.");
+      const n = e[t];
+      !n && k(this).error(`Unable to create widget. Type '${t}' is not registered.`), this.widget.events.dispatch("widget:create-instance", {}, { bubbles: !0 });
+      try {
+        this.widget.container.register(
+          "$instance",
+          new n(this.container)
+        );
+      } catch (i) {
+        k(this).error("Unable to create widget type.", i);
+      }
+      this.widget.events.dispatch("widget:instance-created", {}, { bubbles: !0 });
+    }
+  }
+  /**
+   * The initialization is performed before the widget is activated but after it's configured
+   * and thus all required services are available. This hook is a good place to bind events that
+   * should trigger activation (e.g. click on "trigger links" or routing events)
+   * @param {object} data Custom initialization data passed to the widget.
+   */
+  initialize(e) {
+    return this.initialized = this.initialized || (() => {
+      const t = this.container.get("$instance"), n = t.initialize || (() => {
+      });
+      return this.initialized = Promise.resolve(n.call(t, e)).then(() => he(this.container, "initialize", e)).then(() => {
+      });
+    })();
+  }
+  /**
+   * The activation is where the widget is actually created and rendered.
+   * Activation can be initialized from the outside or from an event originated
+   * in the "initialize" hook.
+   * @param {object} data Custom activation data passed to the widget.
+   */
+  activate(e) {
+    return (this.initialized || this.initialize()).then(() => {
+      this.activated = this.activated || (() => he(this.container, "activate").then(() => {
+        const t = this.container.get("$instance");
+        return this.activated = t.activate(e);
+      }))();
+    });
+  }
+  deactivate() {
+    const e = this.container.get("$instance"), t = e.deactivate || (() => {
+    });
+    return he(this.container, "deactivate").then(() => Promise.resolve(t.call(e))).then(() => {
+      this.initialized = null, this.activated = null;
+    }).then(() => {
+    });
+  }
+  /**
+   * Invokes a command on the widget component.
+   * @param command Name of command
+   * @param args Command arguments
+   */
+  invoke(e, ...t) {
+    return he(this.container, "invoke", { command: e, args: t }).then(() => {
+      const n = this.container.get("$instance");
+      if (n[e])
+        return n[e].apply(n, t);
+      const i = n.invoke;
+      if (i)
+        return i.call(n, e, ...t);
+    });
+  }
+};
+const K = (s, e) => {
+  if (!e)
+    return !0;
+  if (typeof e == "string") {
+    const t = e.split(",");
+    for (let n = 0, i = t.length; n < i; n++) {
+      const r = t[n].trim();
+      if (r === s || r === "*")
+        return !0;
+    }
+  }
+  return e instanceof Array ? e.indexOf(s) > -1 : !1;
+}, Qs = (s, e) => {
+  if (typeof e == "function")
+    return e(s);
+  const t = typeof e == "string" ? Xs(e) : e;
+  return !(!K(s.implementation.tenant || "", t.tenant || "") || !K(s.implementation.name, t.implementation || "") || !K(s.name, t.widget || "") || !K(s.container.get("$type"), t.type || ""));
+}, Ys = (s, e) => {
+  if (typeof e == "function")
+    return e(s);
+  const t = typeof e == "string" ? Zs(e) : e;
+  return !(!K(s.tenant || "", t.tenant || "") || !K(s.name, t.implementation || ""));
+}, hs = (s) => (e) => Qs(e, s), Gs = (s) => (e) => Ys(e, s), I = (s) => s instanceof Array && s.length === 1 ? s[0] : s, Xs = (s) => {
+  const e = {}, t = s.split(":");
+  return t.length === 1 ? e.widget = I(t[0].split(",")) : t.length === 2 ? (e.implementation = I(t[0].split(",")), e.widget = I(t[1].split(","))) : (e.tenant = I(t[0].split(",")), e.implementation = I(t[1].split(",")), e.widget = I(t[2].split(","))), e;
+}, Zs = (s) => {
+  const e = {}, t = s.split(":");
+  return t.length === 1 ? e.implementation = I(t[0].split(",")) : (e.tenant = I(t[0].split(",")), e.implementation = I(t[1].split(","))), e;
+}, me = G(), It = (s, e, t) => s.filter((n) => n.stage === e && hs(n.selector)(t));
+function en(s) {
+  const e = s.container.get("$environment");
+  let t = me(e).configurationCache;
+  t && (t = t.filter((n) => n[0] !== s), me(e).configurationCache = t);
+}
+var fe = /* @__PURE__ */ ((s) => (s.Implementation = "implementation", s.Widget = "widget", s))(fe || {}), T = /* @__PURE__ */ ((s) => (s.Pre = "pre", s.Post = "post", s))(T || {});
+const ls = (s, e, t) => (Object.keys(e).forEach((n) => {
+  const i = e[n];
+  if (typeof i == "function") {
+    const r = i();
+    typeof r.defaultArgs != "undefined" && t(r, ...r.defaultArgs), s[n] = (...o) => {
+      const a = Object.assign(
+        {},
+        r,
+        { handlerResolver: r.handlerResolver.bind({}) }
+      );
+      return t(a, ...o), s;
+    };
+  } else
+    s[n] = ls(
+      {},
+      i,
+      t
+    );
+}), s), tn = (s, e) => {
+  switch (e) {
+    case "implementation":
+      return s.implementation;
+    case "widget":
+      return s;
+  }
+}, Tt = (s, e, t, n) => (n.forEach((i) => {
+  ls(
+    s,
+    i,
+    (r, ...o) => {
+      const a = {
+        selector: e,
+        stage: r.stage,
+        handler: (c) => {
+          const l = tn(c, r.scope), h = { container: l.container, events: l.events }, d = r.handlerResolver, p = d(h);
+          let u = me(t.environment).configurationCache;
+          return u || (u = me(t.environment).configurationCache = []), u.find((g) => g.indexOf(l) > -1 && g.indexOf(d) > -1) ? Promise.resolve() : (u.push([l, d]), Promise.resolve(p(...o)));
+        }
+      };
+      t.instructions.push(a);
+    }
+  );
+}), s);
+function sn(s, e) {
+  function t(n) {
+    return Tt(
+      {},
+      n,
+      s,
+      e
+    );
+  }
+  return Tt(
+    t,
+    "*",
+    s,
+    e
+  );
+}
+const nn = (s, e, t, n) => {
+  try {
+    const i = new e(t, n);
+    return {
+      name: s,
+      invoke: (r, o) => {
+        let a;
+        return i[r] && (a = i[r].call(i, o)), Promise.resolve(a);
+      },
+      getInstance: () => i
+    };
+  } catch (i) {
+    if (i.message && i.message.indexOf("is not a constructor") >= 0)
+      return {
+        name: s,
+        invoke: (r) => {
+          let o;
+          return r === "initialize" && (o = e(t, n)), Promise.resolve(o);
+        },
+        getInstance: () => e
+      };
+    throw i;
+  }
+};
+function jt(s, e) {
+  return typeof s == "undefined" ? e : s;
+}
+let rn = class {
+  constructor(e = {}) {
+    this.part = e;
+  }
+  createCommand(e, t, n) {
+    let i;
+    typeof t == "function" ? i = {
+      scope: fe.Widget,
+      stage: T.Post,
+      defaultArgs: void 0,
+      handlerResolver: t
+    } : i = {
+      scope: jt(t.scope, fe.Widget),
+      stage: jt(t.stage, T.Post),
+      defaultArgs: t.defaultArgs,
+      handlerResolver: n
+    };
+    let r = this.part;
+    const o = e.split(".");
+    return o.forEach((a, c) => {
+      c === o.length - 1 ? r[a] || (r[a] = () => i) : r = this.part[a] = this.part[a] || {};
+    }), this;
+  }
+  get() {
+    return this.part;
+  }
+};
+const ds = (s) => {
+  const e = new rn({});
+  return s(e), e.get();
+}, on = ds((s) => {
+  s.createCommand(
+    "types.register",
+    { scope: fe.Implementation, stage: T.Pre },
+    (e) => (t, n) => {
+      e.container.get("$types")[t] = n;
+    }
+  ).createCommand(
+    "type",
+    { stage: T.Pre },
+    (e) => (t) => {
+      e.container.register("$type", t);
+    }
+  ).createCommand(
+    "settings",
+    { stage: T.Pre, defaultArgs: [null] },
+    (e) => (t) => {
+      e.events.dispatch(
+        "settings:change",
+        t,
+        { bubbles: !0 }
+      ), e.container.register("$settings", t);
+    }
+  ).createCommand(
+    "plugin",
+    { stage: T.Pre },
+    (e) => (t, n, i) => {
+      const { container: r } = e;
+      let o = null, a = t, c = n;
+      typeof t == "string" && (o = t, a = n, c = i);
+      const l = (h) => {
+        const { transformPluginSettings: d } = e.container.get("$environmentOptions"), p = d ? d(
+          c || {},
+          o,
+          e.container,
+          a
+        ) : n;
+        try {
+          const u = nn(
+            o,
+            a,
+            r,
+            p
+          );
+          r.get("$plugins").push(u), h && u.invoke("initialize", null);
+        } catch (u) {
+          k(e).warn("Error when initializing plugin", u);
+        }
+      };
+      e.container.get("$instance") ? l(!0) : e.events.subscribeOnce("widget:instance-created", () => l(!1));
+    }
+  ).createCommand(
+    "container.register",
+    (e) => (t, n) => {
+      e.container.register(t, n);
+    }
+  ).createCommand(
+    "container.registerAsync",
+    (e) => (t, n) => {
+      e.container.registerAsync(t, n);
+    }
+  ).createCommand(
+    "container.registerFactory",
+    (e) => (t, n) => {
+      e.container.registerFactory(t, n);
+    }
+  ).createCommand(
+    "container.touch",
+    (e) => (t, n) => {
+      e.container.touch(t, n);
+    }
+  ).createCommand(
+    "csp",
+    {},
+    (e) => (t) => {
+      e.container.register("csp", t);
+    }
+  );
+}), an = on;
+function cn(s, e, t = []) {
+  const n = [an].concat(t), i = sn(
+    e,
+    n
+  );
+  s(i, e);
+}
+let hn = class {
+  constructor() {
+    this.tasks = [], this.current = Promise.resolve(), this.next = this.next.bind(this);
+  }
+  add(e, t, n, i) {
+    this.tasks.push({ task: e, resolve: t, reject: n, done: i }), this.next();
+  }
+  next() {
+    this.current = this.current.then(() => {
+      const e = this.tasks.shift();
+      if (e) {
+        const t = Promise.resolve(e.task());
+        return Promise.resolve(t).then(this.next).then(() => t.then((n) => {
+          e.done(), e.resolve(n);
+        })).catch((n) => (e.done(), e.reject(n), this.next()));
+      }
+      return Promise.resolve();
+    });
+  }
+};
+const le = /* @__PURE__ */ new WeakMap();
+function ln(s) {
+  return le.has(s) || le.set(s, new hn()), (e) => new Promise((t, n) => {
+    const i = le.get(s);
+    i.add(e, t, n, () => {
+      i.tasks.length || le.delete(s);
+    });
+  });
+}
+const Dt = (s) => typeof s != "undefined", ee = (s, e) => {
+  s.events.dispatch("widget:state-change", { state: e }, { bubbles: !0 }), s.state = e, s.events.dispatch("widget:state-changed", {}, { bubbles: !0 });
+}, A = G(), dn = (s) => {
+  const { container: e, events: t } = s;
+  e.get("$controller") || (e.register("$controller", new Ks(e)), t.dispatch("widget:controller-created", {}, { bubbles: !0 }));
+};
+let un = class {
+  /**
+   * Creates a new `Widget` instance.
+   * @param name Name of widget.
+   * @param implementation The implementation this instance belongs to.
+   * @param configuration Configuration for the widget.
+   */
+  constructor(e, t, n) {
+    this.state = "deactivated", this.name = e, this.implementation = t, this.container = t.container.createChild(this, e), this.events = t.events.createChild(this), A(this).subscriptions = [], n && t.configure((i) => {
+      const r = i(e);
+      Dt(n.type) && r.type(n.type), Dt(n.settings) && r.settings(n.settings), n.plugins && Object.keys(n.plugins).forEach((o) => {
+        var a;
+        const c = (a = n.plugins) == null ? void 0 : a[o];
+        r.plugin(o, c);
+      });
+    }), this.load = this.load.bind(this), this.activate = this.activate.bind(this), this.invoke = this.invoke.bind(this), this.deactivate = this.deactivate.bind(this);
+  }
+  /**
+   * Initializes the widget, if not already initialized, and applies any
+   * pending configuration.
+   */
+  load() {
+    return ln(this)(() => {
+      A(this).deactivatedPromise = null;
+      const e = this.state === "deactivated";
+      e && (ee(
+        this,
+        "activating"
+        /* Activating */
+      ), this.container.register("$widget", this), this.container.register("$controller", null), this.container.register("$plugins", []), this.container.register("$type", null), this.container.register("$instance", null)), ee(
+        this,
+        "loading"
+        /* Loading */
+      );
+      const t = this.implementation.instructions, n = It(t, T.Pre, this);
+      return Promise.all(n.map((i) => i.handler(this))).then(() => {
+        dn(this);
+        const i = It(t, T.Post, this);
+        return Promise.all(i.map((r) => r.handler(this))).then(() => {
+          e && this.container.get("$controller").initialize();
+        });
+      }).then(() => (ee(
+        this,
+        "activated"
+        /* Activated */
+      ), this));
+    });
+  }
+  /**
+   * Activates the widget and makes it ready for receiving commands.
+   * @param data Activation data
+   */
+  activate(e) {
+    A(this).subscriptions.push(
+      this.implementation.events.subscribe("implementation:configured", () => {
+        [
+          "activated",
+          "activating",
+          "loading"
+          /* Loading */
+        ].indexOf(this.state) > -1 && this.load();
+      })
+    );
+    const t = A(this).activatedPromise;
+    return t ? (process.env.NODE_ENV !== "production" && k(this).warn(`Widget '${this.name}' has already been activated. The passed arguments for this activation will be discarded.`, e), t) : A(this).activatedPromise = this.load().then(() => this.container.get("$controller").activate(e));
+  }
+  /**
+   * Invokes a command on a widget. If the widget isn't activate the invocation 
+   * will be suspended until activation.
+   * @param command Command to invoke.
+   * @param args Command arguments.
+   */
+  invoke(e, ...t) {
+    const n = A(this).activatedPromise, i = (r, ...o) => n.then(this.load).then(() => this.container.get("$controller").invoke(r, ...o));
+    return n ? i(e, ...t) : (process.env.NODE_ENV !== "production" && k(this).warn("You are invoking a command on a deactivated widget. The invocation will be queued until the widget is activated.", this), new Promise((r) => {
+      const o = this.events.subscribe("widget:state-changed", () => {
+        this.state === "activated" && (o(), r(i(e, ...t)));
+      });
+    }));
+  }
+  /**
+   * Deactivates the widget by clearing the `Container` and removing any event subscriptions in the
+   * `EventManager`.
+   */
+  deactivate() {
+    return A(this).deactivatedPromise || (this.state === "deactivated" ? Promise.resolve() : (ee(
+      this,
+      "deactivating"
+      /* Deactivating */
+    ), A(this).deactivatedPromise = this.container.get("$controller").deactivate().then(() => (A(this).activatedPromise = null, A(this).subscriptions.forEach((t) => t()), A(this).subscriptions = [], this.container.clear().then(() => {
+      this.events.clear(), en(this), ee(
+        this,
+        "deactivated"
+        /* Deactivated */
+      );
+    })))));
+  }
+};
+const Wt = G();
+let pn = class {
+  /**
+   * Creates a new Implementation instance.
+   * @param configuration Configuration for the implementation.
+   * @param environment The parent environment.
+   * @param configurationApiExtensions Optional configuration API extensions.
+   */
+  constructor(e, t, n = []) {
+    this.instructions = [], this.widgets = /* @__PURE__ */ new Map(), this.name = e.name, this.tenant = e.tenant, this.environment = t, this.container = t.container.createChild(this, this.name), this.events = t.events.createChild(this), this.container.register("$types", {}), Wt(this).configurationApiExtensions = n;
+  }
+  /**
+   * Loads all widgets in the implementation.
+   */
+  load() {
+    const e = Array.from(this.widgets.values());
+    return Promise.all(e.map((t) => t.load())).then(() => e);
+  }
+  /**
+   * Configures the implementation by adding a configuration callback.
+   * @param configFn Callback function for configuration.
+   */
+  configure(e) {
+    return cn(e, this, Wt(this).configurationApiExtensions), this.events.dispatch(
+      "implementation:configured",
+      { implementation: this },
+      { bubbles: !0 }
+    ), this;
+  }
+  /**
+   * Creates a widget on the implementation and returns its `WidgetData`.
+   * @param name Widget name.
+   * @param configuration Widget configuration.
+   */
+  createWidget(e, t) {
+    const n = new un(e, this, t);
+    return this.widgets.set(n.name, n), n;
+  }
+};
+function gn(s, e, t) {
+  const n = new pn(s, e, t);
+  return s.widgets && Object.keys(s.widgets).forEach((i) => {
+    var r;
+    const o = (r = s.widgets) == null ? void 0 : r[i];
+    n.createWidget(i, o);
+  }), n;
+}
+let Mt = class us {
+  constructor(e, t) {
+    this.selectorFactory = t, typeof e == "function" ? this.resolver = e : this.resolver = () => e;
+  }
+  append(e) {
+    const t = typeof e == "function" ? e : () => e;
+    return new us(
+      () => this.all().concat(t()),
+      this.selectorFactory
+    );
+  }
+  all() {
+    return this.resolver().concat([]);
+  }
+  query(e) {
+    return this.all().filter(this.selectorFactory(e));
+  }
+  find(e) {
+    const t = this.query(e);
+    if (t.length)
+      return t[0];
+  }
+};
+const ct = "#____version____#", Me = G(), mn = (s) => s.tenant ? `${s.name}:${s.tenant}` : s.name, ps = class {
+  constructor(e, t = [], n = {}) {
+    this.widgets = new Mt(
+      () => {
+        let i = [];
+        return this.implementations.all().forEach((r) => {
+          i = i.concat(Array.from(r.widgets.values()));
+        }), i;
+      },
+      hs
+    ), this.implementations = new Mt([], Gs), this.name = e, this.container = new Bs(this, e), this.events = new Us(this), this.container.register("$version", ct), this.container.register("$environment", this), this.container.register("$environmentOptions", n), Me(this).configurationApiExtensions = t;
+  }
+  /**
+   * Creates an implementation based on the provided configuration.
+   * @param config Implementation configuration.
+   */
+  createImplementation(e) {
+    const t = mn(e);
+    let n = this.implementations.find(t);
+    if (n)
+      return process.env.NODE_ENV !== "production" && k(n).warn(`Implementation "${t}" already exist on current environment.`), n;
+    const i = Me(this).configurationApiExtensions;
+    return n = gn(
+      e,
+      this,
+      i
+    ), this.implementations = this.implementations.append([n]), this.events.dispatch("implementation:created", { implementation: n }), n;
+  }
+  /**
+   * Patches the Environment instance configuration.
+   * @param configuration Environment configuration.
+   */
+  patch(e = {}) {
+    const { name: t, configurationApiExtensions: n } = e;
+    typeof t != "undefined" && t !== null && (this.name = t), n && n.forEach(
+      (i) => {
+        Me(this).configurationApiExtensions.push(i);
+      }
+    );
+  }
+  /**
+   * Creates a new Environment instance based on the provided configuration.
+   * @param configuration Environment configuration.
+   */
+  static create(e = {}) {
+    return new ps(
+      e.name || "",
+      e.configurationApiExtensions,
+      e.options
+    );
+  }
+};
+let gs = ps;
+gs.version = ct;
+const ke = (s, e, ...t) => typeof e == "string" ? s(`[humany] ${e}`, ...t) : s(e, ...t), se = class {
+  constructor() {
+    this.keys = [], this.log = (e, ...t) => this.lookup(e, () => se.log(...t)), this.warn = (e, ...t) => this.lookup(e, () => se.warn(...t)), this.error = (e, ...t) => this.lookup(e, () => se.error(...t)), this.info = (e, ...t) => this.lookup(e, () => se.info(...t));
+  }
+  lookup(e, t) {
+    this.keys.indexOf(e) === -1 && (this.keys.push(e), t());
+  }
+};
+let C = se;
+C.log = (...s) => ke(console.log, ...s);
+C.warn = (...s) => ke(console.warn, ...s);
+C.error = (...s) => ke(console.error, ...s);
+C.info = (...s) => ke(console.info, ...s);
+const ms = (s) => {
+  let e = {}, t, n;
+  if (typeof s != "object" || s === null)
+    return s;
+  e = Array.isArray(s) ? [] : {};
+  for (n in s)
+    t = s[n], e[n] = typeof t == "object" && t !== null ? ms(t) : t;
+  return e;
+}, fn = ms;
+function zt(s) {
+  let e = 0;
+  if (s.length === 0)
+    return e.toString();
+  for (let t = 0; t < s.length; t++) {
+    const n = s.charCodeAt(t);
+    e = (e << 5) - e + n, e = e & e;
+  }
+  return e.toString();
+}
+let vn = class {
+  constructor(e, t) {
+    this.lockWarningTime = e, this.lockErrorTime = t, this.tasks = [], this.current = Promise.resolve(), this.next = this.next.bind(this);
+  }
+  add(e, t, n, i) {
+    this.tasks.push({ task: e, resolve: t, reject: n, done: i }), this.next();
+  }
+  next() {
+    this.current = this.current.then(() => {
+      const e = this.tasks.shift();
+      if (e) {
+        let t;
+        const n = setTimeout(() => {
+          process.env.NODE_ENV !== "production" && C.warn(
+            `A lock has exceeded ${this.lockWarningTime} ms. Waiting additional ${this.lockErrorTime} ms before rejecting the task.`,
+            e
+          ), t = setTimeout(() => {
+            e.reject("lock timeout exceeded");
+          }, this.lockErrorTime);
+        }, this.lockWarningTime), i = Promise.resolve(e.task()).then((r) => (clearTimeout(n), clearTimeout(t), r));
+        return Promise.resolve(i).then(this.next).then(
+          () => i.then((r) => {
+            e.done(), e.resolve(r);
+          })
+        ).catch((r) => (e.done(), e.reject(r), this.next()));
+      }
+      return Promise.resolve();
+    });
+  }
+};
+const de = /* @__PURE__ */ new WeakMap();
+function oe(s, e = 5e3, t = 1e3) {
+  return de.has(s) || de.set(s, new vn(e, t)), (n) => new Promise((i, r) => {
+    const o = de.get(s);
+    o.add(n, i, r, () => {
+      o.tasks.length || de.delete(s);
+    });
+  });
+}
+const M = () => Math.floor((1 + Math.random()) * 65536).toString(16).substring(1);
+function Oe() {
+  return M() + M() + "-" + M() + "-" + M() + "-" + M() + "-" + M() + M() + M();
+}
+var yn = Object.defineProperty, bn = Object.defineProperties, wn = Object.getOwnPropertyDescriptors, Lt = Object.getOwnPropertySymbols, $n = Object.prototype.hasOwnProperty, Pn = Object.prototype.propertyIsEnumerable, Rt = (s, e, t) => e in s ? yn(s, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : s[e] = t, Ze = (s, e) => {
+  for (var t in e || (e = {}))
+    $n.call(e, t) && Rt(s, t, e[t]);
+  if (Lt)
+    for (var t of Lt(e))
+      Pn.call(e, t) && Rt(s, t, e[t]);
+  return s;
+}, kn = (s, e) => bn(s, wn(e));
+const On = (s) => {
+  const e = [];
+  return [
+    (t, n) => {
+      e.push(s.subscribe(t, n));
+    },
+    () => {
+      e.forEach((t) => {
+        t();
+      });
+    }
+  ];
+};
+let fs = class {
+  constructor(e, t = []) {
+    this.platform = e, this.rules = t;
+  }
+  match(e) {
+    return this.rules.every((t) => !(t.id && t.id !== e.id || t.type && t.type !== e.type));
+  }
+  ofType(e) {
+    return this.rules.push({ type: e }), this;
+  }
+  withId(e) {
+    return this.rules.push({ id: e }), this;
+  }
+  select() {
+    return new Cn(this.platform, this);
+  }
+};
+class xn {
+  constructor(e, t, n) {
+    this.platform = e, this.node = t, this.actions = new ht(
+      e,
+      new fs(e).withId(t.id),
+      n
+    );
+    const [i, r] = On(this.platform.events);
+    this.subscribe = i, this.unsubscribe = r;
+  }
+  properties(e) {
+    return e && this.node.touchProperties((t) => e(t)), this.node.attributes.properties;
+  }
+  context(e) {
+    return e && this.subscribe("components:context-changed", (t, { node: n }) => {
+      n === this.node && e(this.node.attributes.context);
+    }), this.node.attributes.context;
+  }
+  layout(e) {
+    return e && this.subscribe("components:layout-changed", (t, { node: n }) => {
+      n === this.node && e(this.node.attributes.layout);
+    }), this.node.attributes.layout;
+  }
+  writeProperties(e, t) {
+    this.node.writeProperties(e, t);
+  }
+  writeContext(e, t) {
+    this.node.writeProperties(e, t);
+  }
+  writeLayout(e, t) {
+    this.node.writeLayout(e, t);
+  }
+  dispose() {
+    this.unsubscribe(), this.actions.dispose();
+  }
+}
+class Cn {
+  constructor(e, t, n = !0) {
+    this.platform = e, this.target = t, this.clearOnDispose = n, this.removes = [], this.actions = new ht(this.platform, this.target);
+  }
+  writeProperties(e, t) {
+    this.removes.push(
+      this.platform.write({
+        options: t,
+        attributes: { properties: e },
+        target: this.target,
+        removable: this.clearOnDispose
+      })
+    );
+  }
+  writeContext(e, t) {
+    this.removes.push(
+      this.platform.write({
+        options: t,
+        attributes: { context: e },
+        target: this.target,
+        removable: this.clearOnDispose
+      })
+    );
+  }
+  writeLayout(e, t) {
+    this.removes.push(
+      this.platform.write({
+        options: t,
+        attributes: { layout: e },
+        target: this.target,
+        removable: this.clearOnDispose
+      })
+    );
+  }
+  dispose() {
+    this.removes.forEach((e) => {
+      e();
+    }), this.actions.dispose();
+  }
+}
+const En = (s, e, t) => {
+  const n = s.concat(), i = (r, o, a) => {
+    let c = !0;
+    if (n.length) {
+      const l = n.shift(), h = (d, p) => (c = !1, i(d, Object.assign({}, o, p), a));
+      return Promise.resolve(l(r, h, a)).then((d) => kn(Ze({}, d), {
+        cancelled: c
+      }));
+    }
+    return Promise.resolve({ data: r, cancelled: !1, options: o });
+  };
+  return i(e, {}, t);
+};
+let ht = class {
+  constructor(e, t, n) {
+    this.platform = e, this.target = t, this.ns = n, this.subscriptions = [], this.create = this.create.bind(this);
+  }
+  create(e, t = () => {
+  }) {
+    const n = {
+      key: e,
+      fn: t,
+      target: this.target,
+      ns: this.ns
+    };
+    this.platform.actionsState.handlers.push(n);
+    const i = () => {
+      const r = this.platform.actionsState.handlers.indexOf(n);
+      r > -1 && this.platform.actionsState.handlers.splice(r, 1);
+    };
+    return this.subscriptions.push(i), i;
+  }
+  dispatch(e, t) {
+    const n = this.platform.nodes.all.concat(
+      this.platform.nodes.detached
+    ), i = {}, r = this.platform.actionsState.handlers.filter(
+      (o) => o.key === e && (!o.ns || !this.ns || o.ns === this.ns)
+    );
+    return Promise.all(
+      r.map((o) => {
+        const a = n.filter(
+          (l) => o.target.match(l) && this.target.match(l)
+        ), c = this.platform.actionsState.watchers.filter((l) => l.key === e && (!l.ns || !this.ns || l.ns === this.ns) && a.some((h) => l.target.match(h))).map((l) => l.fn);
+        return Promise.all(
+          a.map((l) => {
+            const h = new xn(
+              this.platform,
+              l,
+              this.ns
+            );
+            return En(c, t, h).then((d) => {
+              const { data: p = {}, options: u, cancelled: g } = d;
+              return Promise.resolve(
+                g ? {} : o.fn(p, u, h)
+              ).then((y) => {
+                i[l.id] = y;
+              });
+            });
+          })
+        );
+      })
+    ).then(() => i);
+  }
+  watch(e, t) {
+    let n = e, i = this.ns;
+    const r = e.split(".");
+    r.length > 1 && (i = r[0], n = r.splice(1).join("."));
+    const o = {
+      fn: t,
+      target: this.target,
+      key: n,
+      ns: i
+    };
+    this.platform.actionsState.watchers.push(o);
+    const a = () => {
+      const c = this.platform.actionsState.watchers.indexOf(o);
+      c > -1 && this.platform.actionsState.watchers.splice(c, 1);
+    };
+    return this.subscriptions.push(a), a;
+  }
+  dispose() {
+    this.subscriptions.forEach((e) => e());
+  }
+};
+ds((s) => {
+  s.createCommand("components", (e) => (t) => {
+    e.events.subscribeOnce("components:platform-created", (n, { platform: i }) => {
+      t.handlers && t.handlers.forEach(([r, o]) => {
+        i.addComponentHandler(r, o);
+      });
+    });
+  });
+});
+class Vt {
+  constructor(e, t) {
+    this.events = e, this.tags = [], this.children = {}, this.changesets = [], this.mountCount = 0, this.id = Oe(), this.type = t, this.attributes = {
+      context: {},
+      properties: {},
+      layout: {},
+      tags: []
+    }, this.writeLayout({ size: "full", indent: 0 });
+  }
+  mount(e, t) {
+    let n = e.get("mounted-nodes");
+    return n || (n = /* @__PURE__ */ new Map(), e.register("mounted-nodes", n)), n.has(this) ? (process.env.NODE_ENV !== "production" && C.error("Trying to mount an already mounted component node.", this), () => {
+    }) : (this.events.dispatch("components:node-mounted", { node: this }), this.mountCount === 0 && (this.mountCount = this.mountCount + 1, this.events.dispatch("components:node-enter", { node: this })), () => {
+      n.delete(this), this.events.dispatch("components:node-unmounted", { node: this }), this.mountCount = this.mountCount - 1, this.mountCount === 0 && this.events.dispatch("components:node-exit", { node: this });
+    });
+  }
+  appendChild(e, t = "default") {
+    if (e.parent) {
+      if (e.parent === this)
+        return;
+      e.parent.removeChild(e);
+    }
+    e.parent = this, this.children[t] || (this.children[t] = []), this.children[t].push(e), this.events.dispatch("components:node-appended", { node: e });
+  }
+  prependChild(e, t = "default") {
+    if (e.parent) {
+      if (e.parent === this)
+        return;
+      e.parent.removeChild(e);
+    }
+    e.parent = this, this.children[t] || (this.children[t] = []), this.children[t].unshift(e), this.events.dispatch("components:node-appended", { node: e });
+  }
+  touchProperties(e, t = {}, n) {
+    const i = [{ properties: e }, t];
+    return this.changesets.push(i), this.events.dispatch("components:set-properties", { node: this }), () => {
+      if (n) {
+        const r = this.changesets.indexOf(i);
+        r > -1 && (this.changesets.splice(r, 1), this.events.dispatch("components:set-properties", { node: this }));
+      }
+    };
+  }
+  writeProperties(e, t = {}, n) {
+    const i = [{ properties: e }, t];
+    return this.changesets.push(i), this.events.dispatch("components:set-properties", { node: this }), () => {
+      if (n) {
+        const r = this.changesets.indexOf(i);
+        r > -1 && (this.changesets.splice(r, 1), this.events.dispatch("components:set-properties", { node: this }));
+      }
+    };
+  }
+  writeLayout(e, t = {}, n) {
+    const i = [{ layout: e }, t];
+    return this.changesets.push(i), this.events.dispatch("components:set-layout", { node: this }), () => {
+      if (!n)
+        return;
+      const r = this.changesets.indexOf(i);
+      r > -1 && (this.changesets.splice(r, 1), this.events.dispatch("components:set-layout", { node: this }));
+    };
+  }
+  writeContext(e, t = {}, n) {
+    const i = [{ context: e }, t];
+    return this.changesets.push(i), this.events.dispatch("components:set-context", { node: this }), () => {
+      if (!n)
+        return;
+      const r = this.changesets.indexOf(i);
+      r > -1 && (this.changesets.splice(r, 1), this.events.dispatch("components:set-context", { node: this }));
+    };
+  }
+  getChildren(e = "default") {
+    const t = this.children[e] || [];
+    return t.reduce((n, i, r) => {
+      const { order: o = r } = i.attributes.layout;
+      return n[o] ? n.splice(o, 0, i) : n[o] = i, n;
+    }, Array(t.length));
+  }
+  remove() {
+    this.parent && this.parent.removeChild(this);
+  }
+  removeChild(e) {
+    Object.keys(this.children).forEach((t) => {
+      const n = this.children[t], i = n.indexOf(e);
+      i > -1 && (n.splice(i, 1), this.events.dispatch("components:node-removed", { node: e, parentNode: this }));
+    }), delete e.parent;
+  }
+}
+const vs = (s, e, t) => {
+  for (let n = 0, i = s.length; n < i && t(s[n]) !== !0; n++) {
+    const r = e[s[n].id] || "default", o = s[n].getChildren(r);
+    vs(o, e, t);
+  }
+}, lt = (s, e, t) => {
+  if (t(s) !== !0) {
+    const n = e[s.id] || "default", i = s.children[n];
+    vs(i, e, t);
+  }
+}, ze = (s, e) => {
+  const t = [];
+  return lt(s, e, (n) => {
+    t.push(n);
+  }), t;
+}, An = (s, e, t) => {
+  let n;
+  return lt(s, e, (i) => {
+    if (t(i))
+      return n = i, !0;
+  }), n;
+};
+let Sn = class {
+  constructor(e, t, n) {
+    this.root = e, this.switches = t, this.all = [], this.visible = [], this.detached = [], n.subscribe("components:node-appended", (i, r) => {
+      this.all.push(r.node), this.visible = ze(e, t);
+    }), n.subscribe("components:node-removed", (i, r) => {
+      let o = this.all.indexOf(r.node);
+      o > -1 && this.all.splice(o, 1), o = this.visible.indexOf(r.node), o > -1 && this.visible.splice(o, 1), this.visible = ze(e, t);
+    }), n.subscribe("components:node-switched", (i, r) => {
+      this.visible = ze(e, t);
+    });
+  }
+  query(e = {}) {
+    const t = [];
+    return lt(this.root, this.switches, (n) => {
+      Object.keys(e).every((i) => e[i] === n[i]) && t.push(n);
+    }), t;
+  }
+  get(e) {
+    return An(this.root, this.switches, (t) => t.id === e) || this.detached.find((t) => t.id === e);
+  }
+};
+class Nn {
+  constructor() {
+    this.handlers = /* @__PURE__ */ new Map();
+  }
+  add(e, t) {
+    this.handlers.set(e, t);
+  }
+  get(e) {
+    return this.handlers.get(e);
+  }
+}
+const _n = (s) => {
+  let e = s, t = 0;
+  for (; e.parent; )
+    t = t + 1, e = e.parent;
+  return t;
+}, In = (s) => s.map(([e, t]) => [_n(e), e, t]).sort(([e], [t]) => e - t).map(([, e, t]) => [e, t]), Le = (s) => s instanceof Date ? !1 : s && typeof s == "object" && !Array.isArray(s), N = (s, ...e) => {
+  if (!e.length)
+    return s;
+  const t = e.shift();
+  if (Le(s) && Le(t))
+    for (const n in t)
+      Le(t[n]) ? (s[n] || Object.assign(s, { [n]: {} }), N(s[n], t[n])) : Object.assign(s, { [n]: t[n] });
+  return N(s, ...e);
+}, Tn = (s, e) => !s || s === "all" ? !0 : s.some((t) => e.indexOf(t) > -1), jn = (s, e) => {
+  let t = [], n = [], i;
+  const r = () => {
+    process.env.NODE_ENV !== "production" && console.time("state-processor.flush");
+    const a = /* @__PURE__ */ new Map(), c = In(t.map((h, d) => [h, n[d]])), l = (h, d) => {
+      var p;
+      const u = a.get(h) || {}, g = d.context && !u.context, y = d.properties && !u.properties, O = d.layout && !u.layout;
+      a.set(h, {
+        context: u.context || g,
+        properties: u.properties || y,
+        layout: u.layout || O
+      }), y && (h.attributes.properties = {}), O && (h.attributes.layout = {}), g && (h.attributes.context = N({}, (p = h.parent) == null ? void 0 : p.attributes.context));
+      const D = [], X = [], Z = [];
+      if (h.changesets.forEach((v) => {
+        const [m, V] = v;
+        Tn(V.breakpoints, s.breakpoints) && (y && (typeof m.properties == "function" ? D.push(
+          m.properties
+        ) : N(h.attributes.properties, m.properties)), O && (typeof m.layout == "function" ? X.push(m.layout) : N(h.attributes.layout, m.layout)), g && (typeof m.context == "function" ? Z.push(m.context) : N(h.attributes.context, m.context)));
+      }), D.forEach((v) => {
+        N(h.attributes.properties, v(h.attributes.properties));
+      }), X.forEach((v) => {
+        N(h.attributes.layout, v(h.attributes.layout));
+      }), Z.forEach((v) => {
+        N(h.attributes.context, v(h.attributes.context));
+      }), g || d.recursive) {
+        const v = s.getBranch(h), m = d.recursive ? d : {
+          context: !!g
+        };
+        h.getChildren(v).forEach((V) => {
+          l(V, m);
+        });
+      }
+    };
+    process.env.NODE_ENV !== "production" && console.timeEnd("state-processor.flush"), c.forEach(([h, d]) => {
+      l(h, d);
+    }), t = [], n = [], e(a);
+  }, o = () => {
+    clearTimeout(i), i = setTimeout(r, 0);
+  };
+  return (a, c) => {
+    const l = t.indexOf(a);
+    if (l > -1) {
+      const h = n[l];
+      return c.context && (h.context = !0), c.properties && (h.properties = !0), c.layout && (h.layout = !0), c.recursive && (h.recursive = !0), o();
+    }
+    return t.push(a), n.push(c), o();
+  };
+};
+let Dn = class {
+  constructor(e, t = {}) {
+    this.providers = t, this.breakpoints = [], this.actionsState = { handlers: [], watchers: [] }, this.switches = {}, this.changesets = [], this.subscriptions = [], this.customComponentHandler = new Nn(), this.events = e.events.createChild(this);
+    const n = new Vt(this.events, "root");
+    n.name = `root-${e.name}`, this.nodes = new Sn(n, this.switches, this.events);
+    const i = this.processNode = jn(this, (r) => {
+      const o = Array.from(r.keys());
+      process.env.NODE_ENV !== "production" && console.info(`STATE PROCESSOR: ${o.length} node(s) processed:
+${o.map(
+        (a) => `${a.name || "<no name>"} (${a.id})
+`
+      )}`), o.forEach((a) => {
+        const c = r.get(a);
+        a.parent && a.parent.type === "root" && this.events.dispatch("components:root-children-changed", { node: a }), c != null && c.context && this.events.dispatch("components:context-changed", { node: a }), c != null && c.properties && this.events.dispatch("components:properties-changed", { node: a }), c != null && c.layout && this.events.dispatch("components:layout-changed", { node: a });
+      }), this.events.dispatch("components:component-model-initialized", {}, { bubbles: !0 });
+    });
+    Promise.all(
+      Object.keys(t).map((r) => t[r].load(this))
+    ), this.subscriptions.push(
+      this.events.subscribe(
+        "components:node-appended",
+        (r, o) => {
+          const { node: a } = o;
+          this.changesets.forEach((c) => {
+            const { changeset: l, target: h, removes: d } = c, [p, u] = l;
+            h.match(o.node) && (p.properties && d.push(a.writeProperties(p.properties, u)), p.context && d.push(a.writeContext(p.context, u)), p.layout && d.push(a.writeLayout(p.layout, u)));
+          });
+        }
+      )
+    ), this.subscriptions.push(
+      this.events.subscribe(
+        "components:node-appended",
+        (r, o) => {
+          i(o.node, { properties: !0, context: !0 });
+        }
+      )
+    ), this.subscriptions.push(
+      this.events.subscribe(
+        "components:set-properties",
+        (r, o) => {
+          i(o.node, { properties: !0 });
+        }
+      )
+    ), this.subscriptions.push(
+      this.events.subscribe(
+        "components:set-context",
+        (r, o) => {
+          i(o.node, { properties: !0, context: !0 });
+        }
+      )
+    ), this.subscriptions.push(
+      this.events.subscribe(
+        "components:set-indent",
+        (r, o) => {
+          i(o.node, { layout: !0 });
+        }
+      )
+    ), this.subscriptions.push(
+      this.events.subscribe(
+        "components:set-layout",
+        (r, o) => {
+          i(o.node, { layout: !0 });
+        }
+      )
+    ), this.subscriptions.push(
+      this.events.subscribe("components:node-switched", (r, { node: o, branch: a }) => {
+        i(o, {
+          layout: !0,
+          recursive: !0,
+          properties: !0,
+          context: !0
+        });
+      })
+    ), this.subscriptions.push(
+      this.events.subscribe("components:node-removed", (r, { parentNode: o }) => {
+        i(o, { properties: !0 });
+      })
+    ), this.events.parent && this.events.parent.dispatch("components:platform-created", { platform: this });
+  }
+  static getInstance(e) {
+    return e.getAsync("components");
+  }
+  addBreakpoint(e) {
+    this.breakpoints.indexOf(e) === -1 && (this.breakpoints.push(e), this.processNode(this.nodes.root, {
+      context: !0,
+      properties: !0,
+      layout: !0,
+      recursive: !0
+    }));
+  }
+  removeBreakpoint(e) {
+    const t = this.breakpoints.indexOf(e);
+    t > -1 && (this.breakpoints.splice(t, 1), this.processNode(this.nodes.root, {
+      context: !0,
+      properties: !0,
+      layout: !0,
+      recursive: !0
+    }));
+  }
+  setSwitch(e, t) {
+    this.switches[e.id] = t, this.events.dispatch("components:node-switched", { node: e, branch: t });
+  }
+  getBranch(e) {
+    return this.switches[e.id];
+  }
+  /**
+   * Creates a `ComponentNode` of the specified type.
+   * @param type Type of node.
+   */
+  createNode(e, t = {}) {
+    const n = new Vt(this.events, e);
+    return t.detached && this.nodes.detached.push(n), n;
+  }
+  components() {
+    return new fs(this);
+  }
+  actions(e, t) {
+    return new ht(this, e, t);
+  }
+  write(e) {
+    const { provider: t, target: n, attributes: i, options: r = {}, removable: o } = e, a = e.key || Oe(), c = { changeset: [i, r], target: n, removes: [] };
+    if (t) {
+      const l = this.providers[t];
+      l.write(a, n, i, r), c.removes.push(() => {
+        l.remove(a);
+      });
+    }
+    return this.changesets.push(c), this.nodes.all.forEach((l) => {
+      if (n.match(l)) {
+        let h = () => {
+        };
+        i.properties && (h = l.writeProperties(i.properties, r, o)), i.context && (h = l.writeContext(i.context, r, o)), i.layout && (h = l.writeContext(i.layout, r, o)), c.removes.push(h);
+      }
+    }), () => {
+      if (o) {
+        c.removes.forEach((h) => h());
+        const l = this.changesets.indexOf(c);
+        l > -1 && this.changesets.splice(l, 1);
+      }
+    };
+  }
+  addComponentHandler(e, t) {
+    this.customComponentHandler.add(e, t);
+  }
+  getComponentHandler(e) {
+    return this.customComponentHandler.get(e);
+  }
+  dispose() {
+    this.subscriptions.forEach((e) => e());
+  }
+};
+const Wn = "#____version____#", ys = class extends gs {
+  constructor(e, t = []) {
+    super(e, t, {
+      transformPluginSettings: (n, i, r) => {
+        const o = r.get("$settings"), a = o.plugins && i ? o.plugins[i] || {} : {};
+        return Ze(Ze({}, a), n);
+      }
+    });
+  }
+  createImplementation(e) {
+    const t = super.createImplementation(e);
+    return t.bindings = e.bindings, t;
+  }
+  /**
+   * Performs navigation for widgets matching the specified selector by invoking a
+   * 'navigate' command.
+   * @param selector Widget selector matching the widget(s) to perform navigation on.
+   * @param route Route name.
+   * @param params Route params.
+   */
+  navigate(e, t, n) {
+    this.widgets.query(e).forEach((i) => i.invoke("navigate", { route: t, params: n }));
+  }
+  /**
+   * Creates a runtime based on provided configuration.
+   * @param configuration Runtime configuration.
+   */
+  static create(e = {}) {
+    const t = [Js].concat(
+      e.configurationApiExtensions || []
+    );
+    return new ys("humany", t);
+  }
+  /**
+   * Creates a widget runtime based on provided configuration and retains configuration handlers
+   * registered on global context. Use this factory to fully support the default embed script.
+   * Will return any existing widget runtime if available.
+   * @param configuration Runtime configuration.
+   * @param global Object to read configuration handlers from (default: window).
+   */
+  static createFromGlobal(e, t = {}) {
+    if (this.isRuntime(e))
+      return e.patch(t), e;
+    const n = [], i = e && e._c;
+    i && i.forEach((o) => n.push(o));
+    const r = this.create(t);
+    return r.container.register("$runtimecfg", n), r;
+  }
+  /**
+   * Determines whether the specified object is a valid widget runtime.
+   * @param obj Object to compare.
+   */
+  static isRuntime(e) {
+    return !!(e && typeof e == "object" && e.container && typeof e.container.get == "function" && e.container.get("$environment") === e && e.container.owner === e);
+  }
+};
+let Mn = ys;
+Mn.version = `${Wn} (${ct})`;
+var zn = Object.defineProperty, Jt = Object.getOwnPropertySymbols, Ln = Object.prototype.hasOwnProperty, Rn = Object.prototype.propertyIsEnumerable, Ht = (s, e, t) => e in s ? zn(s, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : s[e] = t, B = (s, e) => {
+  for (var t in e || (e = {}))
+    Ln.call(e, t) && Ht(s, t, e[t]);
+  if (Jt)
+    for (var t of Jt(e))
+      Rn.call(e, t) && Ht(s, t, e[t]);
+  return s;
+}, $ = /* @__PURE__ */ ((s) => (s.Cookie = "cookie", s.Local = "local", s.Session = "session", s))($ || {}), xe = /* @__PURE__ */ ((s) => (s.Tenant = "tenant", s.Implementation = "implementation", s.Widget = "widget", s))(xe || {}), w = /* @__PURE__ */ ((s) => (s.Necessary = "necessary", s.Functional = "functional", s.Analytical = "analytical", s.Marketing = "marketing", s))(w || {});
+const Ce = (s, e, t, n = {}) => qt(s, t).then((i) => (process.env.NODE_ENV !== "production" && i && C.warn(
+  `createStorageWriter: Attempted to create storage writer using unallowed category.
+                    Key: ${e}
+                    Category: ${JSON.stringify(t)}
+                    Options: ${JSON.stringify(n)}`
+), (r) => (ut(s), qt(s, t).then((o) => {
+  if (o) {
+    process.env.NODE_ENV !== "production" && C.warn(
+      `storageWriter: Attempted to write to storage using unallowed category.
+                                Key: ${e}
+                                Category: ${JSON.stringify(t)}
+                                Value: ${JSON.stringify(r)}
+                                Options: ${JSON.stringify(n)}`
+    );
+    return;
+  }
+  const {
+    scope: a = xe.Widget,
+    medium: c = $.Session,
+    duration: l
+  } = n, h = Jn();
+  return h[a][e] = $s(r, t, l), c === $.Cookie ? Un(s, h) : Qn(s, c, h);
+})))), J = (s, e, t = $.Session) => (ut(s), typeof e == "undefined" ? (process.env.NODE_ENV !== "production" && C.warn("readStorage: Undefined key passed when reading storage. ", e, t), Promise.resolve(void 0)) : t === $.Cookie ? Bn(s).then((n) => tt(n, e)) : Kn(s, t).then((n) => tt(n, e))), Q = (s) => !!Object.entries(s).filter(([e, t]) => typeof t != "undefined").length, Re = (s) => Object.entries(s).filter(([e, t]) => typeof t != "undefined").forEach(([e, { value: t }]) => {
+  typeof t == "undefined" && delete s[e];
+}), bs = (s, e) => {
+  const t = {
+    tenant: B(B({}, s.tenant), e.tenant),
+    implementation: B(B({}, s.implementation), e.implementation),
+    widget: B(B({}, s.widget), e.widget)
+  };
+  return Re(t.tenant), Re(t.implementation), Re(t.widget), t;
+}, Vn = (s) => Object.entries(s).reduce((e, t) => {
+  const [n, i] = t;
+  return Object.entries(i).forEach((r) => {
+    const [o, { expiration: a }] = r;
+    a && e.push(a);
+  }), e;
+}, []).slice().sort((e, t) => new Date(t).valueOf() - new Date(e).valueOf()).shift() || pt(), Ee = (s) => {
+  const {
+    name: e,
+    implementation: { name: t, tenant: n }
+  } = s.get("$widget");
+  return [
+    `humany_${n}`,
+    `humany_${zt(n + t)}`,
+    `humany_${zt(n + t + e)}`
+  ];
+}, Ve = (s) => {
+  const e = new RegExp(`(?:^|;)\\s?${s}=(.*?)(?:;|$)`, "i"), t = document.cookie.match(e);
+  return t && t[1] && JSON.parse(t[1]) || void 0;
+}, Je = (s, e, t) => {
+  const n = `${s}=${JSON.stringify(e).trim()}`, i = `expires=${new Date(t).toUTCString()}`, r = "path=/", o = "SameSite=None;Secure";
+  return document.cookie = `${n}; ${i}; ${r}; ${o}`;
+}, dt = (s) => {
+  const [e, t, n] = Ee(s), i = Ve(e) || {}, r = Ve(t) || {}, o = Ve(n) || {};
+  return {
+    tenant: i,
+    implementation: r,
+    widget: o
+  };
+}, ws = (s, e) => {
+  const t = dt(s), n = bs(t, e), [i, r, o] = Ee(s), { tenant: a, implementation: c, widget: l } = n, h = Vn(e), d = pt({ days: -1 });
+  Je(i, a, Q(a) ? h : d), Je(
+    r,
+    c,
+    Q(c) ? h : d
+  ), Je(o, l, Q(l) ? h : d);
+}, ve = (s, e) => {
+  const [t, n, i] = Ee(s), r = e.getItem(t) || "{}", o = e.getItem(n) || "{}", a = e.getItem(i) || "{}";
+  return {
+    tenant: JSON.parse(r),
+    implementation: JSON.parse(o),
+    widget: JSON.parse(a)
+  };
+}, et = (s, e, t) => {
+  const n = ve(s, e), i = bs(n, t), [r, o, a] = Ee(s), { tenant: c, implementation: l, widget: h } = i;
+  Q(c) ? e.setItem(r, JSON.stringify(c)) : e.removeItem(r), Q(l) ? e.setItem(o, JSON.stringify(l)) : e.removeItem(o), Q(h) ? e.setItem(a, JSON.stringify(h)) : e.removeItem(a);
+}, Jn = () => ({ tenant: {}, implementation: {}, widget: {} }), Hn = (s) => s ? !!s && /* @__PURE__ */ new Date() > new Date(s) : !1, tt = (s, e) => {
+  const t = s.widget[e] || s.implementation[e] || s.tenant[e];
+  return t == null ? void 0 : t.value;
+}, $s = (s, e, t) => t ? {
+  value: s,
+  category: e,
+  expiration: typeof t == "object" ? pt(t) : t
+} : {
+  value: s,
+  category: e
+}, qn = (s, e) => {
+  const t = fn(s);
+  return Object.entries(t).forEach(([n, i]) => {
+    Object.entries(i).forEach(([r, o]) => {
+      const { expiration: a, category: c } = o;
+      (Hn(a) || Fn(e, c)) && (i[r] = $s(void 0, c, a));
+    });
+  }), t;
+}, qt = (s, e) => J(s, "storagePolicy", $.Cookie).then(
+  (t = [w.Necessary]) => !!e && t.indexOf(e) === -1
+), Fn = (s = [w.Necessary], e) => !!e && s.indexOf(e) === -1, ut = (s) => {
+  const e = dt(s), t = ve(s, window.localStorage), n = ve(s, sessionStorage), i = tt(e, "storagePolicy"), [r, o, a] = [
+    e,
+    t,
+    n
+  ].map((c) => qn(c, i));
+  ws(s, r), et(s, window.localStorage, o), et(s, window.sessionStorage, a);
+}, pt = (s = { days: 30 }) => {
+  const { days: e = 0, hours: t = 0, minutes: n = 0, seconds: i = 0 } = s, r = /* @__PURE__ */ new Date();
+  return r.setTime(r.getTime() + t * 60 * 60 * 1e3), r.setTime(r.getTime() + e * 24 * 60 * 60 * 1e3), r.setTime(r.getTime() + n * 60 * 1e3), r.setTime(r.getTime() + i * 1e3), r.toISOString();
+}, Bn = (s) => oe(document)(() => dt(s)), Un = (s, e) => oe(document)(() => ws(s, e)), Kn = (s, e) => {
+  const t = e === $.Local ? window.localStorage : window.sessionStorage;
+  return oe(t)(() => ve(s, t));
+}, Qn = (s, e, t) => {
+  const n = e === $.Local ? window.localStorage : window.sessionStorage;
+  return oe(n)(() => et(s, n, t));
+}, He = (s, e, t, ...n) => {
+  const i = `[${s.get("$environment").name || "webprovisions"}] ${t}`;
+  switch (e) {
+    case "info":
+      console.info(i, ...n);
+      break;
+    case "warning":
+      console.warn(i, ...n);
+      break;
+    case "error":
+      console.error(i, ...n);
+      break;
+  }
+}, Yn = (s) => {
+  const e = s.container || s;
+  return {
+    info: (t, ...n) => He(e, "info", t, ...n),
+    warn: (t, ...n) => He(e, "warning", t, ...n),
+    error: (t, ...n) => He(e, "error", t, ...n)
+  };
+};
+var ye = /* @__PURE__ */ ((s) => (s.Implementation = "implementation", s.Widget = "widget", s))(ye || {}), H = /* @__PURE__ */ ((s) => (s.Pre = "pre", s.Post = "post", s))(H || {});
+const Gn = (s, e, t, n) => {
+  try {
+    const i = new e(t, n);
+    return {
+      name: s,
+      invoke: (r, o) => {
+        let a;
+        return i[r] && (a = i[r].call(i, o)), Promise.resolve(a);
+      },
+      getInstance: () => i
+    };
+  } catch (i) {
+    if (i.message && i.message.indexOf("is not a constructor") >= 0)
+      return {
+        name: s,
+        invoke: (r) => {
+          let o;
+          return r === "initialize" && (o = e(t, n)), Promise.resolve(o);
+        },
+        getInstance: () => e
+      };
+    throw i;
+  }
+};
+function Ft(s, e) {
+  return typeof s == "undefined" ? e : s;
+}
+class Xn {
+  constructor(e = {}) {
+    this.part = e;
+  }
+  createCommand(e, t, n) {
+    let i;
+    typeof t == "function" ? i = {
+      scope: ye.Widget,
+      stage: H.Post,
+      defaultArgs: void 0,
+      handlerResolver: t
+    } : i = {
+      scope: Ft(t.scope, ye.Widget),
+      stage: Ft(t.stage, H.Post),
+      defaultArgs: t.defaultArgs,
+      handlerResolver: n
+    };
+    let r = this.part;
+    const o = e.split(".");
+    return o.forEach((a, c) => {
+      c === o.length - 1 ? r[a] || (r[a] = () => i) : r = this.part[a] = this.part[a] || {};
+    }), this;
+  }
+  get() {
+    return this.part;
+  }
+}
+const Ps = (s) => {
+  const e = new Xn({});
+  return s(e), e.get();
+};
+Ps((s) => {
+  s.createCommand(
+    "types.register",
+    { scope: ye.Implementation, stage: H.Pre },
+    (e) => (t, n) => {
+      e.container.get("$types")[t] = n;
+    }
+  ).createCommand(
+    "type",
+    { stage: H.Pre },
+    (e) => (t) => {
+      e.container.register("$type", t);
+    }
+  ).createCommand(
+    "settings",
+    { stage: H.Pre, defaultArgs: [null] },
+    (e) => (t) => {
+      e.events.dispatch(
+        "settings:change",
+        t,
+        { bubbles: !0 }
+      ), e.container.register("$settings", t);
+    }
+  ).createCommand(
+    "plugin",
+    { stage: H.Pre },
+    (e) => (t, n, i) => {
+      const { container: r } = e;
+      let o = null, a = t, c = n;
+      typeof t == "string" && (o = t, a = n, c = i);
+      const l = (h) => {
+        const { transformPluginSettings: d } = e.container.get("$environmentOptions"), p = d ? d(
+          c || {},
+          o,
+          e.container,
+          a
+        ) : n;
+        try {
+          const u = Gn(
+            o,
+            a,
+            r,
+            p
+          );
+          r.get("$plugins").push(u), h && u.invoke("initialize", null);
+        } catch (u) {
+          Yn(e).warn("Error when initializing plugin", u);
+        }
+      };
+      e.container.get("$instance") ? l(!0) : e.events.subscribeOnce("widget:instance-created", () => l(!1));
+    }
+  ).createCommand(
+    "container.register",
+    (e) => (t, n) => {
+      e.container.register(t, n);
+    }
+  ).createCommand(
+    "container.registerAsync",
+    (e) => (t, n) => {
+      e.container.registerAsync(t, n);
+    }
+  ).createCommand(
+    "container.registerFactory",
+    (e) => (t, n) => {
+      e.container.registerFactory(t, n);
+    }
+  ).createCommand(
+    "container.touch",
+    (e) => (t, n) => {
+      e.container.touch(t, n);
+    }
+  ).createCommand(
+    "csp",
+    {},
+    (e) => (t) => {
+      e.container.register("csp", t);
+    }
+  );
+});
+Ps((s) => {
+  s.createCommand("storage", (e) => (t = {}) => {
+    const { consent: n } = t;
+    if (typeof n != "undefined") {
+      if (typeof n != "number" && typeof n != "string" && !Array.isArray(n)) {
+        process.env.NODE_ENV !== "production" && C.warn(
+          `storagePolicyConfigurationApi: passed consent is not valid. Consent either has to be a number, a string, an array of strings or an array of numbers.
+                        Passed consent: ${JSON.stringify(n)}`
+        );
+        return;
+      }
+      if (Array.isArray(n) && !n.every(
+        (r) => typeof r == "number" || typeof r == "string"
+      )) {
+        process.env.NODE_ENV !== "production" && C.warn(
+          `storagePolicyConfigurationApi: passed consent is not valid. Consent either has to be a number, a string, an array of strings or an array of numbers.
+                        Passed consent: ${JSON.stringify(n)}`
+        );
+        return;
+      }
+      const i = [
+        w.Necessary,
+        w.Functional,
+        w.Analytical,
+        w.Marketing
+      ].filter((r, o, a) => typeof n == "number" ? n > o : typeof n == "string" ? a.indexOf(n) + 1 > o : Array.isArray(n) ? n.findIndex((c) => c === o + 1 || c === r) > -1 : !0);
+      return i.indexOf(w.Necessary) === -1 && (process.env.NODE_ENV !== "production" && C.warn(
+        `storagePolicyConfigurationApi: passed consent does not include category: '${w.Necessary}'. Consent has to atleast include the '${w.Necessary}' category.
+                        Passed consent: ${JSON.stringify(n)}`
+      ), i.unshift(w.Necessary)), Ce(
+        e.container,
+        "storagePolicy",
+        w.Necessary,
+        {
+          medium: $.Cookie,
+          scope: xe.Tenant,
+          duration: { days: 365 }
+        }
+      ).then((r) => r(i)).then(() => {
+        ut(e.container), e.events.dispatch("storage:policy-changed", i);
+      });
+    }
+  });
+});
+class Zn {
+  constructor(e) {
+    this.controller = e, this.cache = /* @__PURE__ */ new Map(), this.subscriptions = [];
+    const { events: t } = e.container.get("$widget"), n = t.subscribe("data-client:fetched", (i, r) => {
+      r.type === "contact-method" && this.cache.set(r.response.id, r.response);
+    });
+    this.subscriptions.push(n);
+  }
+  getConversationLogs() {
+    return this.controller.messages.reduce(
+      (t, n) => {
+        const i = Ae(n), { content: r, type: o, sender: a, timestamp: c } = i.content, l = this.parseEntry(r, o, a, c);
+        return l && t.push(l), t;
+      },
+      []
+    );
+  }
+  parseEntry(e, t, n, i) {
+    const r = (l) => {
+      let h = [], d = [], p;
+      if (Array.isArray(l)) {
+        const [g, y] = l;
+        p = y;
+      } else
+        p = l;
+      return this.createMessageContent(p).length && (d = [
+        ...d,
+        this.createMessageContent(p)
+      ]), h = [...h, ...this.createMessageOptions(p)], {
+        messagesAsList: d,
+        options: h
+      };
+    };
+    let o = [], a = [];
+    if (Array.isArray(e.items)) {
+      const { items: l } = e;
+      l.forEach((h) => {
+        const d = r(h);
+        o = [...o, ...d.options], a = [...a, ...d.messagesAsList];
+      });
+    } else {
+      const l = r(e);
+      o = [...o, ...l.options], a = [...a, ...l.messagesAsList];
+    }
+    return {
+      options: o,
+      message: a.length ? a.join(`
+`) : void 0,
+      source: this.createMessageSource(t),
+      alias: this.createAlias(t, n),
+      timestamp: i
+    };
+  }
+  createMessageSource(e) {
+    return e;
+  }
+  createAlias(e, t) {
+    return e === ae.System ? "system" : (t == null ? void 0 : t.name) || "Me";
+  }
+  handleContactMethod(e) {
+    if (!this.cache.has(e))
+      return;
+    const t = this.cache.get(e);
+    let n = "";
+    return n = this.appendText(n, `${t.clientName}:`), n = this.appendText(n, t.title), t.description && (n = this.appendText(n, t.title)), n;
+  }
+  getDetails(e, t = !0) {
+    if (!e)
+      return "";
+    const {
+      header: n,
+      title: i,
+      label: r,
+      description: o,
+      text: a,
+      html: c,
+      body: l,
+      contactMethodId: h
+    } = e;
+    let d = "";
+    if (h) {
+      const p = this.handleContactMethod(h.toString());
+      p && (d = this.appendText(d, p, t));
+    }
+    return n && (d = this.appendText(d, n, t)), i && (d = this.appendText(d, i, t)), o && (d = this.appendText(d, o, t)), a && (d = this.appendText(d, a, t)), r && (d = this.appendText(d, r, t)), c && (d = this.appendText(d, c, t)), l && typeof l == "string" && (d = this.appendText(d, l, t)), d;
+  }
+  createMessageContent(e) {
+    let t = "";
+    return t = this.getDetails(e), t;
+  }
+  createMessageOptions(e) {
+    let t = [], n = [];
+    return Array.isArray(e == null ? void 0 : e.actions) ? n = e.actions : typeof (e == null ? void 0 : e.actions) == "object" && (n = Object.entries(e.actions).map(([i, r]) => ({
+      actionKey: i,
+      label: r
+    }))), n.length && (t = n.map((i) => this.getDetails(i, !1))), t;
+  }
+  appendText(e, t, n = !0) {
+    return n && e.length ? `${e}
+${t}` : e.length ? `${e} ${t}` : t;
+  }
+  dispose() {
+    this.subscriptions.forEach((e) => {
+      e();
+    });
+  }
+}
+class st {
+  constructor(e, t) {
+    this.provider = e, this.print = (n, i) => {
+      const r = {
+        name: this.name,
+        avatar: this.avatar,
+        id: this.id
+      }, o = Ae(n, i);
+      return this.provider.createEntry(
+        o.key,
+        o.content,
+        ae.Agent,
+        r,
+        o.timestamp
+      );
+    }, this.typing = () => this.provider.setTypingState({
+      name: this.name,
+      avatar: this.avatar
+    }), this.id = t.id || Oe(), this.name = t.name, this.avatar = t.avatar;
+  }
+  update(e) {
+    var i;
+    const { name: t, avatar: n } = e;
+    n === null ? this.avatar = void 0 : n && (this.avatar = n), t === null ? this.name = void 0 : t && (this.name = t), (i = this.provider.controller) == null || i.events.dispatch("conversation:agent-updated", {
+      agent: this
+    });
+  }
+}
+class gt {
+  constructor(e, t, n) {
+    this.name = e, this.controller = n, this.subscriptions = [], this.user = n == null ? void 0 : n.user, this.options = {
+      silent: !1
+    };
+  }
+  static create(e, t, n) {
+    return new gt(e, t, n);
+  }
+  createAgent(e = {}) {
+    var t;
+    if (this.controller) {
+      const n = this.controller.getAgentById(e.id), i = n ? new st(this, P(P({}, n), e)) : new st(this, e);
+      return n || (t = this.controller) == null || t.events.dispatch("conversation:agent-created", {
+        agent: i
+      }), i;
+    }
+  }
+  print(e) {
+    var t;
+    return (t = this.controller) == null ? void 0 : t.print(e);
+  }
+  setTypingState(e, t) {
+    var n;
+    return (n = this.controller) == null ? void 0 : n.setTypingState(e, t);
+  }
+  loading() {
+    return this.controller ? this.controller.loader() : () => () => {
+    };
+  }
+  createEntry(e, t, n, i, r) {
+    var o;
+    return (o = this.controller) == null ? void 0 : o.createEntry(e, t, n, i, r);
+  }
+  dispose() {
+    var e;
+    process.env.NODE_ENV !== "production" && console.log(`conversation-provider: dispose (${this.name})`), (e = this.controller) == null || e.disposeProvider(this), this.controller = null, this.subscriptions.forEach((t) => t());
+  }
+  isRehydrated() {
+    var e;
+    return ((e = this.controller) == null ? void 0 : e.isRehydrated()) || Promise.resolve(!1);
+  }
+  getHistory() {
+    var e;
+    return ((e = this.controller) == null ? void 0 : e.getHistory()) || [];
+  }
+  complete() {
+    var e;
+    (e = this.controller) == null || e.onCompleteProvider();
+  }
+  setOptions(e = { silent: !1 }) {
+    this.options = e;
+  }
+  onUnreadMessage(e) {
+    var t;
+    if (this.controller) {
+      const n = (t = this.controller) == null ? void 0 : t.onUnreadMessage(e);
+      return this.subscriptions.push(n), () => {
+        n();
+      };
+    }
+  }
+  onMounted(e) {
+    var t;
+    if (this.controller) {
+      const n = (t = this.controller) == null ? void 0 : t.events.subscribe(
+        "conversation:component-mount-changed",
+        e
+      );
+      return this.subscriptions.push(n), e({}, this.controller.getComponentMountedState()), () => {
+        n();
+      };
+    }
+  }
+}
+const ks = (s) => `conversation-${s}`;
+class ei {
+  constructor() {
+    this._locking = Promise.resolve(), this._locks = 0;
+  }
+  isLocked() {
+    return this._locks > 0;
+  }
+  lock() {
+    this._locks += 1;
+    let e, t = new Promise(
+      (i) => e = () => {
+        this._locks -= 1, i();
+      }
+    ), n = this._locking.then(() => e);
+    return this._locking = this._locking.then(() => t), n;
+  }
+}
+class ti {
+  constructor(e, t, n) {
+    this.container = e, this.enabled = n, this.locker = new ei(), this.initialStoredAgents = [], this.sessionStorageKey = ks(t.id), t.onStarted(() => b(this, null, function* () {
+      if (t.messages.length > 0)
+        return;
+      const { agents: i } = yield this.read(), r = [];
+      i && i.forEach((a) => {
+        const c = t.providerIndex(a.providerName), l = c > -1 ? t.registeredProviders[c] : t.createProvider(a.providerName), h = new st(l, {
+          name: a.name,
+          avatar: a.avatar,
+          id: a.id
+        });
+        r.push(h);
+      });
+      const { messages: o } = yield this.read();
+      o.forEach((a) => {
+        switch (a.type) {
+          case "agent": {
+            const c = r.find((l) => {
+              var h;
+              return l.id === ((h = a.sender) == null ? void 0 : h.id);
+            });
+            c && c.print(a.content.items || a.content, {
+              key: a.key
+            });
+            return;
+          }
+          case "user": {
+            t.user.print(a.content.items || a.content, {
+              key: a.key
+            });
+            return;
+          }
+          case "system":
+          default:
+            t.print(a.content.items || a.content);
+        }
+      });
+    })), t.onMessageCreated((i, r) => b(this, null, function* () {
+      this.write(r.message, "messages");
+    })), t.events.subscribe(
+      "conversation:agent-created",
+      (i, r) => b(this, null, function* () {
+        const o = {
+          id: r.agent.id,
+          name: r.agent.name,
+          avatar: r.agent.avatar,
+          providerName: r.agent.provider.name
+        };
+        yield this.write(o, "agents");
+      })
+    ), t.events.subscribe(
+      "conversation:agent-updated",
+      (i, r) => b(this, null, function* () {
+        const { agents: o } = yield this.read();
+        yield this.write(
+          [
+            ...o.map((a) => a.id === r.agent.id ? W(P({}, a), {
+              name: r.agent.name,
+              avatar: r.agent.avatar
+            }) : a)
+          ],
+          "agents",
+          "update"
+        );
+      })
+    );
+  }
+  setInitialData(e) {
+    this.initialStoredAgents = e.agents;
+  }
+  isRehydrated() {
+    return b(this, null, function* () {
+      const { messages: e } = yield this.read();
+      return e.length > 0;
+    });
+  }
+  getStoredAgent(e) {
+    if (this.enabled)
+      return this.initialStoredAgents.find((t) => t.id === e);
+  }
+  write(e, t, n = "add") {
+    return b(this, null, function* () {
+      if (!this.enabled)
+        return;
+      const i = yield this.locker.lock();
+      return Ce(
+        this.container,
+        this.sessionStorageKey,
+        w.Necessary
+      ).then((r) => b(this, null, function* () {
+        if (n === "add") {
+          const o = yield this.read();
+          if (t === "messages" && o.messages.findIndex((c) => c.key === e.key) > -1) {
+            i();
+            return;
+          }
+          let a = P({}, o);
+          return t === "messages" ? a.messages = [...a.messages, e] : t === "agents" && (a.agents = [...a.agents, e]), r(P(P({}, o), a)).then(() => {
+            i();
+          });
+        }
+        if (n === "update" && t === "agents") {
+          const o = yield this.read();
+          return r(W(P({}, o), {
+            agents: e
+          })).then(() => {
+            i();
+          });
+        }
+        return r(e).then(() => {
+          i();
+        });
+      }));
+    });
+  }
+  read() {
+    return b(this, null, function* () {
+      return J(this.container, this.sessionStorageKey).then((e) => e || {
+        messages: [],
+        agents: []
+      });
+    });
+  }
+}
+class si {
+  constructor(e) {
+    this.controller = e, this.print = (t, n) => {
+      const i = Ae(t, n);
+      return this.controller.createEntry(
+        i.key,
+        i.content,
+        ae.User,
+        void 0,
+        i.timestamp
+      );
+    };
+  }
+}
+const nt = (s, e, t) => b(void 0, null, function* () {
+  const n = yield s.getAsync("conversation"), i = yield s.getAsync("components"), r = n.controllers.find((o) => o.conversation.id === e);
+  if (r) {
+    const o = [...r.conversation.providers];
+    o.forEach((c) => {
+      r.conversation.setProviderOptions(c, { silent: !0 });
+    }), r.conversation.queueProviders(o), r.conversation.setProviders([t]);
+    const a = i.components().ofType("conversation");
+    i.write({
+      key: "setConversationProvider",
+      attributes: {
+        properties: { providers: [t] }
+      },
+      target: a,
+      provider: "localStorage"
+    });
+  }
+});
+class ni {
+  constructor(e) {
+    this.writer = e;
+  }
+  update(e) {
+    const t = this.getNormalizedSettings(e);
+    this.writer(t);
+  }
+  remove() {
+    this.writer(null);
+  }
+  getNormalizedSettings(e) {
+    return typeof e == "string" ? { body: e } : e.length > -1 && typeof e == "object" ? { items: e } : e;
+  }
+}
+var ae = /* @__PURE__ */ ((s) => (s.User = "user", s.Agent = "agent", s.System = "system", s))(ae || {});
+const Ae = (s, e) => {
+  let t, n = (e == null ? void 0 : e.key) || Oe(), i = Date.now();
+  return Array.isArray(s) && s.length > -1 ? typeof s[0] == "string" ? t = { items: [s] } : t = { items: s } : typeof s == "string" ? t = { body: s } : (s = s || {}, s.type ? t = P({}, s) : (t = {
+    body: s.body,
+    actions: s.actions,
+    title: s.title
+  }, s.key && (n = s.key), s.timestamp && (i = s.timestamp), s.form, s.timestamp === null && (i = null))), { content: t, key: n, timestamp: i };
+}, Bt = (s, e) => {
+  if (!e)
+    return;
+  const t = JSON.stringify(e), n = s.findIndex((i) => t === JSON.stringify(i));
+  if (n > -1)
+    return s.splice(n, 1);
+};
+class ii {
+  constructor(e, t, n) {
+    this.container = e, this.id = t, this.formHandlers = {}, this.user = new si(this), this.providers = [], this.active = !1, this.queuedProviders = [], this.registeredProviders = [], this.loaders = 0, this.componentMounted = !1, this.messages = [], this.typingActors = [], this.print = (r) => {
+      const o = Ae(r);
+      return this.createEntry(
+        o.key,
+        o.content,
+        "system",
+        void 0,
+        o.timestamp
+      );
+    };
+    const i = e.get("$widget");
+    this.events = i.events.createChild(this), this.store = new ti(e, this, n.rehydrate), this.conversationHistory = new Zn(this);
+  }
+  setInitialStorage(e) {
+    this.store.setInitialData(e);
+  }
+  setProviders(e) {
+    const t = [], n = [];
+    this.providers.reduce((i, r) => (e.indexOf(r) === -1 && i.push(r), i), []).forEach((i) => {
+      const r = this.providers.indexOf(i);
+      r > -1 && (t.push(i), this.providers.splice(r, 1));
+    }), e.forEach((i) => {
+      this.providers.indexOf(i) === -1 && (n.push(i), this.providers.push(i));
+    }), (n.length || t.length) && this.events.dispatch("conversation:providers-changed", {
+      added: n,
+      removed: t
+    });
+  }
+  createProvider(e) {
+    const t = this.providerIndex(e);
+    if (t > -1)
+      return this.registeredProviders[t];
+    const n = gt.create(e, this.container, this);
+    return this.registeredProviders.push(n), n;
+  }
+  providerIndex(e) {
+    return this.registeredProviders.findIndex((t) => t.name === e);
+  }
+  getAgentById(e) {
+    if (e)
+      return this.store.getStoredAgent(e);
+  }
+  dispose() {
+    this.conversationHistory.dispose(), this.registeredProviders.forEach((e) => e.dispose()), this.messages = [], this.events.dispatch("conversation:controller-disposed", this), this.active = !1;
+  }
+  onDispose(e) {
+    return this.events.subscribe("conversation:controller-disposed", e);
+  }
+  onStarted(e) {
+    return this.events.subscribe("conversation:started", e);
+  }
+  onMessageCreated(e) {
+    return this.events.subscribe("conversation:message-created", e);
+  }
+  isRehydrated() {
+    return this.store.isRehydrated();
+  }
+  disposeProvider(e) {
+    const t = this.providerIndex(e.name);
+    t > -1 && this.registeredProviders.splice(t, 1), this.events.dispatch("conversation:providers-changed", {
+      removed: [e.name]
+    }), this.registeredProviders.length || this.dispose();
+  }
+  onProvidersChange(e) {
+    return this.events.subscribe("conversation:providers-changed", e);
+  }
+  setComponentMountedState(e) {
+    this.componentMounted !== e && (this.componentMounted = e, e && (this.events.dispatch("conversation:unread-message", !1), this.events.dispatch("conversation:started", !0), this.active = !0), this.events.dispatch("conversation:component-mount-changed", e));
+  }
+  setProviderOptions(e, t) {
+    const n = this.providerIndex(e);
+    n > -1 && this.registeredProviders[n].setOptions(t);
+  }
+  changeProvider(e) {
+    this.registeredProviders.find(
+      (n) => n.name === e
+    ) && nt(this.container, this.id, e);
+  }
+  queueProviders(e) {
+    this.queuedProviders = e;
+  }
+  onCompleteProvider() {
+    const e = this.queuedProviders.pop();
+    e && nt(this.container, this.id, e);
+  }
+  getComponentMountedState() {
+    return this.componentMounted;
+  }
+  onUnreadMessage(e) {
+    return this.events.subscribe("conversation:unread-message", e);
+  }
+  createEntry(e, t, n, i, r) {
+    const o = {
+      key: e,
+      content: t,
+      type: n,
+      sender: i || null,
+      timestamp: r || r === null ? r : Date.now()
+    };
+    this.messages.push(o), o.type === "agent" && Bt(this.typingActors, i);
+    const a = new ni((c) => {
+      if (c !== null) {
+        const l = c, { timestamp: h = void 0 } = l, d = Et(l, ["timestamp"]);
+        o.content = d, h && (o.timestamp = h);
+      } else {
+        const h = this.messages.indexOf(o);
+        o.content = null, h > -1 && this.messages.splice(h, 1);
+      }
+      this.events.dispatch("conversation:message-updated", { message: o }), this.update();
+    });
+    return this.events.dispatch("conversation:message-created", { message: o }), this.update(), this.componentMounted || this.events.dispatch("conversation:unread-message", !0), a;
+  }
+  update() {
+    this.events.dispatch("conversation:updated", {
+      messages: this.messages,
+      loading: this.loaders > 0,
+      typingActors: this.typingActors
+    });
+  }
+  getMessageStream() {
+    return {
+      messages: this.messages,
+      loading: this.loaders > 0,
+      typingActors: this.typingActors
+    };
+  }
+  setTypingState(e, t) {
+    return this.typingActors.indexOf(e) === -1 && (this.typingActors.push(e), this.update()), () => {
+      Bt(this.typingActors, e), this.update();
+    };
+  }
+  /**
+   * Displays a loader in the conversation.
+   */
+  loader() {
+    this.loaders = this.loaders + 1;
+    let e = !1;
+    return this.loaders === 1 && this.update(), () => {
+      e || (e = !0, this.loaders = this.loaders - 1, this.loaders === 0 && this.update());
+    };
+  }
+  submitForm(e, t) {
+    this.formHandlers[e] = W(P({}, this.formHandlers[e]), { submit: t });
+  }
+  validateForm(e, t) {
+    this.formHandlers[e] = W(P({}, this.formHandlers[e]), { validate: t });
+  }
+  getHistory() {
+    return this.conversationHistory.getConversationLogs();
+  }
+}
+const ri = (s, e) => {
+  const t = s.split("_contact");
+  return e.widgets.get(t[0]);
+}, mt = (s) => {
+  const e = s.get("$widget"), { name: t, implementation: n } = s.get("$widget"), i = t.indexOf("_contact") > -1 ? ri(t, n) : e, { data: r } = s.get("$settings"), { trigger: o } = i.container.get("$settings"), a = `${t.replace("_contact-method", "").replace("_contact", "")}_contact-method`, c = n.widgets.get(a);
+  return c && !o ? { chatWidget: c, mainWidget: i, data: r } : { mainWidget: i, data: r };
+}, oi = (s) => {
+  const { chatWidget: e } = mt(s);
+  return !!e;
+}, Ut = (s, e, t) => {
+  const { mainWidget: n, data: i, chatWidget: r } = mt(s);
+  return r ? r.state === "activated" ? r.invoke("open").then(() => {
+    r.container.getAsync("conversation").then((o) => {
+      o.navigateToConversationIfActive(e.id);
+    });
+  }) : r.activate().then(() => {
+    const { trigger: o } = r.container.get("$settings");
+    return o.action = "hide", r.invoke("setSettings", () => ({
+      data: i,
+      trigger: o,
+      activate: !0
+    })).then(() => r.container.getAsync("components").then((a) => {
+      const c = a.components().ofType("contact-method");
+      a.write({
+        key: "setContactMethodId",
+        attributes: {
+          properties: {
+            id: e.id,
+            guideId: e.guideId
+          }
+        },
+        target: c,
+        provider: "localStorage"
+      });
+      const l = a.components().ofType("conversation");
+      a.write({
+        key: "setConversationProvider",
+        attributes: {
+          properties: { providers: [e.clientName] }
+        },
+        target: l,
+        provider: "localStorage"
+      });
+    }));
+  }).then(() => r.invoke("attach", {
+    key: "contact-method",
+    triggerDOMElement: t,
+    withRenderState: "open"
+  })).then(() => (Ce(
+    r.container,
+    "activeStickyWidget",
+    w.Necessary,
+    {
+      medium: $.Local,
+      scope: xe.Implementation
+    }
+  ).then((o) => o(r.name)), r.container.getAsync("conversation").then((o) => {
+    o.setConversationEndedBehavior(
+      be.Deactivate
+    );
+  }).then(() => !1))) : (n.container.getAsync("conversation").then((o) => o.navigateToConversationIfActive(e.id).then(
+    () => o.setConversationEndedBehavior(
+      be.Navigate
+    )
+  )), !r);
+}, ai = (s, e, t = "conversation") => {
+  const { mainWidget: n, chatWidget: i } = mt(s);
+  return i ? i.container.getAsync("router").then((r) => {
+    r.navigate(t, { id: e.id });
+  }) : n.container.getAsync("conversation").then((r) => {
+    var o;
+    (o = r.setConversationEndedBehavior(be.Navigate)) == null || o.then(() => {
+      n.container.getAsync("router").then((a) => {
+        n.container.getAsync("components").then((c) => {
+          const l = c.components().ofType("conversation");
+          c.write({
+            key: "setConversationProvider",
+            attributes: {
+              properties: { providers: [e.clientName] }
+            },
+            target: l,
+            provider: "localStorage"
+          });
+        }).then(() => {
+          a.navigate(t, { id: e.id });
+        });
+      });
+    });
+  });
+}, te = "conversations";
+var be = /* @__PURE__ */ ((s) => (s.Deactivate = "deactivate", s.Navigate = "navigate", s.None = "none", s))(be || {});
+class ft {
+  constructor(e, t) {
+    this.container = e, this.components = t, this.controllers = [], this.providers = [], this.disposeProviders = {}, this.subscriptions = [], this.storageWriter = null, this.router = null, this.buttonQuery = null, this.sessionInfo = null;
+    const n = e.get("$widget");
+    this.events = n.events.createChild(this);
+  }
+  initialize() {
+    Ce(
+      this.container,
+      te,
+      w.Necessary,
+      {
+        medium: $.Local
+      }
+    ).then((e) => this.storageWriter = e), J(
+      this.container,
+      te,
+      $.Local
+    ).then((e) => {
+      this.buttonQuery = this.components.components().ofType("conversation-return-button"), e && (this.sessionInfo = e, e.id && e.route && this.writeToComponents({ active: !0, alert: { show: !1 } }));
+    }), this.container.getAsync("router").then((e) => this.router = e), this.events.subscribe("conversation:ended", (e, t) => {
+      var n, i, r;
+      switch ((n = this.sessionInfo) == null ? void 0 : n.conversationEndedBehavior) {
+        case "deactivate":
+          this.container.get("$widget").deactivate();
+          break;
+        case "navigate":
+          const a = (i = this.router) == null ? void 0 : i.getInitialRoute();
+          a && ((r = this.router) == null || r.navigate(a.name));
+          break;
+      }
+      this.writeToComponents({ active: !1 }), this.sessionInfo = null, this.storageWriter && this.storageWriter();
+    });
+  }
+  addSubscription(e) {
+    this.subscriptions.push(e);
+  }
+  static getInstance(e, t = "conversation") {
+    return oe(e)(() => e.getAsync(t).then((n) => {
+      let i = n;
+      return i || Dn.getInstance(e).then((r) => (i = new ft(e, r), i.initialize(), e.registerAsync(t, () => i), i));
+    }));
+  }
+  navigateToConversationIfActive(e) {
+    return J(
+      this.container,
+      te,
+      $.Local
+    ).then((t) => {
+      var n;
+      if (t && t.id === e && t.route) {
+        const { name: i, params: r } = t.route;
+        (n = this.router) == null || n.navigate(i, r);
+      }
+    });
+  }
+  setConversationEndedBehavior(e) {
+    return J(
+      this.container,
+      te,
+      $.Local
+    ).then((t) => {
+      let n = t;
+      return n ? n.conversationEndedBehavior = e : n = { conversationEndedBehavior: e }, this.sessionInfo = n, this.storageWriter && this.storageWriter(this.sessionInfo) || Promise.resolve();
+    });
+  }
+  createController(e, t) {
+    return b(this, null, function* () {
+      const n = ks(e), { agents: i } = (yield J(this.container, n)) || { agents: [] }, r = this.controllers.findIndex((a) => a.conversation.id === e);
+      let o;
+      return r > -1 ? o = this.controllers[r].conversation : o = new ii(this.container, e, t), o.setInitialStorage({ agents: i || [] }), o;
+    });
+  }
+  registerProvider(e, t) {
+    const n = {
+      name: e,
+      handler: t
+    };
+    this.providers.push(n), this.controllers.filter(
+      (i) => i.conversation.providers.indexOf(e) > -1
+    ).forEach((i) => {
+      this.invokeHandler(n, i);
+    });
+  }
+  registerController(e, t) {
+    const n = this.controllers.findIndex(
+      (r) => r.conversation.id === e.id
+    );
+    let i;
+    if (n < 0) {
+      i = { conversation: e, component: t }, this.controllers.push(i);
+      const r = (o) => {
+        o && this.providers.filter((a) => o.indexOf(a.name) > -1).forEach((a) => {
+          this.invokeHandler(a, i);
+        });
+      };
+      return this.subscriptions.push(
+        e.onDispose((o, a) => {
+          const c = this.controllers.findIndex(
+            (l) => l.conversation === a
+          );
+          c > -1 && this.controllers.splice(c, 1), this.components.components().ofType("conversation-return-button").select().writeProperties({ active: !1 }), this.events.dispatch("conversation:ended", {}, { bubbles: !0 });
+        })
+      ), this.subscriptions.push(
+        e.onProvidersChange((o, a) => {
+          const {
+            added: c,
+            removed: l = []
+          } = a;
+          l.forEach((h) => {
+            (this.disposeProviders[h] || []).forEach(
+              (d) => {
+                d();
+              }
+            );
+          }), r(c);
+        })
+      ), this.subscriptions.push(
+        e.onStarted((o, a) => {
+          var l, h;
+          const c = {
+            id: e.id,
+            route: (l = this.router) == null ? void 0 : l.getRouteData(),
+            conversationEndedBehavior: (h = this.sessionInfo) == null ? void 0 : h.conversationEndedBehavior
+          };
+          this.sessionInfo = c, this.storageWriter && this.storageWriter(c), this.writeToComponents({ active: a });
+        })
+      ), this.subscriptions.push(
+        e.onUnreadMessage((o, a) => {
+          this.events.dispatch("conversation:unread-message", a), this.writeToComponents({ alert: { show: a } });
+        })
+      ), r(e.providers), !0;
+    }
+    return i = this.controllers[n], !1;
+  }
+  writeToComponents(e, t = "conversationReturnButtonState") {
+    this.buttonQuery && this.components.write({
+      key: "conversationReturnButtonState",
+      attributes: { properties: e },
+      target: this.buttonQuery,
+      provider: "localStorage"
+    });
+  }
+  invokeHandler(e, t) {
+    const n = e.handler(
+      t.conversation.createProvider(e.name),
+      t.component
+    );
+    n && (this.disposeProviders[e.name] || (this.disposeProviders[e.name] = []), this.disposeProviders[e.name].push(n));
+  }
+  getComponentRoute() {
+    return J(
+      this.container,
+      te,
+      $.Local
+    ).then((e) => e == null ? void 0 : e.route);
+  }
+  dispose() {
+    Object.keys(this.disposeProviders).forEach((e) => {
+      this.disposeProviders[e].forEach((t) => {
+        t();
+      });
+    }), this.subscriptions.forEach((e) => {
+      e();
+    }), this.controllers = [], this.providers = [];
+  }
+  static handleContactMethodClick(e, t, n, i) {
+    return b(this, null, function* () {
+      if (oi(t)) {
+        e.preventDefault();
+        let r = document.getElementById("humany-dynamic-anchor");
+        r || (r = document.createElement("a"), r.setAttribute("href", "#"), r.id = "humany-dynamic-anchor", document.body.appendChild(r)), Ut(t, n, r);
+      }
+      Ut(t, n);
+    });
+  }
+  static handleContactMethodSubmit(e, t) {
+    return b(this, null, function* () {
+      var n, i;
+      return (i = (n = t == null ? void 0 : t.body.form.meta) == null ? void 0 : n.conversation) != null && i.id ? nt(
+        e,
+        t.body.form.meta.conversation.id,
+        t.clientName
+      ) : ai(e, t);
+    });
+  }
+}
+var ci = (s, e, t) => new Promise((n, i) => {
+  var r = (c) => {
+    try {
+      a(t.next(c));
+    } catch (l) {
+      i(l);
+    }
+  }, o = (c) => {
+    try {
+      a(t.throw(c));
+    } catch (l) {
+      i(l);
+    }
+  }, a = (c) => c.done ? n(c.value) : Promise.resolve(c.value).then(r, o);
+  a((t = t.apply(s, e)).next());
+});
+const qe = (s, e, t, ...n) => {
+  const i = `[${s.get("$environment").name || "webprovisions"}] ${t}`;
+  switch (e) {
+    case "info":
+      console.info(i, ...n);
+      break;
+    case "warning":
+      console.warn(i, ...n);
+      break;
+    case "error":
+      console.error(i, ...n);
+      break;
+  }
+}, hi = (s) => {
+  const e = s.container || s;
+  return {
+    info: (t, ...n) => qe(e, "info", t, ...n),
+    warn: (t, ...n) => qe(e, "warning", t, ...n),
+    error: (t, ...n) => qe(e, "error", t, ...n)
+  };
+};
+var we = /* @__PURE__ */ ((s) => (s.Implementation = "implementation", s.Widget = "widget", s))(we || {}), q = /* @__PURE__ */ ((s) => (s.Pre = "pre", s.Post = "post", s))(q || {});
+const li = (s, e, t, n) => {
+  try {
+    const i = new e(t, n);
+    return {
+      name: s,
+      invoke: (r, o) => {
+        let a;
+        return i[r] && (a = i[r].call(i, o)), Promise.resolve(a);
+      },
+      getInstance: () => i
+    };
+  } catch (i) {
+    if (i.message && i.message.indexOf("is not a constructor") >= 0)
+      return {
+        name: s,
+        invoke: (r) => {
+          let o;
+          return r === "initialize" && (o = e(t, n)), Promise.resolve(o);
+        },
+        getInstance: () => e
+      };
+    throw i;
+  }
+};
+function Kt(s, e) {
+  return typeof s == "undefined" ? e : s;
+}
+let di = class {
+  constructor(s = {}) {
+    this.part = s;
+  }
+  createCommand(s, e, t) {
+    let n;
+    typeof e == "function" ? n = {
+      scope: we.Widget,
+      stage: q.Post,
+      defaultArgs: void 0,
+      handlerResolver: e
+    } : n = {
+      scope: Kt(e.scope, we.Widget),
+      stage: Kt(e.stage, q.Post),
+      defaultArgs: e.defaultArgs,
+      handlerResolver: t
+    };
+    let i = this.part;
+    const r = s.split(".");
+    return r.forEach((o, a) => {
+      a === r.length - 1 ? i[o] || (i[o] = () => n) : i = this.part[o] = this.part[o] || {};
+    }), this;
+  }
+  get() {
+    return this.part;
+  }
+};
+const vt = (s) => {
+  const e = new di({});
+  return s(e), e.get();
+};
+vt((s) => {
+  s.createCommand(
+    "types.register",
+    { scope: we.Implementation, stage: q.Pre },
+    (e) => (t, n) => {
+      e.container.get("$types")[t] = n;
+    }
+  ).createCommand(
+    "type",
+    { stage: q.Pre },
+    (e) => (t) => {
+      e.container.register("$type", t);
+    }
+  ).createCommand(
+    "settings",
+    { stage: q.Pre, defaultArgs: [null] },
+    (e) => (t) => {
+      e.events.dispatch(
+        "settings:change",
+        t,
+        { bubbles: !0 }
+      ), e.container.register("$settings", t);
+    }
+  ).createCommand(
+    "plugin",
+    { stage: q.Pre },
+    (e) => (t, n, i) => {
+      const { container: r } = e;
+      let o = null, a = t, c = n;
+      typeof t == "string" && (o = t, a = n, c = i);
+      const l = (h) => {
+        const { transformPluginSettings: d } = e.container.get("$environmentOptions"), p = d ? d(
+          c || {},
+          o,
+          e.container,
+          a
+        ) : n;
+        try {
+          const u = li(
+            o,
+            a,
+            r,
+            p
+          );
+          r.get("$plugins").push(u), h && u.invoke("initialize", null);
+        } catch (u) {
+          hi(e).warn("Error when initializing plugin", u);
+        }
+      };
+      e.container.get("$instance") ? l(!0) : e.events.subscribeOnce("widget:instance-created", () => l(!1));
+    }
+  ).createCommand(
+    "container.register",
+    (e) => (t, n) => {
+      e.container.register(t, n);
+    }
+  ).createCommand(
+    "container.registerAsync",
+    (e) => (t, n) => {
+      e.container.registerAsync(t, n);
+    }
+  ).createCommand(
+    "container.registerFactory",
+    (e) => (t, n) => {
+      e.container.registerFactory(t, n);
+    }
+  ).createCommand(
+    "container.touch",
+    (e) => (t, n) => {
+      e.container.touch(t, n);
+    }
+  ).createCommand(
+    "csp",
+    {},
+    (e) => (t) => {
+      e.container.register("csp", t);
+    }
+  );
+});
+const Se = (s, e, ...t) => typeof e == "string" ? s(`[humany] ${e}`, ...t) : s(e, ...t), ne = class {
+  constructor() {
+    this.keys = [], this.log = (s, ...e) => this.lookup(s, () => ne.log(...e)), this.warn = (s, ...e) => this.lookup(s, () => ne.warn(...e)), this.error = (s, ...e) => this.lookup(s, () => ne.error(...e)), this.info = (s, ...e) => this.lookup(s, () => ne.info(...e));
+  }
+  lookup(s, e) {
+    this.keys.indexOf(s) === -1 && (this.keys.push(s), e());
+  }
+};
+let E = ne;
+E.log = (...s) => Se(console.log, ...s);
+E.warn = (...s) => Se(console.warn, ...s);
+E.error = (...s) => Se(console.error, ...s);
+E.info = (...s) => Se(console.info, ...s);
+const Os = (s) => {
+  let e = {}, t, n;
+  if (typeof s != "object" || s === null)
+    return s;
+  e = Array.isArray(s) ? [] : {};
+  for (n in s)
+    t = s[n], e[n] = typeof t == "object" && t !== null ? Os(t) : t;
+  return e;
+}, ui = Os;
+function Qt(s) {
+  let e = 0;
+  if (s.length === 0)
+    return e.toString();
+  for (let t = 0; t < s.length; t++) {
+    const n = s.charCodeAt(t);
+    e = (e << 5) - e + n, e = e & e;
+  }
+  return e.toString();
+}
+let pi = class {
+  constructor(s, e) {
+    this.lockWarningTime = s, this.lockErrorTime = e, this.tasks = [], this.current = Promise.resolve(), this.next = this.next.bind(this);
+  }
+  add(s, e, t, n) {
+    this.tasks.push({ task: s, resolve: e, reject: t, done: n }), this.next();
+  }
+  next() {
+    this.current = this.current.then(() => {
+      const s = this.tasks.shift();
+      if (s) {
+        let e;
+        const t = setTimeout(() => {
+          process.env.NODE_ENV !== "production" && E.warn(
+            `A lock has exceeded ${this.lockWarningTime} ms. Waiting additional ${this.lockErrorTime} ms before rejecting the task.`,
+            s
+          ), e = setTimeout(() => {
+            s.reject("lock timeout exceeded");
+          }, this.lockErrorTime);
+        }, this.lockWarningTime), n = Promise.resolve(s.task()).then((i) => (clearTimeout(t), clearTimeout(e), i));
+        return Promise.resolve(n).then(this.next).then(
+          () => n.then((i) => {
+            s.done(), s.resolve(i);
+          })
+        ).catch((i) => (s.done(), s.reject(i), this.next()));
+      }
+      return Promise.resolve();
+    });
+  }
+};
+const ue = /* @__PURE__ */ new WeakMap();
+function Ne(s, e = 5e3, t = 1e3) {
+  return ue.has(s) || ue.set(s, new pi(e, t)), (n) => new Promise((i, r) => {
+    const o = ue.get(s);
+    o.add(n, i, r, () => {
+      o.tasks.length || ue.delete(s);
+    });
+  });
+}
+const z = () => Math.floor((1 + Math.random()) * 65536).toString(16).substring(1);
+function _e() {
+  return z() + z() + "-" + z() + "-" + z() + "-" + z() + "-" + z() + z() + z();
+}
+var gi = Object.defineProperty, mi = Object.defineProperties, fi = Object.getOwnPropertyDescriptors, Yt = Object.getOwnPropertySymbols, vi = Object.prototype.hasOwnProperty, yi = Object.prototype.propertyIsEnumerable, Gt = (s, e, t) => e in s ? gi(s, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : s[e] = t, bi = (s, e) => {
+  for (var t in e || (e = {}))
+    vi.call(e, t) && Gt(s, t, e[t]);
+  if (Yt)
+    for (var t of Yt(e))
+      yi.call(e, t) && Gt(s, t, e[t]);
+  return s;
+}, wi = (s, e) => mi(s, fi(e));
+const $i = (s) => {
+  const e = [];
+  return [
+    (t, n) => {
+      e.push(s.subscribe(t, n));
+    },
+    () => {
+      e.forEach((t) => {
+        t();
+      });
+    }
+  ];
+};
+let Ie = class {
+  constructor(s, e = []) {
+    this.platform = s, this.rules = e;
+  }
+  match(s) {
+    return this.rules.every((e) => !(e.id && e.id !== s.id || e.type && e.type !== s.type));
+  }
+  ofType(s) {
+    return this.rules.push({ type: s }), this;
+  }
+  withId(s) {
+    return this.rules.push({ id: s }), this;
+  }
+  select() {
+    return new Pi(this.platform, this);
+  }
+};
+class xs {
+  constructor(e, t, n) {
+    this.platform = e, this.node = t, this.actions = new yt(
+      e,
+      new Ie(e).withId(t.id),
+      n
+    );
+    const [i, r] = $i(this.platform.events);
+    this.subscribe = i, this.unsubscribe = r;
+  }
+  properties(e) {
+    return e && this.node.touchProperties((t) => e(t)), this.node.attributes.properties;
+  }
+  context(e) {
+    return e && this.subscribe("components:context-changed", (t, { node: n }) => {
+      n === this.node && e(this.node.attributes.context);
+    }), this.node.attributes.context;
+  }
+  layout(e) {
+    return e && this.subscribe("components:layout-changed", (t, { node: n }) => {
+      n === this.node && e(this.node.attributes.layout);
+    }), this.node.attributes.layout;
+  }
+  writeProperties(e, t) {
+    this.node.writeProperties(e, t);
+  }
+  writeContext(e, t) {
+    this.node.writeProperties(e, t);
+  }
+  writeLayout(e, t) {
+    this.node.writeLayout(e, t);
+  }
+  dispose() {
+    this.unsubscribe(), this.actions.dispose();
+  }
+}
+class Pi {
+  constructor(e, t, n = !0) {
+    this.platform = e, this.target = t, this.clearOnDispose = n, this.removes = [], this.actions = new yt(this.platform, this.target);
+  }
+  writeProperties(e, t) {
+    this.removes.push(
+      this.platform.write({
+        options: t,
+        attributes: { properties: e },
+        target: this.target,
+        removable: this.clearOnDispose
+      })
+    );
+  }
+  writeContext(e, t) {
+    this.removes.push(
+      this.platform.write({
+        options: t,
+        attributes: { context: e },
+        target: this.target,
+        removable: this.clearOnDispose
+      })
+    );
+  }
+  writeLayout(e, t) {
+    this.removes.push(
+      this.platform.write({
+        options: t,
+        attributes: { layout: e },
+        target: this.target,
+        removable: this.clearOnDispose
+      })
+    );
+  }
+  dispose() {
+    this.removes.forEach((e) => {
+      e();
+    }), this.actions.dispose();
+  }
+}
+const ki = (s, e, t) => {
+  const n = s.concat(), i = (r, o, a) => {
+    let c = !0;
+    if (n.length) {
+      const l = n.shift(), h = (d, p) => (c = !1, i(d, Object.assign({}, o, p), a));
+      return Promise.resolve(l(r, h, a)).then((d) => wi(bi({}, d), {
+        cancelled: c
+      }));
+    }
+    return Promise.resolve({ data: r, cancelled: !1, options: o });
+  };
+  return i(e, {}, t);
+};
+let yt = class {
+  constructor(s, e, t) {
+    this.platform = s, this.target = e, this.ns = t, this.subscriptions = [], this.create = this.create.bind(this);
+  }
+  create(s, e = () => {
+  }) {
+    const t = {
+      key: s,
+      fn: e,
+      target: this.target,
+      ns: this.ns
+    };
+    this.platform.actionsState.handlers.push(t);
+    const n = () => {
+      const i = this.platform.actionsState.handlers.indexOf(t);
+      i > -1 && this.platform.actionsState.handlers.splice(i, 1);
+    };
+    return this.subscriptions.push(n), n;
+  }
+  dispatch(s, e) {
+    const t = this.platform.nodes.all.concat(
+      this.platform.nodes.detached
+    ), n = {}, i = this.platform.actionsState.handlers.filter(
+      (r) => r.key === s && (!r.ns || !this.ns || r.ns === this.ns)
+    );
+    return Promise.all(
+      i.map((r) => {
+        const o = t.filter(
+          (c) => r.target.match(c) && this.target.match(c)
+        ), a = this.platform.actionsState.watchers.filter((c) => c.key === s && (!c.ns || !this.ns || c.ns === this.ns) && o.some((l) => c.target.match(l))).map((c) => c.fn);
+        return Promise.all(
+          o.map((c) => {
+            const l = new xs(
+              this.platform,
+              c,
+              this.ns
+            );
+            return ki(a, e, l).then((h) => {
+              const { data: d = {}, options: p, cancelled: u } = h;
+              return Promise.resolve(
+                u ? {} : r.fn(d, p, l)
+              ).then((g) => {
+                n[c.id] = g;
+              });
+            });
+          })
+        );
+      })
+    ).then(() => n);
+  }
+  watch(s, e) {
+    let t = s, n = this.ns;
+    const i = s.split(".");
+    i.length > 1 && (n = i[0], t = i.splice(1).join("."));
+    const r = {
+      fn: e,
+      target: this.target,
+      key: t,
+      ns: n
+    };
+    this.platform.actionsState.watchers.push(r);
+    const o = () => {
+      const a = this.platform.actionsState.watchers.indexOf(r);
+      a > -1 && this.platform.actionsState.watchers.splice(a, 1);
+    };
+    return this.subscriptions.push(o), o;
+  }
+  dispose() {
+    this.subscriptions.forEach((s) => s());
+  }
+};
+vt((s) => {
+  s.createCommand("components", (e) => (t) => {
+    e.events.subscribeOnce("components:platform-created", (n, { platform: i }) => {
+      t.handlers && t.handlers.forEach(([r, o]) => {
+        i.addComponentHandler(r, o);
+      });
+    });
+  });
+});
+let Xt = class {
+  constructor(s, e) {
+    this.events = s, this.tags = [], this.children = {}, this.changesets = [], this.mountCount = 0, this.id = _e(), this.type = e, this.attributes = {
+      context: {},
+      properties: {},
+      layout: {},
+      tags: []
+    }, this.writeLayout({ size: "full", indent: 0 });
+  }
+  mount(s, e) {
+    let t = s.get("mounted-nodes");
+    return t || (t = /* @__PURE__ */ new Map(), s.register("mounted-nodes", t)), t.has(this) ? (process.env.NODE_ENV !== "production" && E.error("Trying to mount an already mounted component node.", this), () => {
+    }) : (this.events.dispatch("components:node-mounted", { node: this }), this.mountCount === 0 && (this.mountCount = this.mountCount + 1, this.events.dispatch("components:node-enter", { node: this })), () => {
+      t.delete(this), this.events.dispatch("components:node-unmounted", { node: this }), this.mountCount = this.mountCount - 1, this.mountCount === 0 && this.events.dispatch("components:node-exit", { node: this });
+    });
+  }
+  appendChild(s, e = "default") {
+    if (s.parent) {
+      if (s.parent === this)
+        return;
+      s.parent.removeChild(s);
+    }
+    s.parent = this, this.children[e] || (this.children[e] = []), this.children[e].push(s), this.events.dispatch("components:node-appended", { node: s });
+  }
+  prependChild(s, e = "default") {
+    if (s.parent) {
+      if (s.parent === this)
+        return;
+      s.parent.removeChild(s);
+    }
+    s.parent = this, this.children[e] || (this.children[e] = []), this.children[e].unshift(s), this.events.dispatch("components:node-appended", { node: s });
+  }
+  touchProperties(s, e = {}, t) {
+    const n = [{ properties: s }, e];
+    return this.changesets.push(n), this.events.dispatch("components:set-properties", { node: this }), () => {
+      if (t) {
+        const i = this.changesets.indexOf(n);
+        i > -1 && (this.changesets.splice(i, 1), this.events.dispatch("components:set-properties", { node: this }));
+      }
+    };
+  }
+  writeProperties(s, e = {}, t) {
+    const n = [{ properties: s }, e];
+    return this.changesets.push(n), this.events.dispatch("components:set-properties", { node: this }), () => {
+      if (t) {
+        const i = this.changesets.indexOf(n);
+        i > -1 && (this.changesets.splice(i, 1), this.events.dispatch("components:set-properties", { node: this }));
+      }
+    };
+  }
+  writeLayout(s, e = {}, t) {
+    const n = [{ layout: s }, e];
+    return this.changesets.push(n), this.events.dispatch("components:set-layout", { node: this }), () => {
+      if (!t)
+        return;
+      const i = this.changesets.indexOf(n);
+      i > -1 && (this.changesets.splice(i, 1), this.events.dispatch("components:set-layout", { node: this }));
+    };
+  }
+  writeContext(s, e = {}, t) {
+    const n = [{ context: s }, e];
+    return this.changesets.push(n), this.events.dispatch("components:set-context", { node: this }), () => {
+      if (!t)
+        return;
+      const i = this.changesets.indexOf(n);
+      i > -1 && (this.changesets.splice(i, 1), this.events.dispatch("components:set-context", { node: this }));
+    };
+  }
+  getChildren(s = "default") {
+    const e = this.children[s] || [];
+    return e.reduce((t, n, i) => {
+      const { order: r = i } = n.attributes.layout;
+      return t[r] ? t.splice(r, 0, n) : t[r] = n, t;
+    }, Array(e.length));
+  }
+  remove() {
+    this.parent && this.parent.removeChild(this);
+  }
+  removeChild(s) {
+    Object.keys(this.children).forEach((e) => {
+      const t = this.children[e], n = t.indexOf(s);
+      n > -1 && (t.splice(n, 1), this.events.dispatch("components:node-removed", { node: s, parentNode: this }));
+    }), delete s.parent;
+  }
+};
+const Cs = (s, e, t) => {
+  for (let n = 0, i = s.length; n < i && t(s[n]) !== !0; n++) {
+    const r = e[s[n].id] || "default", o = s[n].getChildren(r);
+    Cs(o, e, t);
+  }
+}, bt = (s, e, t) => {
+  if (t(s) !== !0) {
+    const n = e[s.id] || "default", i = s.children[n];
+    Cs(i, e, t);
+  }
+}, Fe = (s, e) => {
+  const t = [];
+  return bt(s, e, (n) => {
+    t.push(n);
+  }), t;
+}, Oi = (s, e, t) => {
+  let n;
+  return bt(s, e, (i) => {
+    if (t(i))
+      return n = i, !0;
+  }), n;
+};
+let xi = class {
+  constructor(s, e, t) {
+    this.root = s, this.switches = e, this.all = [], this.visible = [], this.detached = [], t.subscribe("components:node-appended", (n, i) => {
+      this.all.push(i.node), this.visible = Fe(s, e);
+    }), t.subscribe("components:node-removed", (n, i) => {
+      let r = this.all.indexOf(i.node);
+      r > -1 && this.all.splice(r, 1), r = this.visible.indexOf(i.node), r > -1 && this.visible.splice(r, 1), this.visible = Fe(s, e);
+    }), t.subscribe("components:node-switched", (n, i) => {
+      this.visible = Fe(s, e);
+    });
+  }
+  query(s = {}) {
+    const e = [];
+    return bt(this.root, this.switches, (t) => {
+      Object.keys(s).every((n) => s[n] === t[n]) && e.push(t);
+    }), e;
+  }
+  get(s) {
+    return Oi(this.root, this.switches, (e) => e.id === s) || this.detached.find((e) => e.id === s);
+  }
+}, Ci = class {
+  constructor() {
+    this.handlers = /* @__PURE__ */ new Map();
+  }
+  add(s, e) {
+    this.handlers.set(s, e);
+  }
+  get(s) {
+    return this.handlers.get(s);
+  }
+};
+const Ei = (s) => {
+  let e = s, t = 0;
+  for (; e.parent; )
+    t = t + 1, e = e.parent;
+  return t;
+}, Ai = (s) => s.map(([e, t]) => [Ei(e), e, t]).sort(([e], [t]) => e - t).map(([, e, t]) => [e, t]), Be = (s) => s instanceof Date ? !1 : s && typeof s == "object" && !Array.isArray(s), _ = (s, ...e) => {
+  if (!e.length)
+    return s;
+  const t = e.shift();
+  if (Be(s) && Be(t))
+    for (const n in t)
+      Be(t[n]) ? (s[n] || Object.assign(s, { [n]: {} }), _(s[n], t[n])) : Object.assign(s, { [n]: t[n] });
+  return _(s, ...e);
+}, Si = (s, e) => !s || s === "all" ? !0 : s.some((t) => e.indexOf(t) > -1), Ni = (s, e) => {
+  let t = [], n = [], i;
+  const r = () => {
+    process.env.NODE_ENV !== "production" && console.time("state-processor.flush");
+    const a = /* @__PURE__ */ new Map(), c = Ai(t.map((h, d) => [h, n[d]])), l = (h, d) => {
+      var p;
+      const u = a.get(h) || {}, g = d.context && !u.context, y = d.properties && !u.properties, O = d.layout && !u.layout;
+      a.set(h, {
+        context: u.context || g,
+        properties: u.properties || y,
+        layout: u.layout || O
+      }), y && (h.attributes.properties = {}), O && (h.attributes.layout = {}), g && (h.attributes.context = _({}, (p = h.parent) == null ? void 0 : p.attributes.context));
+      const D = [], X = [], Z = [];
+      if (h.changesets.forEach((v) => {
+        const [m, V] = v;
+        Si(V.breakpoints, s.breakpoints) && (y && (typeof m.properties == "function" ? D.push(
+          m.properties
+        ) : _(h.attributes.properties, m.properties)), O && (typeof m.layout == "function" ? X.push(m.layout) : _(h.attributes.layout, m.layout)), g && (typeof m.context == "function" ? Z.push(m.context) : _(h.attributes.context, m.context)));
+      }), D.forEach((v) => {
+        _(h.attributes.properties, v(h.attributes.properties));
+      }), X.forEach((v) => {
+        _(h.attributes.layout, v(h.attributes.layout));
+      }), Z.forEach((v) => {
+        _(h.attributes.context, v(h.attributes.context));
+      }), g || d.recursive) {
+        const v = s.getBranch(h), m = d.recursive ? d : {
+          context: !!g
+        };
+        h.getChildren(v).forEach((V) => {
+          l(V, m);
+        });
+      }
+    };
+    process.env.NODE_ENV !== "production" && console.timeEnd("state-processor.flush"), c.forEach(([h, d]) => {
+      l(h, d);
+    }), t = [], n = [], e(a);
+  }, o = () => {
+    clearTimeout(i), i = setTimeout(r, 0);
+  };
+  return (a, c) => {
+    const l = t.indexOf(a);
+    if (l > -1) {
+      const h = n[l];
+      return c.context && (h.context = !0), c.properties && (h.properties = !0), c.layout && (h.layout = !0), c.recursive && (h.recursive = !0), o();
+    }
+    return t.push(a), n.push(c), o();
+  };
+};
+let Es = class {
+  constructor(s, e = {}) {
+    this.providers = e, this.breakpoints = [], this.actionsState = { handlers: [], watchers: [] }, this.switches = {}, this.changesets = [], this.subscriptions = [], this.customComponentHandler = new Ci(), this.events = s.events.createChild(this);
+    const t = new Xt(this.events, "root");
+    t.name = `root-${s.name}`, this.nodes = new xi(t, this.switches, this.events);
+    const n = this.processNode = Ni(this, (i) => {
+      const r = Array.from(i.keys());
+      process.env.NODE_ENV !== "production" && console.info(`STATE PROCESSOR: ${r.length} node(s) processed:
+${r.map(
+        (o) => `${o.name || "<no name>"} (${o.id})
+`
+      )}`), r.forEach((o) => {
+        const a = i.get(o);
+        o.parent && o.parent.type === "root" && this.events.dispatch("components:root-children-changed", { node: o }), a != null && a.context && this.events.dispatch("components:context-changed", { node: o }), a != null && a.properties && this.events.dispatch("components:properties-changed", { node: o }), a != null && a.layout && this.events.dispatch("components:layout-changed", { node: o });
+      }), this.events.dispatch("components:component-model-initialized", {}, { bubbles: !0 });
+    });
+    Promise.all(
+      Object.keys(e).map((i) => e[i].load(this))
+    ), this.subscriptions.push(
+      this.events.subscribe(
+        "components:node-appended",
+        (i, r) => {
+          const { node: o } = r;
+          this.changesets.forEach((a) => {
+            const { changeset: c, target: l, removes: h } = a, [d, p] = c;
+            l.match(r.node) && (d.properties && h.push(o.writeProperties(d.properties, p)), d.context && h.push(o.writeContext(d.context, p)), d.layout && h.push(o.writeLayout(d.layout, p)));
+          });
+        }
+      )
+    ), this.subscriptions.push(
+      this.events.subscribe(
+        "components:node-appended",
+        (i, r) => {
+          n(r.node, { properties: !0, context: !0 });
+        }
+      )
+    ), this.subscriptions.push(
+      this.events.subscribe(
+        "components:set-properties",
+        (i, r) => {
+          n(r.node, { properties: !0 });
+        }
+      )
+    ), this.subscriptions.push(
+      this.events.subscribe(
+        "components:set-context",
+        (i, r) => {
+          n(r.node, { properties: !0, context: !0 });
+        }
+      )
+    ), this.subscriptions.push(
+      this.events.subscribe(
+        "components:set-indent",
+        (i, r) => {
+          n(r.node, { layout: !0 });
+        }
+      )
+    ), this.subscriptions.push(
+      this.events.subscribe(
+        "components:set-layout",
+        (i, r) => {
+          n(r.node, { layout: !0 });
+        }
+      )
+    ), this.subscriptions.push(
+      this.events.subscribe("components:node-switched", (i, { node: r, branch: o }) => {
+        n(r, {
+          layout: !0,
+          recursive: !0,
+          properties: !0,
+          context: !0
+        });
+      })
+    ), this.subscriptions.push(
+      this.events.subscribe("components:node-removed", (i, { parentNode: r }) => {
+        n(r, { properties: !0 });
+      })
+    ), this.events.parent && this.events.parent.dispatch("components:platform-created", { platform: this });
+  }
+  static getInstance(s) {
+    return s.getAsync("components");
+  }
+  addBreakpoint(s) {
+    this.breakpoints.indexOf(s) === -1 && (this.breakpoints.push(s), this.processNode(this.nodes.root, {
+      context: !0,
+      properties: !0,
+      layout: !0,
+      recursive: !0
+    }));
+  }
+  removeBreakpoint(s) {
+    const e = this.breakpoints.indexOf(s);
+    e > -1 && (this.breakpoints.splice(e, 1), this.processNode(this.nodes.root, {
+      context: !0,
+      properties: !0,
+      layout: !0,
+      recursive: !0
+    }));
+  }
+  setSwitch(s, e) {
+    this.switches[s.id] = e, this.events.dispatch("components:node-switched", { node: s, branch: e });
+  }
+  getBranch(s) {
+    return this.switches[s.id];
+  }
+  /**
+   * Creates a `ComponentNode` of the specified type.
+   * @param type Type of node.
+   */
+  createNode(s, e = {}) {
+    const t = new Xt(this.events, s);
+    return e.detached && this.nodes.detached.push(t), t;
+  }
+  components() {
+    return new Ie(this);
+  }
+  actions(s, e) {
+    return new yt(this, s, e);
+  }
+  write(s) {
+    const { provider: e, target: t, attributes: n, options: i = {}, removable: r } = s, o = s.key || _e(), a = { changeset: [n, i], target: t, removes: [] };
+    if (e) {
+      const c = this.providers[e];
+      c.write(o, t, n, i), a.removes.push(() => {
+        c.remove(o);
+      });
+    }
+    return this.changesets.push(a), this.nodes.all.forEach((c) => {
+      if (t.match(c)) {
+        let l = () => {
+        };
+        n.properties && (l = c.writeProperties(n.properties, i, r)), n.context && (l = c.writeContext(n.context, i, r)), n.layout && (l = c.writeContext(n.layout, i, r)), a.removes.push(l);
+      }
+    }), () => {
+      if (r) {
+        a.removes.forEach((l) => l());
+        const c = this.changesets.indexOf(a);
+        c > -1 && this.changesets.splice(c, 1);
+      }
+    };
+  }
+  addComponentHandler(s, e) {
+    this.customComponentHandler.add(s, e);
+  }
+  getComponentHandler(s) {
+    return this.customComponentHandler.get(s);
+  }
+  dispose() {
+    this.subscriptions.forEach((s) => s());
+  }
+};
+const _i = (s, e, t, n = _e(), i = {}) => s.getAsync("components").then((r) => {
+  let o;
+  if (typeof e == "string") {
+    const l = new Ie(r);
+    l.ofType(e), o = l;
+  } else
+    o = e;
+  const a = {}, c = (l) => {
+    const h = a[l.id];
+    return h ? Promise.resolve(h.controller) : Es.getInstance(s).then((d) => new xs(d, l, n));
+  };
+  r.events.subscribe(
+    "components:node-enter",
+    (l, { node: h }) => {
+      o.match(h) && c(h).then((d) => {
+        Promise.resolve(t(d)).then((p) => {
+          a[h.id] = {
+            dispose: p,
+            controller: d
+          };
+        });
+      });
+    }
+  ), r.events.subscribe(
+    "components:node-exit",
+    (l, { node: h }) => {
+      const d = a[h.id];
+      d && (d.dispose && d.dispose(), i.reuseController || (d.controller.dispose(), delete a[h.id]));
+    }
+  );
+});
+process.env.NODE_ENV;
+var Ii = Object.defineProperty, Zt = Object.getOwnPropertySymbols, Ti = Object.prototype.hasOwnProperty, ji = Object.prototype.propertyIsEnumerable, es = (s, e, t) => e in s ? Ii(s, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : s[e] = t, U = (s, e) => {
+  for (var t in e || (e = {}))
+    Ti.call(e, t) && es(s, t, e[t]);
+  if (Zt)
+    for (var t of Zt(e))
+      ji.call(e, t) && es(s, t, e[t]);
+  return s;
+}, j = /* @__PURE__ */ ((s) => (s.Cookie = "cookie", s.Local = "local", s.Session = "session", s))(j || {}), wt = /* @__PURE__ */ ((s) => (s.Tenant = "tenant", s.Implementation = "implementation", s.Widget = "widget", s))(wt || {}), x = /* @__PURE__ */ ((s) => (s.Necessary = "necessary", s.Functional = "functional", s.Analytical = "analytical", s.Marketing = "marketing", s))(x || {});
+const Di = (s, e, t, n = {}) => ts(s, t).then((i) => (process.env.NODE_ENV !== "production" && i && E.warn(
+  `createStorageWriter: Attempted to create storage writer using unallowed category.
+                    Key: ${e}
+                    Category: ${JSON.stringify(t)}
+                    Options: ${JSON.stringify(n)}`
+), (r) => (Pt(s), ts(s, t).then((o) => {
+  if (o) {
+    process.env.NODE_ENV !== "production" && E.warn(
+      `storageWriter: Attempted to write to storage using unallowed category.
+                                Key: ${e}
+                                Category: ${JSON.stringify(t)}
+                                Value: ${JSON.stringify(r)}
+                                Options: ${JSON.stringify(n)}`
+    );
+    return;
+  }
+  const {
+    scope: a = wt.Widget,
+    medium: c = j.Session,
+    duration: l
+  } = n, h = zi();
+  return h[a][e] = Ns(r, t, l), c === j.Cookie ? Hi(s, h) : Fi(s, c, h);
+})))), Wi = (s, e, t = j.Session) => (Pt(s), typeof e == "undefined" ? (process.env.NODE_ENV !== "production" && E.warn("readStorage: Undefined key passed when reading storage. ", e, t), Promise.resolve(void 0)) : t === j.Cookie ? Ji(s).then((n) => rt(n, e)) : qi(s, t).then((n) => rt(n, e))), Y = (s) => !!Object.entries(s).filter(([e, t]) => typeof t != "undefined").length, Ue = (s) => Object.entries(s).filter(([e, t]) => typeof t != "undefined").forEach(([e, { value: t }]) => {
+  typeof t == "undefined" && delete s[e];
+}), As = (s, e) => {
+  const t = {
+    tenant: U(U({}, s.tenant), e.tenant),
+    implementation: U(U({}, s.implementation), e.implementation),
+    widget: U(U({}, s.widget), e.widget)
+  };
+  return Ue(t.tenant), Ue(t.implementation), Ue(t.widget), t;
+}, Mi = (s) => Object.entries(s).reduce((e, t) => {
+  const [n, i] = t;
+  return Object.entries(i).forEach((r) => {
+    const [o, { expiration: a }] = r;
+    a && e.push(a);
+  }), e;
+}, []).slice().sort((e, t) => new Date(t).valueOf() - new Date(e).valueOf()).shift() || kt(), Te = (s) => {
+  const {
+    name: e,
+    implementation: { name: t, tenant: n }
+  } = s.get("$widget");
+  return [
+    `humany_${n}`,
+    `humany_${Qt(n + t)}`,
+    `humany_${Qt(n + t + e)}`
+  ];
+}, Ke = (s) => {
+  const e = new RegExp(`(?:^|;)\\s?${s}=(.*?)(?:;|$)`, "i"), t = document.cookie.match(e);
+  return t && t[1] && JSON.parse(t[1]) || void 0;
+}, Qe = (s, e, t) => {
+  const n = `${s}=${JSON.stringify(e).trim()}`, i = `expires=${new Date(t).toUTCString()}`, r = "path=/", o = "SameSite=None;Secure";
+  return document.cookie = `${n}; ${i}; ${r}; ${o}`;
+}, $t = (s) => {
+  const [e, t, n] = Te(s), i = Ke(e) || {}, r = Ke(t) || {}, o = Ke(n) || {};
+  return {
+    tenant: i,
+    implementation: r,
+    widget: o
+  };
+}, Ss = (s, e) => {
+  const t = $t(s), n = As(t, e), [i, r, o] = Te(s), { tenant: a, implementation: c, widget: l } = n, h = Mi(e), d = kt({ days: -1 });
+  Qe(i, a, Y(a) ? h : d), Qe(
+    r,
+    c,
+    Y(c) ? h : d
+  ), Qe(o, l, Y(l) ? h : d);
+}, $e = (s, e) => {
+  const [t, n, i] = Te(s), r = e.getItem(t) || "{}", o = e.getItem(n) || "{}", a = e.getItem(i) || "{}";
+  return {
+    tenant: JSON.parse(r),
+    implementation: JSON.parse(o),
+    widget: JSON.parse(a)
+  };
+}, it = (s, e, t) => {
+  const n = $e(s, e), i = As(n, t), [r, o, a] = Te(s), { tenant: c, implementation: l, widget: h } = i;
+  Y(c) ? e.setItem(r, JSON.stringify(c)) : e.removeItem(r), Y(l) ? e.setItem(o, JSON.stringify(l)) : e.removeItem(o), Y(h) ? e.setItem(a, JSON.stringify(h)) : e.removeItem(a);
+}, zi = () => ({ tenant: {}, implementation: {}, widget: {} }), Li = (s) => s ? !!s && /* @__PURE__ */ new Date() > new Date(s) : !1, rt = (s, e) => {
+  const t = s.widget[e] || s.implementation[e] || s.tenant[e];
+  return t == null ? void 0 : t.value;
+}, Ns = (s, e, t) => t ? {
+  value: s,
+  category: e,
+  expiration: typeof t == "object" ? kt(t) : t
+} : {
+  value: s,
+  category: e
+}, Ri = (s, e) => {
+  const t = ui(s);
+  return Object.entries(t).forEach(([n, i]) => {
+    Object.entries(i).forEach(([r, o]) => {
+      const { expiration: a, category: c } = o;
+      (Li(a) || Vi(e, c)) && (i[r] = Ns(void 0, c, a));
+    });
+  }), t;
+}, ts = (s, e) => Wi(s, "storagePolicy", j.Cookie).then(
+  (t = [x.Necessary]) => !!e && t.indexOf(e) === -1
+), Vi = (s = [x.Necessary], e) => !!e && s.indexOf(e) === -1, Pt = (s) => {
+  const e = $t(s), t = $e(s, window.localStorage), n = $e(s, sessionStorage), i = rt(e, "storagePolicy"), [r, o, a] = [
+    e,
+    t,
+    n
+  ].map((c) => Ri(c, i));
+  Ss(s, r), it(s, window.localStorage, o), it(s, window.sessionStorage, a);
+}, kt = (s = { days: 30 }) => {
+  const { days: e = 0, hours: t = 0, minutes: n = 0, seconds: i = 0 } = s, r = /* @__PURE__ */ new Date();
+  return r.setTime(r.getTime() + t * 60 * 60 * 1e3), r.setTime(r.getTime() + e * 24 * 60 * 60 * 1e3), r.setTime(r.getTime() + n * 60 * 1e3), r.setTime(r.getTime() + i * 1e3), r.toISOString();
+}, Ji = (s) => Ne(document)(() => $t(s)), Hi = (s, e) => Ne(document)(() => Ss(s, e)), qi = (s, e) => {
+  const t = e === j.Local ? window.localStorage : window.sessionStorage;
+  return Ne(t)(() => $e(s, t));
+}, Fi = (s, e, t) => {
+  const n = e === j.Local ? window.localStorage : window.sessionStorage;
+  return Ne(n)(() => it(s, n, t));
+}, Ye = (s, e, t, ...n) => {
+  const i = `[${s.get("$environment").name || "webprovisions"}] ${t}`;
+  switch (e) {
+    case "info":
+      console.info(i, ...n);
+      break;
+    case "warning":
+      console.warn(i, ...n);
+      break;
+    case "error":
+      console.error(i, ...n);
+      break;
+  }
+}, Bi = (s) => {
+  const e = s.container || s;
+  return {
+    info: (t, ...n) => Ye(e, "info", t, ...n),
+    warn: (t, ...n) => Ye(e, "warning", t, ...n),
+    error: (t, ...n) => Ye(e, "error", t, ...n)
+  };
+};
+var Pe = /* @__PURE__ */ ((s) => (s.Implementation = "implementation", s.Widget = "widget", s))(Pe || {}), F = /* @__PURE__ */ ((s) => (s.Pre = "pre", s.Post = "post", s))(F || {});
+const Ui = (s, e, t, n) => {
+  try {
+    const i = new e(t, n);
+    return {
+      name: s,
+      invoke: (r, o) => {
+        let a;
+        return i[r] && (a = i[r].call(i, o)), Promise.resolve(a);
+      },
+      getInstance: () => i
+    };
+  } catch (i) {
+    if (i.message && i.message.indexOf("is not a constructor") >= 0)
+      return {
+        name: s,
+        invoke: (r) => {
+          let o;
+          return r === "initialize" && (o = e(t, n)), Promise.resolve(o);
+        },
+        getInstance: () => e
+      };
+    throw i;
+  }
+};
+function ss(s, e) {
+  return typeof s == "undefined" ? e : s;
+}
+let Ki = class {
+  constructor(s = {}) {
+    this.part = s;
+  }
+  createCommand(s, e, t) {
+    let n;
+    typeof e == "function" ? n = {
+      scope: Pe.Widget,
+      stage: F.Post,
+      defaultArgs: void 0,
+      handlerResolver: e
+    } : n = {
+      scope: ss(e.scope, Pe.Widget),
+      stage: ss(e.stage, F.Post),
+      defaultArgs: e.defaultArgs,
+      handlerResolver: t
+    };
+    let i = this.part;
+    const r = s.split(".");
+    return r.forEach((o, a) => {
+      a === r.length - 1 ? i[o] || (i[o] = () => n) : i = this.part[o] = this.part[o] || {};
+    }), this;
+  }
+  get() {
+    return this.part;
+  }
+};
+const _s = (s) => {
+  const e = new Ki({});
+  return s(e), e.get();
+};
+_s((s) => {
+  s.createCommand(
+    "types.register",
+    { scope: Pe.Implementation, stage: F.Pre },
+    (e) => (t, n) => {
+      e.container.get("$types")[t] = n;
+    }
+  ).createCommand(
+    "type",
+    { stage: F.Pre },
+    (e) => (t) => {
+      e.container.register("$type", t);
+    }
+  ).createCommand(
+    "settings",
+    { stage: F.Pre, defaultArgs: [null] },
+    (e) => (t) => {
+      e.events.dispatch(
+        "settings:change",
+        t,
+        { bubbles: !0 }
+      ), e.container.register("$settings", t);
+    }
+  ).createCommand(
+    "plugin",
+    { stage: F.Pre },
+    (e) => (t, n, i) => {
+      const { container: r } = e;
+      let o = null, a = t, c = n;
+      typeof t == "string" && (o = t, a = n, c = i);
+      const l = (h) => {
+        const { transformPluginSettings: d } = e.container.get("$environmentOptions"), p = d ? d(
+          c || {},
+          o,
+          e.container,
+          a
+        ) : n;
+        try {
+          const u = Ui(
+            o,
+            a,
+            r,
+            p
+          );
+          r.get("$plugins").push(u), h && u.invoke("initialize", null);
+        } catch (u) {
+          Bi(e).warn("Error when initializing plugin", u);
+        }
+      };
+      e.container.get("$instance") ? l(!0) : e.events.subscribeOnce("widget:instance-created", () => l(!1));
+    }
+  ).createCommand(
+    "container.register",
+    (e) => (t, n) => {
+      e.container.register(t, n);
+    }
+  ).createCommand(
+    "container.registerAsync",
+    (e) => (t, n) => {
+      e.container.registerAsync(t, n);
+    }
+  ).createCommand(
+    "container.registerFactory",
+    (e) => (t, n) => {
+      e.container.registerFactory(t, n);
+    }
+  ).createCommand(
+    "container.touch",
+    (e) => (t, n) => {
+      e.container.touch(t, n);
+    }
+  ).createCommand(
+    "csp",
+    {},
+    (e) => (t) => {
+      e.container.register("csp", t);
+    }
+  );
+});
+_s((s) => {
+  s.createCommand("storage", (e) => (t = {}) => {
+    const { consent: n } = t;
+    if (typeof n != "undefined") {
+      if (typeof n != "number" && typeof n != "string" && !Array.isArray(n)) {
+        process.env.NODE_ENV !== "production" && E.warn(
+          `storagePolicyConfigurationApi: passed consent is not valid. Consent either has to be a number, a string, an array of strings or an array of numbers.
+                        Passed consent: ${JSON.stringify(n)}`
+        );
+        return;
+      }
+      if (Array.isArray(n) && !n.every(
+        (r) => typeof r == "number" || typeof r == "string"
+      )) {
+        process.env.NODE_ENV !== "production" && E.warn(
+          `storagePolicyConfigurationApi: passed consent is not valid. Consent either has to be a number, a string, an array of strings or an array of numbers.
+                        Passed consent: ${JSON.stringify(n)}`
+        );
+        return;
+      }
+      const i = [
+        x.Necessary,
+        x.Functional,
+        x.Analytical,
+        x.Marketing
+      ].filter((r, o, a) => typeof n == "number" ? n > o : typeof n == "string" ? a.indexOf(n) + 1 > o : Array.isArray(n) ? n.findIndex((c) => c === o + 1 || c === r) > -1 : !0);
+      return i.indexOf(x.Necessary) === -1 && (process.env.NODE_ENV !== "production" && E.warn(
+        `storagePolicyConfigurationApi: passed consent does not include category: '${x.Necessary}'. Consent has to atleast include the '${x.Necessary}' category.
+                        Passed consent: ${JSON.stringify(n)}`
+      ), i.unshift(x.Necessary)), Di(
+        e.container,
+        "storagePolicy",
+        x.Necessary,
+        {
+          medium: j.Cookie,
+          scope: wt.Tenant,
+          duration: { days: 365 }
+        }
+      ).then((r) => r(i)).then(() => {
+        Pt(e.container), e.events.dispatch("storage:policy-changed", i);
+      });
+    }
+  });
+});
+function Is(s) {
+  if (s.__esModule)
+    return s;
+  var e = s.default;
+  if (typeof e == "function") {
+    var t = function n() {
+      if (this instanceof n) {
+        var i = [null];
+        i.push.apply(i, arguments);
+        var r = Function.bind.apply(e, i);
+        return new r();
+      }
+      return e.apply(this, arguments);
+    };
+    t.prototype = e.prototype;
+  } else
+    t = {};
+  return Object.defineProperty(t, "__esModule", { value: !0 }), Object.keys(s).forEach(function(n) {
+    var i = Object.getOwnPropertyDescriptor(s, n);
+    Object.defineProperty(t, n, i.get ? i : {
+      enumerable: !0,
+      get: function() {
+        return s[n];
+      }
+    });
+  }), t;
+}
+var Ts = function() {
+};
+process.env.NODE_ENV !== "production" && (Ts = function(s, e, t) {
+  var n = arguments.length;
+  t = new Array(n > 2 ? n - 2 : 0);
+  for (var i = 2; i < n; i++)
+    t[i - 2] = arguments[i];
+  if (e === void 0)
+    throw new Error(
+      "`warning(condition, format, ...args)` requires a warning message argument"
+    );
+  if (e.length < 10 || /^[s\W]*$/.test(e))
+    throw new Error(
+      "The warning format should be able to uniquely identify this warning. Please, use a more descriptive format than: " + e
+    );
+  if (!s) {
+    var r = 0, o = "Warning: " + e.replace(/%s/g, function() {
+      return t[r++];
+    });
+    typeof console != "undefined" && console.error(o);
+    try {
+      throw new Error(o);
+    } catch (a) {
+    }
+  }
+});
+var Qi = Ts, Yi = Qi;
+Gi(Yi);
+function Gi(s) {
+  return s && s.__esModule ? s : { default: s };
+}
+function pe(s) {
+  return s.charAt(0) === "/";
+}
+function Ge(s, e) {
+  for (var t = e, n = t + 1, i = s.length; n < i; t += 1, n += 1)
+    s[t] = s[n];
+  s.pop();
+}
+function Xi(s) {
+  var e = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : "", t = s && s.split("/") || [], n = e && e.split("/") || [], i = s && pe(s), r = e && pe(e), o = i || r;
+  if (s && pe(s) ? n = t : t.length && (n.pop(), n = n.concat(t)), !n.length)
+    return "/";
+  var a = void 0;
+  if (n.length) {
+    var c = n[n.length - 1];
+    a = c === "." || c === ".." || c === "";
+  } else
+    a = !1;
+  for (var l = 0, h = n.length; h >= 0; h--) {
+    var d = n[h];
+    d === "." ? Ge(n, h) : d === ".." ? (Ge(n, h), l++) : l && (Ge(n, h), l--);
+  }
+  if (!o)
+    for (; l--; l)
+      n.unshift("..");
+  o && n[0] !== "" && (!n[0] || !pe(n[0])) && n.unshift("");
+  var p = n.join("/");
+  return a && p.substr(-1) !== "/" && (p += "/"), p;
+}
+const Zi = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  default: Xi
+}, Symbol.toStringTag, { value: "Module" })), er = /* @__PURE__ */ Is(Zi);
+var ns = typeof Symbol == "function" && typeof Symbol.iterator == "symbol" ? function(s) {
+  return typeof s;
+} : function(s) {
+  return s && typeof Symbol == "function" && s.constructor === Symbol && s !== Symbol.prototype ? "symbol" : typeof s;
+};
+function ge(s, e) {
+  if (s === e)
+    return !0;
+  if (s == null || e == null)
+    return !1;
+  if (Array.isArray(s))
+    return Array.isArray(e) && s.length === e.length && s.every(function(c, l) {
+      return ge(c, e[l]);
+    });
+  var t = typeof s == "undefined" ? "undefined" : ns(s), n = typeof e == "undefined" ? "undefined" : ns(e);
+  if (t !== n)
+    return !1;
+  if (t === "object") {
+    var i = s.valueOf(), r = e.valueOf();
+    if (i !== s || r !== e)
+      return ge(i, r);
+    var o = Object.keys(s), a = Object.keys(e);
+    return o.length !== a.length ? !1 : o.every(function(c) {
+      return ge(s[c], e[c]);
+    });
+  }
+  return !1;
+}
+const tr = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  default: ge
+}, Symbol.toStringTag, { value: "Module" })), sr = /* @__PURE__ */ Is(tr);
+var nr = er;
+js(nr);
+var ir = sr;
+js(ir);
+function js(s) {
+  return s && s.__esModule ? s : { default: s };
+}
+vt((s) => {
+  s.createCommand("routing", (e) => (t) => {
+    const n = {
+      mode: t.mode
+    };
+    t.basePath && (n.basePath = t.basePath), e.container.register("routingSettings", n);
+  });
+});
+const Xe = (s, e, t, ...n) => {
+  const i = `[${s.get("$environment").name || "webprovisions"}] ${t}`;
+  switch (e) {
+    case "info":
+      console.info(i, ...n);
+      break;
+    case "warning":
+      console.warn(i, ...n);
+      break;
+    case "error":
+      console.error(i, ...n);
+      break;
+  }
+}, rr = (s) => {
+  const e = s.container || s;
+  return {
+    info: (t, ...n) => Xe(e, "info", t, ...n),
+    warn: (t, ...n) => Xe(e, "warning", t, ...n),
+    error: (t, ...n) => Xe(e, "error", t, ...n)
+  };
+};
+var re = /* @__PURE__ */ ((s) => (s.Implementation = "implementation", s.Widget = "widget", s))(re || {}), R = /* @__PURE__ */ ((s) => (s.Pre = "pre", s.Post = "post", s))(R || {});
+const or = (s, e, t, n) => {
+  try {
+    const i = new e(t, n);
+    return {
+      name: s,
+      invoke: (r, o) => {
+        let a;
+        return i[r] && (a = i[r].call(i, o)), Promise.resolve(a);
+      },
+      getInstance: () => i
+    };
+  } catch (i) {
+    if (i.message && i.message.indexOf("is not a constructor") >= 0)
+      return {
+        name: s,
+        invoke: (r) => {
+          let o;
+          return r === "initialize" && (o = e(t, n)), Promise.resolve(o);
+        },
+        getInstance: () => e
+      };
+    throw i;
+  }
+};
+function is(s, e) {
+  return typeof s == "undefined" ? e : s;
+}
+class ar {
+  constructor(e = {}) {
+    this.part = e;
+  }
+  createCommand(e, t, n) {
+    let i;
+    typeof t == "function" ? i = {
+      scope: re.Widget,
+      stage: R.Post,
+      defaultArgs: void 0,
+      handlerResolver: t
+    } : i = {
+      scope: is(t.scope, re.Widget),
+      stage: is(t.stage, R.Post),
+      defaultArgs: t.defaultArgs,
+      handlerResolver: n
+    };
+    let r = this.part;
+    const o = e.split(".");
+    return o.forEach((a, c) => {
+      c === o.length - 1 ? r[a] || (r[a] = () => i) : r = this.part[a] = this.part[a] || {};
+    }), this;
+  }
+  get() {
+    return this.part;
+  }
+}
+const Ds = (s) => {
+  const e = new ar({});
+  return s(e), e.get();
+};
+Ds((s) => {
+  s.createCommand(
+    "types.register",
+    { scope: re.Implementation, stage: R.Pre },
+    (e) => (t, n) => {
+      e.container.get("$types")[t] = n;
+    }
+  ).createCommand(
+    "type",
+    { stage: R.Pre },
+    (e) => (t) => {
+      e.container.register("$type", t);
+    }
+  ).createCommand(
+    "settings",
+    { stage: R.Pre, defaultArgs: [null] },
+    (e) => (t) => {
+      e.events.dispatch(
+        "settings:change",
+        t,
+        { bubbles: !0 }
+      ), e.container.register("$settings", t);
+    }
+  ).createCommand(
+    "plugin",
+    { stage: R.Pre },
+    (e) => (t, n, i) => {
+      const { container: r } = e;
+      let o = null, a = t, c = n;
+      typeof t == "string" && (o = t, a = n, c = i);
+      const l = (h) => {
+        const { transformPluginSettings: d } = e.container.get("$environmentOptions"), p = d ? d(
+          c || {},
+          o,
+          e.container,
+          a
+        ) : n;
+        try {
+          const u = or(
+            o,
+            a,
+            r,
+            p
+          );
+          r.get("$plugins").push(u), h && u.invoke("initialize", null);
+        } catch (u) {
+          rr(e).warn("Error when initializing plugin", u);
+        }
+      };
+      e.container.get("$instance") ? l(!0) : e.events.subscribeOnce("widget:instance-created", () => l(!1));
+    }
+  ).createCommand(
+    "container.register",
+    (e) => (t, n) => {
+      e.container.register(t, n);
+    }
+  ).createCommand(
+    "container.registerAsync",
+    (e) => (t, n) => {
+      e.container.registerAsync(t, n);
+    }
+  ).createCommand(
+    "container.registerFactory",
+    (e) => (t, n) => {
+      e.container.registerFactory(t, n);
+    }
+  ).createCommand(
+    "container.touch",
+    (e) => (t, n) => {
+      e.container.touch(t, n);
+    }
+  ).createCommand(
+    "csp",
+    {},
+    (e) => (t) => {
+      e.container.register("csp", t);
+    }
+  );
+});
+Ds((s) => {
+  s.createCommand(
+    "ready",
+    { scope: re.Implementation, stage: R.Pre },
+    (e) => (t) => {
+      const { container: n } = e, i = n.owner;
+      n.get("bootstrapping").ready ? t(i) : i.events.subscribeOnce("bootstrap:ready", () => {
+        t(i);
+      });
+    }
+  );
+});
+const cr = (s, e, t, n, i) => s.getAsync("componentResolver").then((r) => (r.registerComponent(e, t), _i(s, e, n || (() => {
+}), e, i)));
+/**
+ * @license
+ * Copyright 2021 Google LLC
+ * SPDX-License-Identifier: BSD-3-Clause
+ */
+let hr = class extends Event {
+  constructor(s, e, t) {
+    super("context-request", { bubbles: !0, composed: !0 }), this.context = s, this.callback = e, this.subscribe = t != null && t;
+  }
+};
+/**
+ * @license
+ * Copyright 2021 Google LLC
+ * SPDX-License-Identifier: BSD-3-Clause
+ */
+/**
+ * @license
+ * Copyright 2021 Google LLC
+ * SPDX-License-Identifier: BSD-3-Clause
+ */
+class rs {
+  constructor(e, t, n, i) {
+    var r;
+    if (this.subscribe = !1, this.provided = !1, this.value = void 0, this.t = (o, a) => {
+      this.unsubscribe && (this.unsubscribe !== a && (this.provided = !1, this.unsubscribe()), this.subscribe || this.unsubscribe()), this.value = o, this.host.requestUpdate(), this.provided && !this.subscribe || (this.provided = !0, this.callback && this.callback(o, a)), this.unsubscribe = a;
+    }, this.host = e, t.context !== void 0) {
+      const o = t;
+      this.context = o.context, this.callback = o.callback, this.subscribe = (r = o.subscribe) !== null && r !== void 0 && r;
+    } else
+      this.context = t, this.callback = n, this.subscribe = i != null && i;
+    this.host.addController(this);
+  }
+  hostConnected() {
+    this.dispatchRequest();
+  }
+  hostDisconnected() {
+    this.unsubscribe && (this.unsubscribe(), this.unsubscribe = void 0);
+  }
+  dispatchRequest() {
+    this.host.dispatchEvent(new hr(this.context, this.t, this.subscribe));
+  }
+}
+const lr = "descriptor", dr = "container", Tr = "properties";
+class jr {
+  constructor(e) {
+    (this.host = e).addController(this), new rs(
+      e,
+      dr,
+      (t) => {
+        this._container = t, this.host.requestUpdate();
+      },
+      !0
+    ), new rs(
+      e,
+      lr,
+      (t) => {
+        this._descriptor = t, this.host.requestUpdate();
+      },
+      !0
+    );
+  }
+  hostConnected() {
+  }
+  hostDisconnected() {
+  }
+  dispatch(e, t) {
+    return ci(this, null, function* () {
+      if (!this._container || !this._descriptor)
+        return;
+      const n = yield Es.getInstance(
+        this._container
+      ), i = new Ie(n).withId(
+        this._descriptor.id
+      );
+      yield n.actions(
+        i,
+        this._descriptor.type || _e()
+      ).dispatch(e, t);
+    });
+  }
+}
+const ur = (s, e) => s.reduce((t, n, i) => {
+  var o, a;
+  const r = W(P({}, n), {
+    content: [W(P({}, n.content), { key: n.key })]
+  });
+  if (t.length > 0 && n.type !== ae.System) {
+    const c = t[t.length - 1];
+    if ((!e && e !== 0 || Math.abs(c.timestamp - n.timestamp) < e) && ((o = c.sender) == null ? void 0 : o.name) === ((a = n.sender) == null ? void 0 : a.name) && c.type === n.type)
+      return c.timestamp = n.timestamp, c.content.push(W(P({}, n.content), { key: n.key })), t;
+  }
+  return t.push(r), t;
+}, []), Dr = (s) => b(void 0, null, function* () {
+  const e = yield s.getAsync("router"), t = yield ft.getInstance(s);
+  return cr(
+    s,
+    "conversation",
+    import("./conversation-31b48ff2.js"),
+    (n) => b(void 0, null, function* () {
+      const { rehydrate: i = !1 } = n.properties(), o = e.getRouteData().params.id || n.node.name || "component", a = yield t.createController(o, { rehydrate: i }), c = t.registerController(
+        a,
+        n
+      ), l = 3 * 60 * 1e3, h = (u) => {
+        const { providers: g = [] } = u;
+        if (g) {
+          const y = Array.isArray(g) ? g : [g];
+          return a.setProviders(y), y;
+        }
+      };
+      h(
+        n.properties(h)
+      ), a.setComponentMountedState(!0);
+      const d = (u) => {
+        const { loading: g, typingActors: y, messages: O } = u;
+        n.writeProperties({
+          loading: g,
+          typingActors: y,
+          messages: ur(O, l)
+        });
+      };
+      d(a.getMessageStream()), c && (n.writeProperties({
+        conversationControllerId: a.id
+      }), n.actions.create("user-submit", (u, g) => {
+        if (g) {
+          const { preventDefault: y, validationPromise: O } = g;
+          if (y) {
+            O && O().then((D) => {
+              D && a.user.print(D);
+            });
+            return;
+          }
+        }
+        a.user.print(u.text);
+      }), n.actions.create("user-typing", (u, g) => {
+      }), n.actions.create("form", (u, g) => {
+      }), n.actions.create("action", (u, g) => {
+      }), n.actions.create("overlay-mounted", (u, g) => {
+      }), n.actions.create("show-overlay", (u, g) => {
+        n.writeProperties({
+          overlay: { conversation: !1, secondary: !1 }
+        });
+      }), n.actions.create("hide-overlay", (u, g) => {
+        n.writeProperties({
+          overlay: null
+        });
+      }), n.actions.create(
+        "show-overlay-conversation",
+        (u, g) => {
+          n.writeProperties({
+            overlay: { conversation: !0, secondary: !1 }
+          });
+        }
+      ), n.actions.create(
+        "hide-overlay-conversation",
+        (u, g) => {
+          n.writeProperties({
+            overlay: { conversation: !1, secondary: !1 }
+          });
+        }
+      ));
+      const p = a.events.subscribe(
+        "conversation:updated",
+        (u, g) => {
+          d(g);
+        }
+      );
+      return () => {
+        a.setComponentMountedState(!1), p(), a.active || d({ messages: [], typingActors: [], loading: !1 });
+      };
+    })
+  );
+});
+var pr = /* @__PURE__ */ ((s) => (s.LinkList = "link-list", s.Separator = "separator", s.ButtonList = "button-list", s.ItemList = "item-list", s.Text = "text", s.HTML = "html", s.VideoRequest = "video-request", s))(pr || {});
+const Wr = (s, e, t) => b(void 0, null, function* () {
+  yield t;
+});
+export {
+  ae as C,
+  Tr as V,
+  jr as W,
+  ft as a,
+  be as b,
+  Dr as c,
+  ii as d,
+  ni as e,
+  pr as f,
+  Wr as r,
+  dr as y
+};
+//# sourceMappingURL=index-d8edc7b3.js.map