@telia-ace/knowledge-data-client-flamingo 1.0.23 → 1.0.42

package/index.mjs

@@ -0,0 +1,1743 @@
+const K = (n, e, t, ...i) => {
+  const s = `[${n.get("$environment").name || "webprovisions"}] ${t}`;
+  switch (e) {
+    case "info":
+      console.info(s, ...i);
+      break;
+    case "warning":
+      console.warn(s, ...i);
+      break;
+    case "error":
+      console.error(s, ...i);
+      break;
+  }
+}, De = (n) => {
+  const e = n.container || n;
+  return {
+    info: (t, ...i) => K(e, "info", t, ...i),
+    warn: (t, ...i) => K(e, "warning", t, ...i),
+    error: (t, ...i) => K(e, "error", t, ...i)
+  };
+};
+var D = /* @__PURE__ */ ((n) => (n.Implementation = "implementation", n.Widget = "widget", n))(D || {}), x = /* @__PURE__ */ ((n) => (n.Pre = "pre", n.Post = "post", n))(x || {});
+const Ge = (n, e, t, i) => {
+  try {
+    const s = new e(t, i);
+    return {
+      name: n,
+      invoke: (r, a) => {
+        let o;
+        return s[r] && (o = s[r].call(s, a)), Promise.resolve(o);
+      },
+      getInstance: () => s
+    };
+  } catch (s) {
+    if (s.message && s.message.indexOf("is not a constructor") >= 0)
+      return {
+        name: n,
+        invoke: (r) => {
+          let a;
+          return r === "initialize" && (a = e(t, i)), Promise.resolve(a);
+        },
+        getInstance: () => e
+      };
+    throw s;
+  }
+};
+function de(n, e) {
+  return typeof n > "u" ? e : n;
+}
+let Te = class {
+  constructor(e = {}) {
+    this.part = e;
+  }
+  createCommand(e, t, i) {
+    let s;
+    typeof t == "function" ? s = {
+      scope: D.Widget,
+      stage: x.Post,
+      defaultArgs: void 0,
+      handlerResolver: t
+    } : s = {
+      scope: de(t.scope, D.Widget),
+      stage: de(t.stage, x.Post),
+      defaultArgs: t.defaultArgs,
+      handlerResolver: i
+    };
+    let r = this.part;
+    const a = e.split(".");
+    return a.forEach((o, c) => {
+      c === a.length - 1 ? r[o] || (r[o] = () => s) : r = this.part[o] = this.part[o] || {};
+    }), this;
+  }
+  get() {
+    return this.part;
+  }
+};
+const Ae = (n) => {
+  const e = new Te({});
+  return n(e), e.get();
+};
+Ae((n) => {
+  n.createCommand(
+    "types.register",
+    { scope: D.Implementation, stage: x.Pre },
+    (e) => (t, i) => {
+      e.container.get("$types")[t] = i;
+    }
+  ).createCommand(
+    "type",
+    { stage: x.Pre },
+    (e) => (t) => {
+      e.container.register("$type", t);
+    }
+  ).createCommand(
+    "settings",
+    { stage: x.Pre, defaultArgs: [null] },
+    (e) => (t) => {
+      e.events.dispatch(
+        "settings:change",
+        t,
+        { bubbles: !0 }
+      ), e.container.register("$settings", t);
+    }
+  ).createCommand(
+    "plugin",
+    { stage: x.Pre },
+    (e) => (t, i, s) => {
+      const { container: r } = e;
+      let a = null, o = t, c = i;
+      typeof t == "string" && (a = t, o = i, c = s);
+      const h = (d) => {
+        const { transformPluginSettings: g } = e.container.get("$environmentOptions"), u = g ? g(
+          c || {},
+          a,
+          e.container,
+          o
+        ) : i;
+        try {
+          const p = Ge(
+            a,
+            o,
+            r,
+            u
+          );
+          r.get("$plugins").push(p), d && p.invoke("initialize", null);
+        } catch (p) {
+          De(e).warn("Error when initializing plugin", p);
+        }
+      };
+      e.container.get("$instance") ? h(!0) : e.events.subscribeOnce("widget:instance-created", () => h(!1));
+    }
+  ).createCommand(
+    "container.register",
+    (e) => (t, i) => {
+      e.container.register(t, i);
+    }
+  ).createCommand(
+    "container.registerAsync",
+    (e) => (t, i) => {
+      e.container.registerAsync(t, i);
+    }
+  ).createCommand(
+    "container.registerFactory",
+    (e) => (t, i) => {
+      e.container.registerFactory(t, i);
+    }
+  ).createCommand(
+    "container.touch",
+    (e) => (t, i) => {
+      e.container.touch(t, i);
+    }
+  ).createCommand(
+    "csp",
+    {},
+    (e) => (t) => {
+      e.container.register("csp", t);
+    }
+  );
+});
+const ze = Ae((n) => {
+  n.createCommand(
+    "ready",
+    { scope: D.Implementation, stage: x.Pre },
+    (e) => (t) => {
+      const { container: i } = e, s = i.owner;
+      i.get("bootstrapping").ready ? t(s) : s.events.subscribeOnce("bootstrap:ready", () => {
+        t(s);
+      });
+    }
+  );
+}), Z = /* @__PURE__ */ new WeakMap();
+function R() {
+  return (n) => (Z.has(n) || Z.set(n, {}), Z.get(n));
+}
+const J = (n, e, t, ...i) => {
+  const s = `[${n.get("$environment").name || "webprovisions"}] ${t}`;
+  switch (e) {
+    case "info":
+      console.info(s, ...i);
+      break;
+    case "warning":
+      console.warn(s, ...i);
+      break;
+    case "error":
+      console.error(s, ...i);
+      break;
+  }
+}, v = (n) => {
+  const e = n.container || n;
+  return {
+    info: (t, ...i) => J(e, "info", t, ...i),
+    warn: (t, ...i) => J(e, "warning", t, ...i),
+    error: (t, ...i) => J(e, "error", t, ...i)
+  };
+}, m = R(), se = (() => {
+  let n = 0;
+  return () => ++n;
+})(), re = (n, e, t) => {
+  const i = m(n).touchQueue.get(e);
+  i && i.forEach((s) => {
+    s(t, n);
+  });
+};
+class Ue {
+  constructor(e, t, i, s) {
+    this.key = e, this.factory = t, this.parent = i, this.container = s, this.id = se(), 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, re(this.container, this.key, t), t));
+    }
+    return this.value;
+  }
+}
+class Be {
+  constructor(e, t, i, s) {
+    this.key = e, this.value = t, this.parent = i, this.container = s, this.id = se(), this.async = !1, this.resolved = !1, this.constructed = !0, this.resolve = () => (this.resolved = !0, re(this.container, this.key, this.value), this.value);
+  }
+}
+class Fe {
+  constructor(e, t, i, s) {
+    this.key = e, this.value = t, this.parent = i, this.container = s, this.id = se(), 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 re(this.container, this.key, this.value), r;
+    };
+  }
+}
+class oe {
+  /**
+   * 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, i) {
+    this.owner = e, this.name = t, this.parent = i, m(this).resolvers = /* @__PURE__ */ new Map(), m(this).touchQueue = /* @__PURE__ */ new Map(), m(this).children = [];
+  }
+  /**
+   * Deletes an existing resolver by its unique id.
+   * @param id Resolver id.
+   */
+  delete(e) {
+    const t = m(this).resolvers, i = Array.from(t.values()).find((s) => s.id === e);
+    return i ? (m(this).touchQueue.delete(i.key), Promise.resolve(t.delete(i.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 = m(this).resolvers, t = Array.from(e.values());
+    return Promise.all(t.map((i) => {
+      if (i.constructed)
+        return Promise.resolve(i.resolve()).then((s) => {
+          if (s !== null && typeof s == "object" && typeof s.dispose == "function")
+            return s.dispose.call(s, this, i);
+        });
+    })).then(() => {
+      t.forEach((i) => this.delete(i.id)), m(this).children.forEach((i) => i.clear());
+    });
+  }
+  /**
+   * Detaches this `Container` instance from its parent, allowing it to be garbage-collected.
+   */
+  detach() {
+    if (this.parent) {
+      const e = m(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 i = m(this).resolvers.get(e);
+    if (i && i.constructed)
+      Promise.resolve(i.resolve()).then((s) => {
+        t(s, this);
+      });
+    else {
+      const s = m(this).touchQueue;
+      let r = s.get(e);
+      r || (r = [], s.set(e, r)), r.push(t);
+    }
+    return this.parent && !i ? 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 i = m(this).resolvers.get(e);
+    i && !i.async && process.env.NODE_ENV !== "production" && v(this).warn(`Mismatching resolver type. You are registering an async resolver with a key ('${e}') previously used by a non-async resolver.`);
+    const s = new Ue(e, t, i, this);
+    return m(this).resolvers.set(e, s), s.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 i = m(this).resolvers.get(e);
+    i && i.async && process.env.NODE_ENV !== "production" && v(this).warn(`Mismatching resolver type. You are registering a non-async resolver with a key ('${e}') previously used by an async resolver.`);
+    const s = new Fe(e, t, i, this);
+    return m(this).resolvers.set(e, s), s.id;
+  }
+  /**
+   * Registers an synchronous resolver.
+   * @param key Key of the resolver.
+   * @param value Value.
+   */
+  register(e, t) {
+    const i = m(this).resolvers.get(e);
+    i && i.async && process.env.NODE_ENV !== "production" && v(this).warn(`Mismatching resolver type. You are registering a non-async resolver with a key ('${e}') previously used by an async resolver.`);
+    const s = new Be(e, t, i, this);
+    return m(this).resolvers.set(e, s), s.id;
+  }
+  /**
+   * Gets the value for a synchronous resolver.
+   * @param key Key of resolver to get.
+   */
+  get(e) {
+    const t = m(this).resolvers.get(e);
+    if (t)
+      return t.async && process.env.NODE_ENV !== "production" && v(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 = m(this).resolvers.get(e);
+    if (t) {
+      if (!t.async)
+        throw process.env.NODE_ENV !== "production" && v(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((i) => t[i] = this.get(i)), t;
+  }
+  getManyAsync(...e) {
+    const t = {};
+    return Promise.all(e.map((i) => this.getAsync(i).then((s) => t[i] = s))).then(() => t);
+  }
+  createChild(e, t) {
+    const i = new oe(e, t, this);
+    return m(this).children.push(i), i;
+  }
+}
+class ue {
+  /**
+   * 
+   * @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, i = !1, s = !1) {
+    this.type = e, this.target = t, this.cancelable = !!i, this.bubbles = !!s, this.defaultPrevented = !1;
+  }
+  /**
+   * Cancels the default behaviour (if the event is cancelable).
+   */
+  preventDefault() {
+    this.cancelable && (this.defaultPrevented = !0);
+  }
+}
+const $ = R(), ge = (n, e) => [].concat(
+  $(n).listenerLookup.get(e.toLowerCase()) || [],
+  $(n).listenerLookup.get("*") || []
+), pe = (n, e, t, i) => {
+  let s, r;
+  return e instanceof ue ? (s = e, r = e.type) : (s = new ue(e, n.target, !!t.cancelable, !!t.bubbles), r = e), { event: s, type: r, async: i };
+};
+let We = class Ne {
+  /**
+   * 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, $(this).listenerLookup = /* @__PURE__ */ new Map(), $(this).children = [];
+  }
+  /**
+   * Clears registered event listeners in this `EventManager` as well as in any children.
+   */
+  clear() {
+    $(this).listenerLookup.clear(), $(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 = $(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, i) {
+    const s = $(this).listenerLookup, r = e.toLowerCase();
+    return s.has(r) || s.set(r, []), s.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 i = this.subscribe(e, (s, r) => (i(), t(s, 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 i = $(this).listenerLookup.get(e.toLowerCase());
+    if (i) {
+      const s = i.indexOf(t);
+      s > -1 && i.splice(s, 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, i = {}) {
+    const { event: s, type: r } = pe(this, e, i, !0), a = ge(this, r);
+    let o = 0;
+    const c = a.length;
+    let h = Promise.resolve();
+    for (o = 0; o < c; o++)
+      ((d) => {
+        h = h.then((g) => g ? Promise.resolve(!0) : Promise.resolve(d(s, t)).then(() => s.defaultPrevented));
+      })(a[o]);
+    return h.then((d) => !d && s.bubbles && this.parent ? this.parent.dispatchAsync(s, t) : d);
+  }
+  /**
+   * 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, i = {}) {
+    const { event: s, type: r } = pe(this, e, i, !1), a = ge(this, r);
+    let o = 0;
+    const c = a.length;
+    let h = !1;
+    for (o = 0; o < c; o++)
+      if (a[o](s, t), s.defaultPrevented) {
+        h = !0;
+        break;
+      }
+    return !h && s.bubbles && this.parent && (h = this.parent.dispatch(s, t)), h;
+  }
+  /**
+   * Creates a child instance to the current Event manager.
+   */
+  createChild(e) {
+    const t = new Ne(e, this);
+    return $(this).children.push(t), t;
+  }
+};
+const z = (n, e, t) => {
+  const i = n.get("$plugins").map((s) => {
+    try {
+      return s.invoke(e, t);
+    } catch (r) {
+      v(n).error("An error occured when invoking a plugin.", s, r);
+    }
+  });
+  return Promise.all(i);
+};
+let He = 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 && v(this).error("Unable to create widget. No type is specified.");
+      const i = e[t];
+      !i && v(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 i(this.container)
+        );
+      } catch (s) {
+        v(this).error("Unable to create widget type.", s);
+      }
+      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"), i = t.initialize || (() => {
+      });
+      return this.initialized = Promise.resolve(i.call(t, e)).then(() => z(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 || (() => z(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 z(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 z(this.container, "invoke", { command: e, args: t }).then(() => {
+      const i = this.container.get("$instance");
+      if (i[e])
+        return i[e].apply(i, t);
+      const s = i.invoke;
+      if (s)
+        return s.call(i, e, ...t);
+    });
+  }
+};
+const M = (n, e) => {
+  if (!e)
+    return !0;
+  if (typeof e == "string") {
+    const t = e.split(",");
+    for (let i = 0, s = t.length; i < s; i++) {
+      const r = t[i].trim();
+      if (r === n || r === "*")
+        return !0;
+    }
+  }
+  return e instanceof Array ? e.indexOf(n) > -1 : !1;
+}, Ve = (n, e) => {
+  if (typeof e == "function")
+    return e(n);
+  const t = typeof e == "string" ? Ke(e) : e;
+  return !(!M(n.implementation.tenant || "", t.tenant || "") || !M(n.implementation.name, t.implementation || "") || !M(n.name, t.widget || "") || !M(n.container.get("$type"), t.type || ""));
+}, Qe = (n, e) => {
+  if (typeof e == "function")
+    return e(n);
+  const t = typeof e == "string" ? Ze(e) : e;
+  return !(!M(n.tenant || "", t.tenant || "") || !M(n.name, t.implementation || ""));
+}, xe = (n) => (e) => Ve(e, n), Ye = (n) => (e) => Qe(e, n), E = (n) => n instanceof Array && n.length === 1 ? n[0] : n, Ke = (n) => {
+  const e = {}, t = n.split(":");
+  return t.length === 1 ? e.widget = E(t[0].split(",")) : t.length === 2 ? (e.implementation = E(t[0].split(",")), e.widget = E(t[1].split(","))) : (e.tenant = E(t[0].split(",")), e.implementation = E(t[1].split(",")), e.widget = E(t[2].split(","))), e;
+}, Ze = (n) => {
+  const e = {}, t = n.split(":");
+  return t.length === 1 ? e.implementation = E(t[0].split(",")) : (e.tenant = E(t[0].split(",")), e.implementation = E(t[1].split(","))), e;
+}, W = R(), me = (n, e, t) => n.filter((i) => i.stage === e && xe(i.selector)(t));
+function Je(n) {
+  const e = n.container.get("$environment");
+  let t = W(e).configurationCache;
+  t && (t = t.filter((i) => i[0] !== n), W(e).configurationCache = t);
+}
+var H = /* @__PURE__ */ ((n) => (n.Implementation = "implementation", n.Widget = "widget", n))(H || {}), A = /* @__PURE__ */ ((n) => (n.Pre = "pre", n.Post = "post", n))(A || {});
+const Oe = (n, e, t) => (Object.keys(e).forEach((i) => {
+  const s = e[i];
+  if (typeof s == "function") {
+    const r = s();
+    typeof r.defaultArgs < "u" && t(r, ...r.defaultArgs), n[i] = (...a) => {
+      const o = Object.assign(
+        {},
+        r,
+        { handlerResolver: r.handlerResolver.bind({}) }
+      );
+      return t(o, ...a), n;
+    };
+  } else
+    n[i] = Oe(
+      {},
+      s,
+      t
+    );
+}), n), Xe = (n, e) => {
+  switch (e) {
+    case "implementation":
+      return n.implementation;
+    case "widget":
+      return n;
+  }
+}, fe = (n, e, t, i) => (i.forEach((s) => {
+  Oe(
+    n,
+    s,
+    (r, ...a) => {
+      const o = {
+        selector: e,
+        stage: r.stage,
+        handler: (c) => {
+          const h = Xe(c, r.scope), d = { container: h.container, events: h.events }, g = r.handlerResolver, u = g(d);
+          let p = W(t.environment).configurationCache;
+          return p || (p = W(t.environment).configurationCache = []), p.find((b) => b.indexOf(h) > -1 && b.indexOf(g) > -1) ? Promise.resolve() : (p.push([h, g]), Promise.resolve(u(...a)));
+        }
+      };
+      t.instructions.push(o);
+    }
+  );
+}), n);
+function et(n, e) {
+  function t(i) {
+    return fe(
+      {},
+      i,
+      n,
+      e
+    );
+  }
+  return fe(
+    t,
+    "*",
+    n,
+    e
+  );
+}
+const tt = (n, e, t, i) => {
+  try {
+    const s = new e(t, i);
+    return {
+      name: n,
+      invoke: (r, a) => {
+        let o;
+        return s[r] && (o = s[r].call(s, a)), Promise.resolve(o);
+      },
+      getInstance: () => s
+    };
+  } catch (s) {
+    if (s.message && s.message.indexOf("is not a constructor") >= 0)
+      return {
+        name: n,
+        invoke: (r) => {
+          let a;
+          return r === "initialize" && (a = e(t, i)), Promise.resolve(a);
+        },
+        getInstance: () => e
+      };
+    throw s;
+  }
+};
+function ve(n, e) {
+  return typeof n > "u" ? e : n;
+}
+let nt = class {
+  constructor(e = {}) {
+    this.part = e;
+  }
+  createCommand(e, t, i) {
+    let s;
+    typeof t == "function" ? s = {
+      scope: H.Widget,
+      stage: A.Post,
+      defaultArgs: void 0,
+      handlerResolver: t
+    } : s = {
+      scope: ve(t.scope, H.Widget),
+      stage: ve(t.stage, A.Post),
+      defaultArgs: t.defaultArgs,
+      handlerResolver: i
+    };
+    let r = this.part;
+    const a = e.split(".");
+    return a.forEach((o, c) => {
+      c === a.length - 1 ? r[o] || (r[o] = () => s) : r = this.part[o] = this.part[o] || {};
+    }), this;
+  }
+  get() {
+    return this.part;
+  }
+};
+const Ie = (n) => {
+  const e = new nt({});
+  return n(e), e.get();
+}, it = Ie((n) => {
+  n.createCommand(
+    "types.register",
+    { scope: H.Implementation, stage: A.Pre },
+    (e) => (t, i) => {
+      e.container.get("$types")[t] = i;
+    }
+  ).createCommand(
+    "type",
+    { stage: A.Pre },
+    (e) => (t) => {
+      e.container.register("$type", t);
+    }
+  ).createCommand(
+    "settings",
+    { stage: A.Pre, defaultArgs: [null] },
+    (e) => (t) => {
+      e.events.dispatch(
+        "settings:change",
+        t,
+        { bubbles: !0 }
+      ), e.container.register("$settings", t);
+    }
+  ).createCommand(
+    "plugin",
+    { stage: A.Pre },
+    (e) => (t, i, s) => {
+      const { container: r } = e;
+      let a = null, o = t, c = i;
+      typeof t == "string" && (a = t, o = i, c = s);
+      const h = (d) => {
+        const { transformPluginSettings: g } = e.container.get("$environmentOptions"), u = g ? g(
+          c || {},
+          a,
+          e.container,
+          o
+        ) : i;
+        try {
+          const p = tt(
+            a,
+            o,
+            r,
+            u
+          );
+          r.get("$plugins").push(p), d && p.invoke("initialize", null);
+        } catch (p) {
+          v(e).warn("Error when initializing plugin", p);
+        }
+      };
+      e.container.get("$instance") ? h(!0) : e.events.subscribeOnce("widget:instance-created", () => h(!1));
+    }
+  ).createCommand(
+    "container.register",
+    (e) => (t, i) => {
+      e.container.register(t, i);
+    }
+  ).createCommand(
+    "container.registerAsync",
+    (e) => (t, i) => {
+      e.container.registerAsync(t, i);
+    }
+  ).createCommand(
+    "container.registerFactory",
+    (e) => (t, i) => {
+      e.container.registerFactory(t, i);
+    }
+  ).createCommand(
+    "container.touch",
+    (e) => (t, i) => {
+      e.container.touch(t, i);
+    }
+  ).createCommand(
+    "csp",
+    {},
+    (e) => (t) => {
+      e.container.register("csp", t);
+    }
+  );
+}), st = it;
+function rt(n, e, t = []) {
+  const i = [st].concat(t), s = et(
+    e,
+    i
+  );
+  n(s, e);
+}
+class ot {
+  constructor() {
+    this.tasks = [], this.current = Promise.resolve(), this.next = this.next.bind(this);
+  }
+  add(e, t, i, s) {
+    this.tasks.push({ task: e, resolve: t, reject: i, done: s }), 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((i) => {
+          e.done(), e.resolve(i);
+        })).catch((i) => (e.done(), e.reject(i), this.next()));
+      }
+      return Promise.resolve();
+    });
+  }
+}
+const U = /* @__PURE__ */ new WeakMap();
+function at(n) {
+  return U.has(n) || U.set(n, new ot()), (e) => new Promise((t, i) => {
+    const s = U.get(n);
+    s.add(e, t, i, () => {
+      s.tasks.length || U.delete(n);
+    });
+  });
+}
+const ye = (n) => typeof n < "u", S = (n, e) => {
+  n.events.dispatch("widget:state-change", { state: e }, { bubbles: !0 }), n.state = e, n.events.dispatch("widget:state-changed", {}, { bubbles: !0 });
+}, y = R(), ct = (n) => {
+  const { container: e, events: t } = n;
+  e.get("$controller") || (e.register("$controller", new He(e)), t.dispatch("widget:controller-created", {}, { bubbles: !0 }));
+};
+let ht = 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, i) {
+    this.state = "deactivated", this.name = e, this.implementation = t, this.container = t.container.createChild(this, e), this.events = t.events.createChild(this), y(this).subscriptions = [], i && t.configure((s) => {
+      const r = s(e);
+      ye(i.type) && r.type(i.type), ye(i.settings) && r.settings(i.settings), i.plugins && Object.keys(i.plugins).forEach((a) => {
+        var o;
+        const c = (o = i.plugins) == null ? void 0 : o[a];
+        r.plugin(a, 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 at(this)(() => {
+      y(this).deactivatedPromise = null;
+      const e = this.state === "deactivated";
+      e && (S(
+        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)), S(
+        this,
+        "loading"
+        /* Loading */
+      );
+      const t = this.implementation.instructions, i = me(t, A.Pre, this);
+      return Promise.all(i.map((s) => s.handler(this))).then(() => {
+        ct(this);
+        const s = me(t, A.Post, this);
+        return Promise.all(s.map((r) => r.handler(this))).then(() => {
+          e && this.container.get("$controller").initialize();
+        });
+      }).then(() => (S(
+        this,
+        "activated"
+        /* Activated */
+      ), this));
+    });
+  }
+  /**
+   * Activates the widget and makes it ready for receiving commands.
+   * @param data Activation data
+   */
+  activate(e) {
+    y(this).subscriptions.push(
+      this.implementation.events.subscribe("implementation:configured", () => {
+        [
+          "activated",
+          "activating",
+          "loading"
+          /* Loading */
+        ].indexOf(this.state) > -1 && this.load();
+      })
+    );
+    const t = y(this).activatedPromise;
+    return t ? (process.env.NODE_ENV !== "production" && v(this).warn(`Widget '${this.name}' has already been activated. The passed arguments for this activation will be discarded.`, e), t) : y(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 i = y(this).activatedPromise, s = (r, ...a) => i.then(this.load).then(() => this.container.get("$controller").invoke(r, ...a));
+    return i ? s(e, ...t) : (process.env.NODE_ENV !== "production" && v(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 a = this.events.subscribe("widget:state-changed", () => {
+        this.state === "activated" && (a(), r(s(e, ...t)));
+      });
+    }));
+  }
+  /**
+   * Deactivates the widget by clearing the `Container` and removing any event subscriptions in the
+   * `EventManager`.
+   */
+  deactivate() {
+    return y(this).deactivatedPromise || (this.state === "deactivated" ? Promise.resolve() : (S(
+      this,
+      "deactivating"
+      /* Deactivating */
+    ), y(this).deactivatedPromise = this.container.get("$controller").deactivate().then(() => (y(this).activatedPromise = null, y(this).subscriptions.forEach((t) => t()), y(this).subscriptions = [], this.container.clear().then(() => {
+      this.events.clear(), Je(this), S(
+        this,
+        "deactivated"
+        /* Deactivated */
+      );
+    })))));
+  }
+};
+const be = R();
+class lt {
+  /**
+   * 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, i = []) {
+    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", {}), be(this).configurationApiExtensions = i;
+  }
+  /**
+   * 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 rt(e, this, be(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 i = new ht(e, this, t);
+    return this.widgets.set(i.name, i), i;
+  }
+}
+function dt(n, e, t) {
+  const i = new lt(n, e, t);
+  return n.widgets && Object.keys(n.widgets).forEach((s) => {
+    var r;
+    const a = (r = n.widgets) == null ? void 0 : r[s];
+    i.createWidget(s, a);
+  }), i;
+}
+let we = class Me {
+  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 Me(
+      () => 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 ae = "#____version____#", X = R(), ut = (n) => n.tenant ? `${n.name}:${n.tenant}` : n.name, Re = class {
+  constructor(e, t = [], i = {}) {
+    this.widgets = new we(
+      () => {
+        let s = [];
+        return this.implementations.all().forEach((r) => {
+          s = s.concat(Array.from(r.widgets.values()));
+        }), s;
+      },
+      xe
+    ), this.implementations = new we([], Ye), this.name = e, this.container = new oe(this, e), this.events = new We(this), this.container.register("$version", ae), this.container.register("$environment", this), this.container.register("$environmentOptions", i), X(this).configurationApiExtensions = t;
+  }
+  /**
+   * Creates an implementation based on the provided configuration.
+   * @param config Implementation configuration.
+   */
+  createImplementation(e) {
+    const t = ut(e);
+    let i = this.implementations.find(t);
+    if (i)
+      return process.env.NODE_ENV !== "production" && v(i).warn(`Implementation "${t}" already exist on current environment.`), i;
+    const s = X(this).configurationApiExtensions;
+    return i = dt(
+      e,
+      this,
+      s
+    ), this.implementations = this.implementations.append([i]), this.events.dispatch("implementation:created", { implementation: i }), i;
+  }
+  /**
+   * Patches the Environment instance configuration.
+   * @param configuration Environment configuration.
+   */
+  patch(e = {}) {
+    const { name: t, configurationApiExtensions: i } = e;
+    typeof t < "u" && t !== null && (this.name = t), i && i.forEach(
+      (s) => {
+        X(this).configurationApiExtensions.push(s);
+      }
+    );
+  }
+  /**
+   * Creates a new Environment instance based on the provided configuration.
+   * @param configuration Environment configuration.
+   */
+  static create(e = {}) {
+    return new Re(
+      e.name || "",
+      e.configurationApiExtensions,
+      e.options
+    );
+  }
+};
+let _e = Re;
+_e.version = ae;
+const Q = (n, e, ...t) => typeof e == "string" ? n(`[humany] ${e}`, ...t) : n(e, ...t), L = class {
+  constructor() {
+    this.keys = [], this.log = (e, ...t) => this.lookup(e, () => L.log(...t)), this.warn = (e, ...t) => this.lookup(e, () => L.warn(...t)), this.error = (e, ...t) => this.lookup(e, () => L.error(...t)), this.info = (e, ...t) => this.lookup(e, () => L.info(...t));
+  }
+  lookup(e, t) {
+    this.keys.indexOf(e) === -1 && (this.keys.push(e), t());
+  }
+};
+let G = L;
+G.log = (...n) => Q(console.log, ...n);
+G.warn = (...n) => Q(console.warn, ...n);
+G.error = (...n) => Q(console.error, ...n);
+G.info = (...n) => Q(console.info, ...n);
+const Se = (n) => {
+  let e = {}, t, i;
+  if (typeof n != "object" || n === null)
+    return n;
+  e = Array.isArray(n) ? [] : {};
+  for (i in n)
+    t = n[i], e[i] = typeof t == "object" && t !== null ? Se(t) : t;
+  return e;
+}, gt = Se;
+class pt {
+  constructor(e, t) {
+    this.lockWarningTime = e, this.lockErrorTime = t, this.tasks = [], this.current = Promise.resolve(), this.next = this.next.bind(this);
+  }
+  add(e, t, i, s) {
+    this.tasks.push({ task: e, resolve: t, reject: i, done: s }), this.next();
+  }
+  next() {
+    this.current = this.current.then(() => {
+      const e = this.tasks.shift();
+      if (e) {
+        let t;
+        const i = setTimeout(() => {
+          process.env.NODE_ENV !== "production" && G.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), s = Promise.resolve(e.task()).then((r) => (clearTimeout(i), clearTimeout(t), r));
+        return Promise.resolve(s).then(this.next).then(
+          () => s.then((r) => {
+            e.done(), e.resolve(r);
+          })
+        ).catch((r) => (e.done(), e.reject(r), this.next()));
+      }
+      return Promise.resolve();
+    });
+  }
+}
+const B = /* @__PURE__ */ new WeakMap();
+function mt(n, e = 5e3, t = 1e3) {
+  return B.has(n) || B.set(n, new pt(e, t)), (i) => new Promise((s, r) => {
+    const a = B.get(n);
+    a.add(i, s, r, () => {
+      a.tasks.length || B.delete(n);
+    });
+  });
+}
+const ft = (n = {}) => (Object.keys(n).forEach((e) => {
+  (n[e] === null || typeof n[e] > "u") && delete n[e];
+}), n), vt = ft, F = (n, e) => {
+  let t = !0;
+  return Object.keys(n).length !== Object.keys(e).length || Object.keys(n).some((i) => !Object.keys(e).some((s) => i === s)) ? !1 : (Object.keys(n).forEach((i) => {
+    if (t) {
+      const s = typeof n[i] > "u" ? "" : n[i], r = typeof e[i] > "u" ? "" : e[i];
+      t = s.toString() === r.toString();
+    }
+  }), t);
+};
+var yt = Object.defineProperty, ke = Object.getOwnPropertySymbols, bt = Object.prototype.hasOwnProperty, wt = Object.prototype.propertyIsEnumerable, Ce = (n, e, t) => e in n ? yt(n, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : n[e] = t, $e = (n, e) => {
+  for (var t in e || (e = {}))
+    bt.call(e, t) && Ce(n, t, e[t]);
+  if (ke)
+    for (var t of ke(e))
+      wt.call(e, t) && Ce(n, t, e[t]);
+  return n;
+};
+Ie((n) => {
+  n.createCommand("components", (e) => (t) => {
+    e.events.subscribeOnce("components:platform-created", (i, { platform: s }) => {
+      t.handlers && t.handlers.forEach(([r, a]) => {
+        s.addComponentHandler(r, a);
+      });
+    });
+  });
+});
+const kt = "#____version____#", Le = class extends _e {
+  constructor(n, e = []) {
+    super(n, e, {
+      transformPluginSettings: (t, i, s) => {
+        const r = s.get("$settings"), a = r.plugins && i ? r.plugins[i] || {} : {};
+        return $e($e({}, a), t);
+      }
+    });
+  }
+  createImplementation(n) {
+    const e = super.createImplementation(n);
+    return e.bindings = n.bindings, e;
+  }
+  /**
+   * 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(n, e, t) {
+    this.widgets.query(n).forEach((i) => i.invoke("navigate", { route: e, params: t }));
+  }
+  /**
+   * Creates a runtime based on provided configuration.
+   * @param configuration Runtime configuration.
+   */
+  static create(n = {}) {
+    const e = [ze].concat(
+      n.configurationApiExtensions || []
+    );
+    return new Le("humany", e);
+  }
+  /**
+   * 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(n, e = {}) {
+    if (this.isRuntime(n))
+      return n.patch(e), n;
+    const t = [], i = n && n._c;
+    i && i.forEach((r) => t.push(r));
+    const s = this.create(e);
+    return s.container.register("$runtimecfg", t), s;
+  }
+  /**
+   * Determines whether the specified object is a valid widget runtime.
+   * @param obj Object to compare.
+   */
+  static isRuntime(n) {
+    return !!(n && typeof n == "object" && n.container && typeof n.container.get == "function" && n.container.get("$environment") === n && n.container.owner === n);
+  }
+};
+let Ct = Le;
+Ct.version = `${kt} (${ae})`;
+var V = /* @__PURE__ */ ((n) => (n.open = "open", n.closed = "closed", n.hidden = "hidden", n))(V || {});
+const Pe = (n) => import("./index-5c9c2abf.mjs").then(
+  ({ ServiceClient: e, ServiceProxy: t }) => n.get("settings").then((i) => {
+    const { name: s, events: r } = n.get("$widget"), {
+      data: { projection: a = "", site: o = "current", forceHttps: c = !1 }
+    } = i, h = new t(a, {
+      credentials: "same-origin"
+    }), d = new e(
+      h,
+      {
+        funnel: s.replace("_contact-method", "").replace("_contact", ""),
+        site: $t(o, c)
+      },
+      null,
+      n
+    );
+    return r.subscribe("widget:settings-updated", (g, { data: u }) => {
+      u && u.projection !== a && d.proxy.setBaseUrl(u.projection);
+    }), d;
+  })
+), $t = (n, e) => () => {
+  const t = (s) => {
+    const r = document.createElement("a");
+    return r.href = s, r;
+  };
+  let i = window.location;
+  return n === "referrer" && document.referrer && (i = t(document.referrer)), [
+    e ? "https:" : "",
+    "//",
+    i.host,
+    i.pathname
+  ].join("");
+}, O = (n) => {
+  if (n) {
+    const { Type: e, Content: t } = n;
+    if (e && t)
+      return { type: e, content: t };
+  }
+}, ie = (n) => n.map((e) => {
+  const t = {
+    id: e.Id.toString(),
+    title: e.Name,
+    symbol: O(e.DefaultIcon),
+    activeSymbol: e.ActiveIcon && O(e.ActiveIcon),
+    description: e.Description || e.Attributes && e.Attributes.description || "",
+    matches: e.GuidesCount
+  };
+  return e.Children && e.Children.length && (t.items = ie(e.Children)), t;
+}), P = (n, e) => n.filter(({ Type: t }) => t === e).map(({ Id: t, Title: i, Body: s }) => ({
+  id: t.toString(),
+  title: i,
+  body: s
+})), ee = (n) => n.map(({ Id: e, Title: t, DefaultIcon: i, ListNotices: s, Notices: r }) => ({
+  id: e.toString(),
+  title: t,
+  symbol: O(i),
+  defaultHeaderOptions: {
+    visible: !!s.length
+  },
+  notifications: (s || []).concat(r || []).map(({ Id: a, Title: o, Body: c, Type: h, Modified: d }) => ({
+    id: a.toString(),
+    title: o,
+    body: c,
+    modified: d,
+    expandable: h === "listNotice"
+  }))
+})), te = ({
+  Id: n,
+  Title: e,
+  DefaultIcon: t,
+  Exits: [i],
+  ExitType: s,
+  ConfirmationText: r,
+  Description: a
+}, o) => {
+  const { Adapter: c } = i || { Adapter: {} }, { ClientName: h = "", Settings: d = {}, CustomClientName: g = "" } = c, u = {
+    id: n.toString(),
+    title: e,
+    description: a,
+    symbol: O(t),
+    clientName: h === "custom.adapter" ? g : h,
+    expanded: !0,
+    inline: !0,
+    body: {}
+  };
+  if (h.indexOf("phone") > -1 || h.indexOf("freetext") > -1) {
+    const { displayTextBeforeClick: p, textBeforeClick: b } = d;
+    p === "true" && (u.expanded = !1, u.title = b), h.indexOf("phone.text") > -1 ? u.body.phoneNumber = d.phoneNumber : u.body.freetext = d.freetext;
+  }
+  return (h.indexOf("chat.popup") > -1 || h.indexOf("link") > -1 || h === "custom.adapter" && s === "custom") && (u.body = d, u.body.confirmationFallback = r), h.indexOf("ace") > -1 && (u.body = d), u;
+}, j = (n = []) => n.map(
+  ({ Id: e, Title: t, TotalMatches: i, Symbol: s, DefaultIcon: r, ActiveIcon: a }) => ({
+    id: e.toString(),
+    title: t,
+    matches: i,
+    symbol: O(r || s),
+    defaultIcon: O(r),
+    activeIcon: O(a)
+  })
+), ne = (n) => n.map(({ Id: e, Title: t, Tags: i, FirstPublishedDate: s, Modified: r }) => ({
+  id: e.toString(),
+  title: t,
+  tags: j(i),
+  published: s,
+  modified: r
+})), Pt = (n, e) => {
+  switch (n) {
+    case C.MatchByCategory:
+    case C.Match: {
+      const t = {
+        guides: [],
+        matches: 0,
+        topNotifications: [],
+        middleNotifications: [],
+        bottomNotifications: [],
+        notificationLists: [],
+        tags: [],
+        byCategory: []
+      }, {
+        Matches: i,
+        TotalMatches: s,
+        Notices: r,
+        NoticeLists: a,
+        Tags: o,
+        ByCategory: c
+      } = e;
+      return t.guides = ne(i), t.matches = s, t.byCategory = (c || []).map(
+        ({ Id: h, Matches: d, TotalMatches: g }) => ({
+          id: h,
+          guides: ne(d),
+          matches: g
+        })
+      ), t.tags = j(o), t.notificationLists = ee(a || []), t.topNotifications = P(r || [], "noticeRowTop"), t.middleNotifications = P(r || [], "noticeRowMiddle"), t.bottomNotifications = P(r || [], "footerNotice"), t;
+    }
+    case C.Categories: {
+      const { Children: t, GuidesCountTotal: i } = e;
+      return {
+        categories: ie(t || []),
+        matches: i
+      };
+    }
+    case C.Guide: {
+      const {
+        Id: t,
+        Title: i,
+        Body: s,
+        Related: r,
+        Options: a,
+        ConnectionId: o,
+        ContactMethods: c,
+        EnableFeedback: h,
+        HandoverExists: d,
+        FirstPublishedDate: g,
+        Modified: u,
+        ModifiedByDisplayName: p,
+        FirstPublishedByDisplayName: b,
+        Categories: w,
+        Tags: l,
+        SeoMetaDescription: f,
+        SeoAllowIndex: Y,
+        Perspectives: _,
+        PerspectiveKey: ce,
+        Translations: he
+      } = e, je = ce || Object.values(_).find(
+        (N) => N === o
+      ) || _.Default || null, le = {
+        guide: {
+          id: t.toString(),
+          title: i,
+          body: s,
+          modified: u,
+          published: g,
+          modifiedBy: p,
+          publishedBy: b,
+          connection: o,
+          categories: w,
+          hasHandover: d,
+          allowFeedback: h,
+          seoMetaDescription: f,
+          seoAllowIndex: Y,
+          perspectives: _,
+          perspective: je,
+          translations: Object.keys(he || {}).reduce((N, T) => (N[T] = he[T].toString(), N), {})
+        },
+        related: ne(r || []),
+        dialog: [],
+        contactMethods: (c || []).map(
+          (N) => te(N)
+        ),
+        tags: j(l)
+      };
+      return (a || []).forEach(
+        ({ CanAccess: N, Description: T, ConnectionId: qe, Properties: k }) => {
+          if (!N)
+            return;
+          const I = {
+            id: t.toString(),
+            title: T,
+            connection: qe,
+            connectionKey: k.ConnectionKey,
+            type: "default",
+            parent: {
+              id: t.toString(),
+              title: i,
+              tags: j(l)
+            }
+          };
+          if (k.Type === "Guide" || k.Type === "Link")
+            switch (k.Id && (I.id = k.Id.toString()), k.Uri && (I.href = k.Uri), k.Target && (I.target = k.Target), k.Type) {
+              case "Guide":
+                I.type = "guide";
+                break;
+              case "Link":
+                I.type = "link";
+                break;
+            }
+          le.dialog.push(I);
+        }
+      ), le;
+    }
+    case C.Contacts: {
+      const {
+        Children: t,
+        Matches: i,
+        Notices: s,
+        NoticeLists: r
+      } = e;
+      return {
+        contactMethods: (i || []).map(
+          (o) => te(o)
+        ),
+        categories: ie(t || []),
+        topNotifications: P(s || [], "noticeRowTop"),
+        middleNotifications: P(s || [], "noticeRowMiddle"),
+        bottomNotifications: P(s || [], "footerNotice"),
+        notificationLists: ee(r || [])
+      };
+    }
+    case C.ContactMethod: {
+      const { ContactMethod: t } = e;
+      return te(t || {});
+    }
+    case C.Tags:
+    case C.TagsOnGuides:
+      return j(e || []);
+    case C.Notifications: {
+      const { Notices: t, NoticeLists: i } = e;
+      return {
+        topNotifications: P(t || [], "noticeRowTop"),
+        middleNotifications: P(t || [], "noticeRowMiddle"),
+        bottomNotifications: P(t || [], "footerNotice"),
+        notificationLists: ee(i || [])
+      };
+    }
+    default:
+      return {};
+  }
+};
+var Et = /* @__PURE__ */ ((n) => (n.Guide = "guide", n.Guides = "guides", n.GuidesByCategory = "guides-by-category", n.RowNotifications = "row-notices", n.NotificationLists = "notification-lists", n.GuideCategories = "guide-categories", n.ContactMethodCategories = "contact-method-categories", n.ContactMethod = "contact-method", n.ContactMethods = "contact-methods", n.Tags = "tags", n.TagsOnGuides = "tagsonguides", n))(Et || {}), C = /* @__PURE__ */ ((n) => (n.Match = "match", n.Categories = "categories", n.Guide = "guide", n.Contacts = "contacts", n.ContactMethod = "contact-method", n.MatchByCategory = "match-by-category", n.Tags = "tags", n.TagsOnGuides = "tagsonguides", n.Notifications = "notifications", n))(C || {}), At = /* @__PURE__ */ ((n) => (n.Positive = "Positive", n.Negative = "Negative", n))(At || {}), Nt = /* @__PURE__ */ ((n) => (n.POPULARITY_DESCENDING = "popularity-descending", n.ALPHABETIC_ASCENDING = "alphabetic-ascending", n.ALPHABETIC_DESCENDING = "alphabetic-descending", n.MODIFIED_ASCENDING = "modified-ascending", n.MODIFIED_DESCENDING = "modified-descending", n.PUBLISHED_ASCENDING = "published-ascending", n.PUBLISHED_DESCENDING = "published-descending", n))(Nt || {});
+const Ee = (n) => {
+  switch (n) {
+    case "guides":
+      return "match";
+    case "guides-by-category":
+      return "match-by-category";
+    case "guide":
+      return "guide";
+    case "guide-categories":
+      return "categories";
+    case "contact-method-categories":
+    case "contact-methods":
+      return "contacts";
+    case "contact-method":
+      return "contact-method";
+    case "tags":
+      return "tags";
+    case "tagsonguides":
+      return "tagsonguides";
+    case "notification-lists":
+    case "row-notices":
+      return "notifications";
+    default:
+      throw "error";
+  }
+}, xt = async (n) => {
+  const { invoke: e } = n.get("$widget");
+  return await e("renderState") === V.hidden;
+};
+class q {
+  constructor(e, t) {
+    this.container = e, this.matchingClient = t, this.queries = /* @__PURE__ */ new Map(), this.getUnresolvedQueries = () => {
+      let i = 0;
+      return this.queries.forEach((s, r) => {
+        s.some((o) => !o.resolved) && (i = 1);
+      }), i;
+    }, this.events = e.get("$widget").events, this.events.subscribe(
+      "widget:settings-updated",
+      () => this.queries = /* @__PURE__ */ new Map()
+    ), this.events.subscribe(
+      "widget:render-state-changed",
+      (i, { next: s, previous: r }) => {
+        r === V.hidden && s === V.open && this.fetchAllUnresolvedQueries();
+      }
+    );
+  }
+  static getInstance(e, t = "dataClient") {
+    return mt(this)(() => e.getAsync(t).then(async (i) => {
+      let s = await e.getAsync("matchingClient");
+      s || (s = await Pe(e), e.registerAsync("matchingClient", () => s));
+      let r = i;
+      return r || (r = new q(e, s), e.registerAsync(t, () => r)), r;
+    }));
+  }
+  fetch(e, t, i) {
+    return new Promise((s, r) => {
+      t.take, vt(t);
+      const a = Ee(e);
+      let o = this.queries.get(a) || [], c = o.find((h) => F(h.params, t)) || null;
+      if (c && (i != null && i.noCache)) {
+        const h = o.findIndex(
+          (d) => F(d.params, t)
+        );
+        o = [...o.slice(0, h), ...o.slice(h + 1)], c = null;
+      }
+      if (c) {
+        const h = o.indexOf(c);
+        if (c.resolved ? (this.events.dispatch("data-client:fetched", {
+          params: t,
+          type: a,
+          response: c.data,
+          unresolvedQueries: this.getUnresolvedQueries()
+        }), this.track(c.data, a, c.error), c.data && c.error ? r({ error: c.error }) : s(c.data)) : c.resolvers.push({ resolve: s, reject: r }), o.splice(h, 1), o.push(c), this.queries.set(a, o), !c.loading && !c.resolved)
+          return this.runQuery(a, t);
+      } else
+        return o.push({
+          params: t,
+          resolved: !1,
+          loading: !0,
+          data: {},
+          resolvers: [{ resolve: s, reject: r }]
+        }), this.queries.set(a, o), this.runQuery(a, t);
+    }).then((s) => gt(s));
+  }
+  // query the cached data
+  read(e, t) {
+    const { select: i } = t, s = Ee(e);
+    return (this.queries.get(s) || []).reduce((o, c) => {
+      if (typeof i == "function") {
+        const h = i(c.data);
+        h && o.push(h);
+      } else
+        o.push(c.data);
+      return o;
+    }, []);
+  }
+  feedback(e, t, i) {
+    return this.matchingClient.giveFeedback(e, t, i);
+  }
+  setLoadingStatus(e, t, i) {
+    const s = this.queries.get(e) || [], r = s.find((a) => F(a.params, t));
+    r && (r.loading = i), this.queries.set(e, s);
+  }
+  async runQuery(e, t) {
+    const {
+      searchPhrase: i = "",
+      categories: s = "0",
+      contactMethodCategoryId: r = "0",
+      contactMethodId: a = "0",
+      tagId: o = void 0,
+      take: c = 5,
+      connection: h = "",
+      guideId: d,
+      expandCategories: g = "descendants",
+      currentCategory: u,
+      sorting: p = "popularity-descending",
+      guideIds: b = []
+    } = t, w = i.toString().trim();
+    if (await xt(this.container))
+      return Promise.resolve();
+    switch (e) {
+      case "match": {
+        const l = (f) => {
+          const [Y, _] = f.split("-");
+          return {
+            type: (/* @__PURE__ */ new Map([
+              ["popularity", "popularity"],
+              ["alphabetic", "title"],
+              ["modified", "lastModified"],
+              ["published", "firstPublished"]
+            ])).get(Y),
+            direction: _
+          };
+        };
+        return b.length ? this.matchingClient.customRequest("guides", "POST", {
+          configuration: { ids: b, take: +c }
+        }).then(
+          (f) => f && this.handleResponse(f, e, t)
+        ) : this.matchingClient.match(w, {
+          categories: s === "0" ? [] : Array.isArray(s) ? s : [+s],
+          take: +c,
+          tags: o,
+          sorting: l(p),
+          ids: b
+        }).then(
+          (f) => f && this.handleResponse(f, e, t)
+        );
+      }
+      case "match-by-category":
+        return this.matchingClient.match(w, {
+          groupByCategory: !0,
+          categories: s === "0" ? [] : Array.isArray(s) ? s : [+s],
+          take: +c,
+          tags: o
+        }).then(
+          (l) => l && this.handleResponse(l, e, t)
+        );
+      case "guide":
+        return this.matchingClient.getGuide(d, { connectionId: h }).then((l) => {
+          l && this.handleResponse(l, e, t);
+        }).catch((l) => {
+          const f = {
+            message: "Something went wrong.",
+            status: l.status || 400
+          };
+          f.status === 404 && (f.message = "The guide could not be found."), this.handleResponse({}, e, t, f);
+        });
+      case "categories":
+        return this.matchingClient.getCategories({
+          phrase: w,
+          expand: g,
+          tags: o
+        }).then(
+          (l) => l && this.handleResponse(l, e, t)
+        );
+      case "contacts":
+        return d ? this.matchingClient.contactMethods(+d, { phrase: w }).then(
+          (l) => l && this.handleResponse(l, e, t)
+        ) : this.matchingClient.contacts(+r, { phrase: w }).then(
+          (l) => l && this.handleResponse(l, e, t)
+        );
+      case "contact-method":
+        return this.matchingClient.getContactMethod(+a, { guideId: d, currentCategory: u }).then(
+          (l) => l && this.handleResponse(l, e, t)
+        );
+      case "tags":
+        return this.matchingClient.customRequest("tags", "GET", {
+          configuration: {
+            take: 999999,
+            phrase: w,
+            categories: s === "0" ? [] : Array.isArray(s) ? s : [+s]
+          }
+        }).then(
+          (l) => l && this.handleResponse(l, e, t)
+        );
+      case "tagsonguides":
+        return this.matchingClient.customRequest("tagsonguides", "GET", {
+          configuration: {
+            take: 999999,
+            phrase: w,
+            categories: s === "0" ? [] : Array.isArray(s) ? s : [+s],
+            tags: o
+          }
+        }).then(
+          (l) => l && this.handleResponse(l, e, t)
+        );
+      case "notifications":
+        return this.matchingClient.customRequest("notices", "GET", {
+          configuration: {
+            phrase: w,
+            categories: s === "0" ? [] : Array.isArray(s) ? s : [+s]
+          }
+        }).then(
+          (l) => l && this.handleResponse(l, e, t)
+        );
+    }
+  }
+  handleResponse(e = {}, t, i, s) {
+    const r = this.queries.get(t) || [], a = r.find((o) => F(o.params, i));
+    if (a) {
+      const o = s || Pt(t, e);
+      this.track(o, t, s), a.resolvers.forEach((h) => {
+        s ? h.reject({ error: o }) : h.resolve(o);
+      });
+      const c = r.indexOf(a);
+      c > -1 && r.splice(c, 1), r.push({
+        ...a,
+        error: s,
+        resolvers: [],
+        data: o,
+        resolved: !0
+      }), this.setLoadingStatus(t, i, !1), this.queries.set(t, r), s || this.events.dispatch("data-client:fetched", {
+        type: t,
+        params: i,
+        response: o,
+        unresolvedQueries: this.getUnresolvedQueries()
+      });
+    }
+  }
+  fetchAllUnresolvedQueries() {
+    for (const [e, t] of this.queries)
+      t.filter((i) => !i.resolved).forEach((i) => {
+        this.runQuery(e, i.params);
+      });
+  }
+  track(e = {}, t, i) {
+    const s = this.container.get("$widget");
+    s && !i ? s.events.dispatch("tracking:service-client-response", {
+      type: t,
+      data: e
+    }) : s && s.events.dispatch("tracking:service-client-error", {
+      type: t,
+      error: i
+    });
+  }
+  static create(e) {
+    return e.getAsync("matchingClient").then(async (t) => {
+      if (t)
+        return new q(e, t);
+      const i = await Pe(e);
+      return e.registerAsync("matchingClient", () => i), new q(e, i);
+    });
+  }
+  getClient() {
+    return this.matchingClient;
+  }
+}
+const Lt = async (n) => {
+  n.registerAsync("dataClient", () => q.create(n));
+};
+export {
+  q as DataClient,
+  Et as DataType,
+  At as FeedbackType,
+  Lt as KnowledgeDataClientPlugin,
+  C as ServiceClientQueryType,
+  Nt as SortingType,
+  Ee as determineServiceClientQueryType,
+  Pt as formatLegacyData
+};