@telia-ace/widget-core-flamingo 1.0.14

package/dist/index.js

@@ -0,0 +1,2076 @@
+var Vt = Object.defineProperty, jt = Object.defineProperties;
+var qt = Object.getOwnPropertyDescriptors;
+var ct = Object.getOwnPropertySymbols;
+var Ft = Object.prototype.hasOwnProperty, Ht = Object.prototype.propertyIsEnumerable;
+var at = (n, t, e) => t in n ? Vt(n, t, { enumerable: !0, configurable: !0, writable: !0, value: e }) : n[t] = e, I = (n, t) => {
+  for (var e in t || (t = {}))
+    Ft.call(t, e) && at(n, e, t[e]);
+  if (ct)
+    for (var e of ct(t))
+      Ht.call(t, e) && at(n, e, t[e]);
+  return n;
+}, ht = (n, t) => jt(n, qt(t));
+class He {
+  constructor(t) {
+    const { events: e } = t.get("$widget");
+    this.events = e.createChild(this);
+  }
+  action(t, e, s) {
+    this.events.dispatch(
+      "data:action",
+      { action: e, value: s, target: t },
+      { bubbles: !0 }
+    );
+  }
+  subscribe(t, e) {
+    return this.events.subscribe(
+      "data:action",
+      (s, { action: i, value: r, target: o }) => t === o && e(t, i, r)
+    );
+  }
+}
+const j = (n, t, e, ...s) => {
+  const i = `[${n.get("$environment").name || "webprovisions"}] ${e}`;
+  switch (t) {
+    case "info":
+      console.info(i, ...s);
+      break;
+    case "warning":
+      console.warn(i, ...s);
+      break;
+    case "error":
+      console.error(i, ...s);
+      break;
+  }
+}, $t = (n) => {
+  const t = n.container || n;
+  return {
+    info: (e, ...s) => j(t, "info", e, ...s),
+    warn: (e, ...s) => j(t, "warning", e, ...s),
+    error: (e, ...s) => j(t, "error", e, ...s)
+  };
+}, lt = (n, t) => {
+  if (!t)
+    return !0;
+  if (typeof t == "string") {
+    const e = t.split(",");
+    for (let s = 0, i = e.length; s < i; s++) {
+      const r = e[s].trim();
+      if (r === n || r === "*")
+        return !0;
+    }
+  }
+  return t instanceof Array ? t.indexOf(n) > -1 : !1;
+}, Wt = (n, t) => {
+  if (typeof t == "function")
+    return t(n);
+  const e = typeof t == "string" ? Qt(t) : t;
+  return !(!lt(n.tenant || "", e.tenant || "") || !lt(n.name, e.implementation || ""));
+}, Bt = (n) => (t) => Wt(t, n), q = (n) => n instanceof Array && n.length === 1 ? n[0] : n, Qt = (n) => {
+  const t = {}, e = n.split(":");
+  return e.length === 1 ? t.implementation = q(e[0].split(",")) : (t.tenant = q(e[0].split(",")), t.implementation = q(e[1].split(","))), t;
+};
+var D = /* @__PURE__ */ ((n) => (n.Implementation = "implementation", n.Widget = "widget", n))(D || {}), E = /* @__PURE__ */ ((n) => (n.Pre = "pre", n.Post = "post", n))(E || {});
+const Yt = (n, t, e, s) => {
+  try {
+    const i = new t(e, s);
+    return {
+      name: n,
+      invoke: (r, o) => {
+        let c;
+        return i[r] && (c = i[r].call(i, o)), Promise.resolve(c);
+      },
+      getInstance: () => i
+    };
+  } catch (i) {
+    if (i.message && i.message.indexOf("is not a constructor") >= 0)
+      return {
+        name: n,
+        invoke: (r) => {
+          let o;
+          return r === "initialize" && (o = t(e, s)), Promise.resolve(o);
+        },
+        getInstance: () => t
+      };
+    throw i;
+  }
+};
+function ut(n, t) {
+  return typeof n == "undefined" ? t : n;
+}
+let Ut = class {
+  constructor(t = {}) {
+    this.part = t;
+  }
+  createCommand(t, e, s) {
+    let i;
+    typeof e == "function" ? i = {
+      scope: D.Widget,
+      stage: E.Post,
+      defaultArgs: void 0,
+      handlerResolver: e
+    } : i = {
+      scope: ut(e.scope, D.Widget),
+      stage: ut(e.stage, E.Post),
+      defaultArgs: e.defaultArgs,
+      handlerResolver: s
+    };
+    let r = this.part;
+    const o = t.split(".");
+    return o.forEach((c, u) => {
+      u === o.length - 1 ? r[c] || (r[c] = () => i) : r = this.part[c] = this.part[c] || {};
+    }), this;
+  }
+  get() {
+    return this.part;
+  }
+};
+const Ct = (n) => {
+  const t = new Ut({});
+  return n(t), t.get();
+};
+Ct((n) => {
+  n.createCommand(
+    "types.register",
+    { scope: D.Implementation, stage: E.Pre },
+    (t) => (e, s) => {
+      t.container.get("$types")[e] = s;
+    }
+  ).createCommand(
+    "type",
+    { stage: E.Pre },
+    (t) => (e) => {
+      t.container.register("$type", e);
+    }
+  ).createCommand(
+    "settings",
+    { stage: E.Pre, defaultArgs: [null] },
+    (t) => (e) => {
+      t.events.dispatch(
+        "settings:change",
+        e,
+        { bubbles: !0 }
+      ), t.container.register("$settings", e);
+    }
+  ).createCommand(
+    "plugin",
+    { stage: E.Pre },
+    (t) => (e, s, i) => {
+      const { container: r } = t;
+      let o = null, c = e, u = s;
+      typeof e == "string" && (o = e, c = s, u = i);
+      const h = (a) => {
+        const { transformPluginSettings: l } = t.container.get("$environmentOptions"), p = l ? l(
+          u || {},
+          o,
+          t.container,
+          c
+        ) : s;
+        try {
+          const d = Yt(
+            o,
+            c,
+            r,
+            p
+          );
+          r.get("$plugins").push(d), a && d.invoke("initialize", null);
+        } catch (d) {
+          $t(t).warn("Error when initializing plugin", d);
+        }
+      };
+      t.container.get("$instance") ? h(!0) : t.events.subscribeOnce("widget:instance-created", () => h(!1));
+    }
+  ).createCommand(
+    "container.register",
+    (t) => (e, s) => {
+      t.container.register(e, s);
+    }
+  ).createCommand(
+    "container.registerAsync",
+    (t) => (e, s) => {
+      t.container.registerAsync(e, s);
+    }
+  ).createCommand(
+    "container.registerFactory",
+    (t) => (e, s) => {
+      t.container.registerFactory(e, s);
+    }
+  ).createCommand(
+    "container.touch",
+    (t) => (e, s) => {
+      t.container.touch(e, s);
+    }
+  ).createCommand(
+    "csp",
+    {},
+    (t) => (e) => {
+      t.container.register("csp", e);
+    }
+  );
+});
+function Gt(n, t, e) {
+  return Array.from(n.querySelectorAll(
+    `div[id^="${t}_"], div[id^="${t}:"]`
+  )).map((s) => {
+    if (s.id.substr(0, 7) === `${t}_`)
+      return { widgetName: s.id.substr(7), element: s };
+    const { 3: i } = s.id.split(":");
+    return { widgetName: i, element: s };
+  });
+}
+const Kt = (n) => {
+  const t = n.map((e) => e.replace(/\./g, "\\.")).join("|");
+  return new RegExp("^((http[s]?:)?//)?(" + t + ")/([^\\s]+)");
+}, Jt = (n) => n.href;
+function Xt(n, t) {
+  const e = Kt(t), s = (i) => {
+    const r = e.exec(Jt(i));
+    return r ? {
+      element: i,
+      widget: r[4]
+    } : null;
+  };
+  return Array.from(n.querySelectorAll("a")).map((i) => s(i)).filter((i) => !!i).map((i) => ({
+    element: i.element,
+    widgetName: i.widget
+  }));
+}
+function kt(n) {
+  return n.filter((t, e, s) => s.indexOf(t) === e);
+}
+let Zt = class {
+  constructor(t) {
+    this.container = t.container, this.events = t.events;
+  }
+  watch(t) {
+    const e = this.container.get("triggerElements") || [], s = kt(e.concat(t));
+    this.container.register("triggerElements", s), this.events.dispatch(
+      "bootstrap:trigger-elements-updated",
+      { triggerElements: s },
+      { bubbles: !0 }
+    );
+  }
+};
+function Et(n, ...t) {
+  return n.implementation.events.subscribe("widget:create-instance", (e, s) => {
+    if (e.target === n) {
+      let i = n.container.get("bootstrapping.monitor");
+      i || (i = new Zt(n), n.container.register("bootstrapping.monitor", i)), i.watch(t);
+    }
+  }), n.load();
+}
+function Pt(n, t = document) {
+  var e;
+  const s = n.bindings, i = [].concat(
+    Xt(t, s),
+    Gt(t, ((e = n.environment) == null ? void 0 : e.name) || "")
+  ), r = kt(i.map(({ widgetName: o }) => o)).reduce((o, c) => {
+    const u = n.widgets.get(c);
+    if (!u)
+      return process.env.NODE_ENV !== "production" && $t(n).warn(`A trigger element for "${c}" was found but no widget with that name is available on the implementation ("${n.name}"). Make sure this is not a mistake.`), o;
+    const h = i.filter((a) => a.widgetName === c).map((a) => a.element);
+    return o.push(Et(u, ...h)), o;
+  }, []);
+  return Promise.all(r);
+}
+function te() {
+  return new Promise((n) => {
+    document.readyState === "loading" ? document.addEventListener("DOMContentLoaded", () => n()) : n();
+  });
+}
+const ee = (n, t) => {
+  const e = n;
+  e.scan = (i) => Pt(e, i), e.bindings = t, e.attach = (i, ...r) => Et(i, ...r);
+  const { environment: s } = e;
+  return typeof s.configure == "undefined" && (s.configure = (i, r) => {
+    let o, c;
+    r ? (o = i, c = r) : (o = "*", c = i), s.implementations.query(o).forEach((u) => u.configure(c)), s.events.subscribe("implementation:created", (u, h) => {
+      const { implementation: a } = h;
+      Bt(o)(a) && a.configure(c);
+    });
+  }), e;
+};
+function se(n, t, e = () => [], s) {
+  const i = { ready: !1 };
+  n.container.register("bootstrapping", i);
+  const r = ee(n, t);
+  return te().then(() => {
+    n.configure((...o) => {
+      e().forEach((c) => c(...o));
+    });
+  }).then(() => Pt(r, s())).then(() => (i.ready = !0, n.events.dispatch("bootstrap:ready", {}), r));
+}
+const ne = Ct((n) => {
+  n.createCommand(
+    "ready",
+    { scope: D.Implementation, stage: E.Pre },
+    (t) => (e) => {
+      const { container: s } = t, i = s.owner;
+      s.get("bootstrapping").ready ? e(i) : i.events.subscribeOnce("bootstrap:ready", () => {
+        e(i);
+      });
+    }
+  );
+}), F = /* @__PURE__ */ new WeakMap();
+function A() {
+  return (n) => (F.has(n) || F.set(n, {}), F.get(n));
+}
+const H = (n, t, e, ...s) => {
+  const i = `[${n.get("$environment").name || "webprovisions"}] ${e}`;
+  switch (t) {
+    case "info":
+      console.info(i, ...s);
+      break;
+    case "warning":
+      console.warn(i, ...s);
+      break;
+    case "error":
+      console.error(i, ...s);
+      break;
+  }
+}, g = (n) => {
+  const t = n.container || n;
+  return {
+    info: (e, ...s) => H(t, "info", e, ...s),
+    warn: (e, ...s) => H(t, "warning", e, ...s),
+    error: (e, ...s) => H(t, "error", e, ...s)
+  };
+}, m = A(), U = (() => {
+  let n = 0;
+  return () => ++n;
+})(), G = (n, t, e) => {
+  const s = m(n).touchQueue.get(t);
+  s && s.forEach((i) => {
+    i(e, n);
+  });
+};
+class ie {
+  constructor(t, e, s, i) {
+    this.key = t, this.factory = e, this.parent = s, this.container = i, this.id = U(), this.resolved = !1, this.constructed = !1, this.async = !0;
+  }
+  resolve() {
+    if (!this.constructed) {
+      const t = this.factory(this.parent, this.container);
+      return this.constructed = !0, this.value = Promise.resolve(t).then((e) => (this.resolved = !0, G(this.container, this.key, e), e));
+    }
+    return this.value;
+  }
+}
+class re {
+  constructor(t, e, s, i) {
+    this.key = t, this.value = e, this.parent = s, this.container = i, this.id = U(), this.async = !1, this.resolved = !1, this.constructed = !0, this.resolve = () => (this.resolved = !0, G(this.container, this.key, this.value), this.value);
+  }
+}
+class oe {
+  constructor(t, e, s, i) {
+    this.key = t, this.value = e, this.parent = s, this.container = i, this.id = U(), 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 G(this.container, this.key, this.value), r;
+    };
+  }
+}
+class K {
+  /**
+   * 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(t, e, s) {
+    this.owner = t, this.name = e, this.parent = s, 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(t) {
+    const e = m(this).resolvers, s = Array.from(e.values()).find((i) => i.id === t);
+    return s ? (m(this).touchQueue.delete(s.key), Promise.resolve(e.delete(s.key))) : this.parent ? this.parent.delete(t) : Promise.resolve(!1);
+  }
+  /**
+   * Clears the `Container` and any child containers by deleteing all registered resolvers.
+   */
+  clear() {
+    const t = m(this).resolvers, e = Array.from(t.values());
+    return Promise.all(e.map((s) => {
+      if (s.constructed)
+        return Promise.resolve(s.resolve()).then((i) => {
+          if (i !== null && typeof i == "object" && typeof i.dispose == "function")
+            return i.dispose.call(i, this, s);
+        });
+    })).then(() => {
+      e.forEach((s) => this.delete(s.id)), m(this).children.forEach((s) => s.clear());
+    });
+  }
+  /**
+   * Detaches this `Container` instance from its parent, allowing it to be garbage-collected.
+   */
+  detach() {
+    if (this.parent) {
+      const t = m(this.parent).children, e = t.indexOf(this);
+      e > -1 && (t.splice(e, 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(t, e) {
+    const s = m(this).resolvers.get(t);
+    if (s && s.constructed)
+      Promise.resolve(s.resolve()).then((i) => {
+        e(i, this);
+      });
+    else {
+      const i = m(this).touchQueue;
+      let r = i.get(t);
+      r || (r = [], i.set(t, r)), r.push(e);
+    }
+    return this.parent && !s ? this.parent.touch(t, e) : Promise.resolve();
+  }
+  /**
+   * Registers an asynchronous resolver.
+   * @param key Key of the resolver.
+   * @param factory Value factory.
+   */
+  registerAsync(t, e) {
+    const s = m(this).resolvers.get(t);
+    s && !s.async && process.env.NODE_ENV !== "production" && g(this).warn(`Mismatching resolver type. You are registering an async resolver with a key ('${t}') previously used by a non-async resolver.`);
+    const i = new ie(t, e, s, this);
+    return m(this).resolvers.set(t, 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(t, e) {
+    const s = m(this).resolvers.get(t);
+    s && s.async && process.env.NODE_ENV !== "production" && g(this).warn(`Mismatching resolver type. You are registering a non-async resolver with a key ('${t}') previously used by an async resolver.`);
+    const i = new oe(t, e, s, this);
+    return m(this).resolvers.set(t, i), i.id;
+  }
+  /**
+   * Registers an synchronous resolver.
+   * @param key Key of the resolver.
+   * @param value Value.
+   */
+  register(t, e) {
+    const s = m(this).resolvers.get(t);
+    s && s.async && process.env.NODE_ENV !== "production" && g(this).warn(`Mismatching resolver type. You are registering a non-async resolver with a key ('${t}') previously used by an async resolver.`);
+    const i = new re(t, e, s, this);
+    return m(this).resolvers.set(t, i), i.id;
+  }
+  /**
+   * Gets the value for a synchronous resolver.
+   * @param key Key of resolver to get.
+   */
+  get(t) {
+    const e = m(this).resolvers.get(t);
+    if (e)
+      return e.async && process.env.NODE_ENV !== "production" && g(this).warn(`You are retrieving an async value (with key '${t}') by the non-async function 'container.get(key)'. This will not be supported in future versions. Use 'container.getAsync(key) instead.'`), e.resolve();
+    if (this.parent)
+      return this.parent.get(t);
+  }
+  /**
+   * Gets the value for a asynchronous resolver.
+   * @param key Key of resolver to get.
+   */
+  getAsync(t) {
+    const e = m(this).resolvers.get(t);
+    if (e) {
+      if (!e.async)
+        throw process.env.NODE_ENV !== "production" && g(this).warn(`You are retrieving a non-async value (with key '${t}') by the async function 'container.getAsync(key)'.Use 'container.get(key) instead.'`), "Mismatching resolver type";
+      return e.resolve();
+    }
+    return this.parent ? this.parent.getAsync(t) : Promise.resolve(void 0);
+  }
+  getMany(...t) {
+    const e = {};
+    return t.forEach((s) => e[s] = this.get(s)), e;
+  }
+  getManyAsync(...t) {
+    const e = {};
+    return Promise.all(t.map((s) => this.getAsync(s).then((i) => e[s] = i))).then(() => e);
+  }
+  createChild(t, e) {
+    const s = new K(t, e, this);
+    return m(this).children.push(s), s;
+  }
+}
+class pt {
+  /**
+   * 
+   * @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(t, e, s = !1, i = !1) {
+    this.type = t, this.target = e, this.cancelable = !!s, this.bubbles = !!i, this.defaultPrevented = !1;
+  }
+  /**
+   * Cancels the default behaviour (if the event is cancelable).
+   */
+  preventDefault() {
+    this.cancelable && (this.defaultPrevented = !0);
+  }
+}
+const b = A(), dt = (n, t) => [].concat(
+  b(n).listenerLookup.get(t.toLowerCase()) || [],
+  b(n).listenerLookup.get("*") || []
+), mt = (n, t, e, s) => {
+  let i, r;
+  return t instanceof pt ? (i = t, r = t.type) : (i = new pt(t, n.target, !!e.cancelable, !!e.bubbles), r = t), { event: i, type: r, async: s };
+};
+class J {
+  /**
+   * 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(t, e) {
+    this.target = t, this.parent = e, b(this).listenerLookup = /* @__PURE__ */ new Map(), b(this).children = [];
+  }
+  /**
+   * Clears registered event listeners in this `EventManager` as well as in any children.
+   */
+  clear() {
+    b(this).listenerLookup.clear(), b(this).children.forEach((t) => t.clear());
+  }
+  /**
+   * Detaches this `EventManager` instance from its parent, allowing it to be garbage-collected.
+   */
+  detach() {
+    if (this.parent) {
+      const t = b(this.parent).children, e = t.indexOf(this);
+      e > -1 && t.splice(e, 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(t, e, s) {
+    const i = b(this).listenerLookup, r = t.toLowerCase();
+    return i.has(r) || i.set(r, []), i.get(r).push(e), () => this.unsubscribe(t, e);
+  }
+  /**
+   * 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(t, e) {
+    const s = this.subscribe(t, (i, r) => (s(), e(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(t, e) {
+    const s = b(this).listenerLookup.get(t.toLowerCase());
+    if (s) {
+      const i = s.indexOf(e);
+      i > -1 && s.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(t, e, s = {}) {
+    const { event: i, type: r } = mt(this, t, s, !0), o = dt(this, r);
+    let c = 0;
+    const u = o.length;
+    let h = Promise.resolve();
+    for (c = 0; c < u; c++)
+      ((a) => {
+        h = h.then((l) => l ? Promise.resolve(!0) : Promise.resolve(a(i, e)).then(() => i.defaultPrevented));
+      })(o[c]);
+    return h.then((a) => !a && i.bubbles && this.parent ? this.parent.dispatchAsync(i, e) : a);
+  }
+  /**
+   * 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(t, e, s = {}) {
+    const { event: i, type: r } = mt(this, t, s, !1), o = dt(this, r);
+    let c = 0;
+    const u = o.length;
+    let h = !1;
+    for (c = 0; c < u; c++)
+      if (o[c](i, e), i.defaultPrevented) {
+        h = !0;
+        break;
+      }
+    return !h && i.bubbles && this.parent && (h = this.parent.dispatch(i, e)), h;
+  }
+  /**
+   * Creates a child instance to the current Event manager.
+   */
+  createChild(t) {
+    const e = new J(t, this);
+    return b(this).children.push(e), e;
+  }
+}
+const L = (n, t, e) => {
+  const s = n.get("$plugins").map((i) => {
+    try {
+      return i.invoke(t, e);
+    } catch (r) {
+      g(n).error("An error occured when invoking a plugin.", i, r);
+    }
+  });
+  return Promise.all(s);
+};
+class ce {
+  constructor(t) {
+    this.widget = t.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 t = this.widget.container.get("$types"), e = this.widget.container.get("$type");
+      !e && g(this).error("Unable to create widget. No type is specified.");
+      const s = t[e];
+      !s && g(this).error(`Unable to create widget. Type '${e}' is not registered.`), this.widget.events.dispatch("widget:create-instance", {}, { bubbles: !0 });
+      try {
+        this.widget.container.register(
+          "$instance",
+          new s(this.container)
+        );
+      } catch (i) {
+        g(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(t) {
+    return this.initialized = this.initialized || (() => {
+      const e = this.container.get("$instance"), s = e.initialize || (() => {
+      });
+      return this.initialized = Promise.resolve(s.call(e, t)).then(() => L(this.container, "initialize", t)).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(t) {
+    return (this.initialized || this.initialize()).then(() => {
+      this.activated = this.activated || (() => L(this.container, "activate").then(() => {
+        const e = this.container.get("$instance");
+        return this.activated = e.activate(t);
+      }))();
+    });
+  }
+  deactivate() {
+    const t = this.container.get("$instance"), e = t.deactivate || (() => {
+    });
+    return L(this.container, "deactivate").then(() => Promise.resolve(e.call(t))).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(t, ...e) {
+    return L(this.container, "invoke", { command: t, args: e }).then(() => {
+      const s = this.container.get("$instance");
+      if (s[t])
+        return s[t].apply(s, e);
+      const i = s.invoke;
+      if (i)
+        return i.call(s, t, ...e);
+    });
+  }
+}
+const O = (n, t) => {
+  if (!t)
+    return !0;
+  if (typeof t == "string") {
+    const e = t.split(",");
+    for (let s = 0, i = e.length; s < i; s++) {
+      const r = e[s].trim();
+      if (r === n || r === "*")
+        return !0;
+    }
+  }
+  return t instanceof Array ? t.indexOf(n) > -1 : !1;
+}, ae = (n, t) => {
+  if (typeof t == "function")
+    return t(n);
+  const e = typeof t == "string" ? le(t) : t;
+  return !(!O(n.implementation.tenant || "", e.tenant || "") || !O(n.implementation.name, e.implementation || "") || !O(n.name, e.widget || "") || !O(n.container.get("$type"), e.type || ""));
+}, he = (n, t) => {
+  if (typeof t == "function")
+    return t(n);
+  const e = typeof t == "string" ? ue(t) : t;
+  return !(!O(n.tenant || "", e.tenant || "") || !O(n.name, e.implementation || ""));
+}, Ot = (n) => (t) => ae(t, n), At = (n) => (t) => he(t, n), x = (n) => n instanceof Array && n.length === 1 ? n[0] : n, le = (n) => {
+  const t = {}, e = n.split(":");
+  return e.length === 1 ? t.widget = x(e[0].split(",")) : e.length === 2 ? (t.implementation = x(e[0].split(",")), t.widget = x(e[1].split(","))) : (t.tenant = x(e[0].split(",")), t.implementation = x(e[1].split(",")), t.widget = x(e[2].split(","))), t;
+}, ue = (n) => {
+  const t = {}, e = n.split(":");
+  return e.length === 1 ? t.implementation = x(e[0].split(",")) : (t.tenant = x(e[0].split(",")), t.implementation = x(e[1].split(","))), t;
+}, z = A(), gt = (n, t, e) => n.filter((s) => s.stage === t && Ot(s.selector)(e));
+function pe(n) {
+  const t = n.container.get("$environment");
+  let e = z(t).configurationCache;
+  e && (e = e.filter((s) => s[0] !== n), z(t).configurationCache = e);
+}
+var S = /* @__PURE__ */ ((n) => (n.Implementation = "implementation", n.Widget = "widget", n))(S || {}), $ = /* @__PURE__ */ ((n) => (n.Pre = "pre", n.Post = "post", n))($ || {});
+const Nt = (n, t, e) => (Object.keys(t).forEach((s) => {
+  const i = t[s];
+  if (typeof i == "function") {
+    const r = i();
+    typeof r.defaultArgs != "undefined" && e(r, ...r.defaultArgs), n[s] = (...o) => {
+      const c = Object.assign(
+        {},
+        r,
+        { handlerResolver: r.handlerResolver.bind({}) }
+      );
+      return e(c, ...o), n;
+    };
+  } else
+    n[s] = Nt(
+      {},
+      i,
+      e
+    );
+}), n), de = (n, t) => {
+  switch (t) {
+    case "implementation":
+      return n.implementation;
+    case "widget":
+      return n;
+  }
+}, ft = (n, t, e, s) => (s.forEach((i) => {
+  Nt(
+    n,
+    i,
+    (r, ...o) => {
+      const c = {
+        selector: t,
+        stage: r.stage,
+        handler: (u) => {
+          const h = de(u, r.scope), a = { container: h.container, events: h.events }, l = r.handlerResolver, p = l(a);
+          let d = z(e.environment).configurationCache;
+          return d || (d = z(e.environment).configurationCache = []), d.find((C) => C.indexOf(h) > -1 && C.indexOf(l) > -1) ? Promise.resolve() : (d.push([h, l]), Promise.resolve(p(...o)));
+        }
+      };
+      e.instructions.push(c);
+    }
+  );
+}), n);
+function me(n, t) {
+  function e(s) {
+    return ft(
+      {},
+      s,
+      n,
+      t
+    );
+  }
+  return ft(
+    e,
+    "*",
+    n,
+    t
+  );
+}
+class ge {
+  constructor(t, e) {
+    this.container = t, this.settings = e, this.widget = t.get("$widget"), this.events = this.widget.events;
+  }
+}
+const fe = (n, t, e, s) => {
+  try {
+    const i = new t(e, s);
+    return {
+      name: n,
+      invoke: (r, o) => {
+        let c;
+        return i[r] && (c = i[r].call(i, o)), Promise.resolve(c);
+      },
+      getInstance: () => i
+    };
+  } catch (i) {
+    if (i.message && i.message.indexOf("is not a constructor") >= 0)
+      return {
+        name: n,
+        invoke: (r) => {
+          let o;
+          return r === "initialize" && (o = t(e, s)), Promise.resolve(o);
+        },
+        getInstance: () => t
+      };
+    throw i;
+  }
+};
+function vt(n, t) {
+  return typeof n == "undefined" ? t : n;
+}
+class ve {
+  constructor(t = {}) {
+    this.part = t;
+  }
+  createCommand(t, e, s) {
+    let i;
+    typeof e == "function" ? i = {
+      scope: S.Widget,
+      stage: $.Post,
+      defaultArgs: void 0,
+      handlerResolver: e
+    } : i = {
+      scope: vt(e.scope, S.Widget),
+      stage: vt(e.stage, $.Post),
+      defaultArgs: e.defaultArgs,
+      handlerResolver: s
+    };
+    let r = this.part;
+    const o = t.split(".");
+    return o.forEach((c, u) => {
+      u === o.length - 1 ? r[c] || (r[c] = () => i) : r = this.part[c] = this.part[c] || {};
+    }), this;
+  }
+  get() {
+    return this.part;
+  }
+}
+const _t = (n) => {
+  const t = new ve({});
+  return n(t), t.get();
+}, be = _t((n) => {
+  n.createCommand(
+    "types.register",
+    { scope: S.Implementation, stage: $.Pre },
+    (t) => (e, s) => {
+      t.container.get("$types")[e] = s;
+    }
+  ).createCommand(
+    "type",
+    { stage: $.Pre },
+    (t) => (e) => {
+      t.container.register("$type", e);
+    }
+  ).createCommand(
+    "settings",
+    { stage: $.Pre, defaultArgs: [null] },
+    (t) => (e) => {
+      t.events.dispatch(
+        "settings:change",
+        e,
+        { bubbles: !0 }
+      ), t.container.register("$settings", e);
+    }
+  ).createCommand(
+    "plugin",
+    { stage: $.Pre },
+    (t) => (e, s, i) => {
+      const { container: r } = t;
+      let o = null, c = e, u = s;
+      typeof e == "string" && (o = e, c = s, u = i);
+      const h = (a) => {
+        const { transformPluginSettings: l } = t.container.get("$environmentOptions"), p = l ? l(
+          u || {},
+          o,
+          t.container,
+          c
+        ) : s;
+        try {
+          const d = fe(
+            o,
+            c,
+            r,
+            p
+          );
+          r.get("$plugins").push(d), a && d.invoke("initialize", null);
+        } catch (d) {
+          g(t).warn("Error when initializing plugin", d);
+        }
+      };
+      t.container.get("$instance") ? h(!0) : t.events.subscribeOnce("widget:instance-created", () => h(!1));
+    }
+  ).createCommand(
+    "container.register",
+    (t) => (e, s) => {
+      t.container.register(e, s);
+    }
+  ).createCommand(
+    "container.registerAsync",
+    (t) => (e, s) => {
+      t.container.registerAsync(e, s);
+    }
+  ).createCommand(
+    "container.registerFactory",
+    (t) => (e, s) => {
+      t.container.registerFactory(e, s);
+    }
+  ).createCommand(
+    "container.touch",
+    (t) => (e, s) => {
+      t.container.touch(e, s);
+    }
+  ).createCommand(
+    "csp",
+    {},
+    (t) => (e) => {
+      t.container.register("csp", e);
+    }
+  );
+}), ye = be;
+function we(n, t, e = []) {
+  const s = [ye].concat(e), i = me(
+    t,
+    s
+  );
+  n(i, t);
+}
+class xe {
+  constructor() {
+    this.tasks = [], this.current = Promise.resolve(), this.next = this.next.bind(this);
+  }
+  add(t, e, s, i) {
+    this.tasks.push({ task: t, resolve: e, reject: s, done: i }), this.next();
+  }
+  next() {
+    this.current = this.current.then(() => {
+      const t = this.tasks.shift();
+      if (t) {
+        const e = Promise.resolve(t.task());
+        return Promise.resolve(e).then(this.next).then(() => e.then((s) => {
+          t.done(), t.resolve(s);
+        })).catch((s) => (t.done(), t.reject(s), this.next()));
+      }
+      return Promise.resolve();
+    });
+  }
+}
+const M = /* @__PURE__ */ new WeakMap();
+function $e(n) {
+  return M.has(n) || M.set(n, new xe()), (t) => new Promise((e, s) => {
+    const i = M.get(n);
+    i.add(t, e, s, () => {
+      i.tasks.length || M.delete(n);
+    });
+  });
+}
+const bt = (n) => typeof n != "undefined", _ = (n, t) => {
+  n.events.dispatch("widget:state-change", { state: t }, { bubbles: !0 }), n.state = t, n.events.dispatch("widget:state-changed", {}, { bubbles: !0 });
+}, v = A(), Ce = (n) => {
+  const { container: t, events: e } = n;
+  t.get("$controller") || (t.register("$controller", new ce(t)), e.dispatch("widget:controller-created", {}, { bubbles: !0 }));
+};
+class ke {
+  /**
+   * 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(t, e, s) {
+    this.state = "deactivated", this.name = t, this.implementation = e, this.container = e.container.createChild(this, t), this.events = e.events.createChild(this), v(this).subscriptions = [], s && e.configure((i) => {
+      const r = i(t);
+      bt(s.type) && r.type(s.type), bt(s.settings) && r.settings(s.settings), s.plugins && Object.keys(s.plugins).forEach((o) => {
+        var c;
+        const u = (c = s.plugins) == null ? void 0 : c[o];
+        r.plugin(o, u);
+      });
+    }), 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 $e(this)(() => {
+      v(this).deactivatedPromise = null;
+      const t = this.state === "deactivated";
+      t && (_(
+        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)), _(
+        this,
+        "loading"
+        /* Loading */
+      );
+      const e = this.implementation.instructions, s = gt(e, $.Pre, this);
+      return Promise.all(s.map((i) => i.handler(this))).then(() => {
+        Ce(this);
+        const i = gt(e, $.Post, this);
+        return Promise.all(i.map((r) => r.handler(this))).then(() => {
+          t && this.container.get("$controller").initialize();
+        });
+      }).then(() => (_(
+        this,
+        "activated"
+        /* Activated */
+      ), this));
+    });
+  }
+  /**
+   * Activates the widget and makes it ready for receiving commands.
+   * @param data Activation data
+   */
+  activate(t) {
+    v(this).subscriptions.push(
+      this.implementation.events.subscribe("implementation:configured", () => {
+        [
+          "activated",
+          "activating",
+          "loading"
+          /* Loading */
+        ].indexOf(this.state) > -1 && this.load();
+      })
+    );
+    const e = v(this).activatedPromise;
+    return e ? (process.env.NODE_ENV !== "production" && g(this).warn(`Widget '${this.name}' has already been activated. The passed arguments for this activation will be discarded.`, t), e) : v(this).activatedPromise = this.load().then(() => this.container.get("$controller").activate(t));
+  }
+  /**
+   * 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(t, ...e) {
+    const s = v(this).activatedPromise, i = (r, ...o) => s.then(this.load).then(() => this.container.get("$controller").invoke(r, ...o));
+    return s ? i(t, ...e) : (process.env.NODE_ENV !== "production" && g(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(t, ...e)));
+      });
+    }));
+  }
+  /**
+   * Deactivates the widget by clearing the `Container` and removing any event subscriptions in the
+   * `EventManager`.
+   */
+  deactivate() {
+    return v(this).deactivatedPromise || (this.state === "deactivated" ? Promise.resolve() : (_(
+      this,
+      "deactivating"
+      /* Deactivating */
+    ), v(this).deactivatedPromise = this.container.get("$controller").deactivate().then(() => (v(this).activatedPromise = null, v(this).subscriptions.forEach((e) => e()), v(this).subscriptions = [], this.container.clear().then(() => {
+      this.events.clear(), pe(this), _(
+        this,
+        "deactivated"
+        /* Deactivated */
+      );
+    })))));
+  }
+}
+class Ee {
+  /**
+   * Creates a new `Widget` instance.
+   * @param container The `Container` instance to base the widget upon.
+   */
+  constructor(t) {
+    this.container = t, this.widget = t.get("$widget"), this.settings = t.get("$settings"), this.events = this.widget.events, this.widget.events.subscribe("settings:change", (e, s) => {
+      this.settings = s;
+    });
+  }
+}
+const yt = A();
+class Rt {
+  /**
+   * Creates a new Implementation instance.
+   * @param configuration Configuration for the implementation.
+   * @param environment The parent environment.
+   * @param configurationApiExtensions Optional configuration API extensions.
+   */
+  constructor(t, e, s = []) {
+    this.instructions = [], this.widgets = /* @__PURE__ */ new Map(), this.name = t.name, this.tenant = t.tenant, this.environment = e, this.container = e.container.createChild(this, this.name), this.events = e.events.createChild(this), this.container.register("$types", {}), yt(this).configurationApiExtensions = s;
+  }
+  /**
+   * Loads all widgets in the implementation.
+   */
+  load() {
+    const t = Array.from(this.widgets.values());
+    return Promise.all(t.map((e) => e.load())).then(() => t);
+  }
+  /**
+   * Configures the implementation by adding a configuration callback.
+   * @param configFn Callback function for configuration.
+   */
+  configure(t) {
+    return we(t, this, yt(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(t, e) {
+    const s = new ke(t, this, e);
+    return this.widgets.set(s.name, s), s;
+  }
+}
+function Pe(n, t, e) {
+  const s = new Rt(n, t, e);
+  return n.widgets && Object.keys(n.widgets).forEach((i) => {
+    var r;
+    const o = (r = n.widgets) == null ? void 0 : r[i];
+    s.createWidget(i, o);
+  }), s;
+}
+let wt = class Dt {
+  constructor(t, e) {
+    this.selectorFactory = e, typeof t == "function" ? this.resolver = t : this.resolver = () => t;
+  }
+  append(t) {
+    const e = typeof t == "function" ? t : () => t;
+    return new Dt(
+      () => this.all().concat(e()),
+      this.selectorFactory
+    );
+  }
+  all() {
+    return this.resolver().concat([]);
+  }
+  query(t) {
+    return this.all().filter(this.selectorFactory(t));
+  }
+  find(t) {
+    const e = this.query(t);
+    if (e.length)
+      return e[0];
+  }
+};
+const X = "#____version____#", W = A(), Oe = (n) => n.tenant ? `${n.name}:${n.tenant}` : n.name, It = class {
+  constructor(n, t = [], e = {}) {
+    this.widgets = new wt(
+      () => {
+        let s = [];
+        return this.implementations.all().forEach((i) => {
+          s = s.concat(Array.from(i.widgets.values()));
+        }), s;
+      },
+      Ot
+    ), this.implementations = new wt([], At), this.name = n, this.container = new K(this, n), this.events = new J(this), this.container.register("$version", X), this.container.register("$environment", this), this.container.register("$environmentOptions", e), W(this).configurationApiExtensions = t;
+  }
+  /**
+   * Creates an implementation based on the provided configuration.
+   * @param config Implementation configuration.
+   */
+  createImplementation(n) {
+    const t = Oe(n);
+    let e = this.implementations.find(t);
+    if (e)
+      return process.env.NODE_ENV !== "production" && g(e).warn(`Implementation "${t}" already exist on current environment.`), e;
+    const s = W(this).configurationApiExtensions;
+    return e = Pe(
+      n,
+      this,
+      s
+    ), this.implementations = this.implementations.append([e]), this.events.dispatch("implementation:created", { implementation: e }), e;
+  }
+  /**
+   * Patches the Environment instance configuration.
+   * @param configuration Environment configuration.
+   */
+  patch(n = {}) {
+    const { name: t, configurationApiExtensions: e } = n;
+    typeof t != "undefined" && t !== null && (this.name = t), e && e.forEach(
+      (s) => {
+        W(this).configurationApiExtensions.push(s);
+      }
+    );
+  }
+  /**
+   * Creates a new Environment instance based on the provided configuration.
+   * @param configuration Environment configuration.
+   */
+  static create(n = {}) {
+    return new It(
+      n.name || "",
+      n.configurationApiExtensions,
+      n.options
+    );
+  }
+};
+let Lt = It;
+Lt.version = X;
+const Qe = (n, t, e = {}) => se(
+  n,
+  n.bindings,
+  () => {
+    const s = n.container.get("$runtimecfg").map((i) => {
+      const r = i[0];
+      if (typeof r == "function")
+        return r;
+      if (At(r)(n))
+        return i[1];
+    }).filter((i) => !!i);
+    return (t ? [t] : []).concat(s);
+  },
+  e.rootElementResolver || (() => document.body)
+), Ae = (n) => {
+  const t = [];
+  return [
+    (s, i) => {
+      t.push(n.subscribe(s, i));
+    },
+    () => {
+      t.forEach((s) => {
+        s();
+      });
+    }
+  ];
+};
+class Z {
+  constructor(t, e = []) {
+    this.platform = t, this.rules = e;
+  }
+  match(t) {
+    return this.rules.every((e) => !(e.id && e.id !== t.id || e.type && e.type !== t.type));
+  }
+  ofType(t) {
+    return this.rules.push({ type: t }), this;
+  }
+  withId(t) {
+    return this.rules.push({ id: t }), this;
+  }
+  select() {
+    return new Ne(this.platform, this);
+  }
+}
+class Mt {
+  constructor(t, e, s) {
+    this.platform = t, this.node = e, this.actions = new tt(
+      t,
+      new Z(t).withId(e.id),
+      s
+    );
+    const [i, r] = Ae(
+      this.platform.events
+    );
+    this.subscribe = i, this.unsubscribe = r;
+  }
+  properties(t) {
+    return t && this.node.touchProperties((e) => t(e)), this.node.attributes.properties;
+  }
+  context(t) {
+    return t && this.subscribe("components:context-changed", (e, { node: s }) => {
+      s === this.node && t(this.node.attributes.context);
+    }), this.node.attributes.context;
+  }
+  layout(t) {
+    return t && this.subscribe("components:layout-changed", (e, { node: s }) => {
+      s === this.node && t(this.node.attributes.layout);
+    }), this.node.attributes.layout;
+  }
+  writeProperties(t, e) {
+    this.node.writeProperties(t, e);
+  }
+  writeContext(t, e) {
+    this.node.writeProperties(t, e);
+  }
+  writeLayout(t, e) {
+    this.node.writeLayout(t, e);
+  }
+  dispose() {
+    this.unsubscribe(), this.actions.dispose();
+  }
+}
+class Ne {
+  constructor(t, e, s = !0) {
+    this.platform = t, this.target = e, this.clearOnDispose = s, this.removes = [], this.actions = new tt(this.platform, this.target);
+  }
+  writeProperties(t, e) {
+    this.removes.push(
+      this.platform.write({
+        options: e,
+        attributes: { properties: t },
+        target: this.target,
+        removable: this.clearOnDispose
+      })
+    );
+  }
+  writeContext(t, e) {
+    this.removes.push(
+      this.platform.write({
+        options: e,
+        attributes: { context: t },
+        target: this.target,
+        removable: this.clearOnDispose
+      })
+    );
+  }
+  writeLayout(t, e) {
+    this.removes.push(
+      this.platform.write({
+        options: e,
+        attributes: { layout: t },
+        target: this.target,
+        removable: this.clearOnDispose
+      })
+    );
+  }
+  dispose() {
+    this.removes.forEach((t) => {
+      t();
+    }), this.actions.dispose();
+  }
+}
+const _e = (n, t, e) => {
+  const s = n.concat(), i = (r, o, c) => {
+    let u = !0;
+    if (s.length) {
+      const h = s.shift(), a = (l, p) => (u = !1, i(l, Object.assign({}, o, p), c));
+      return Promise.resolve(h(r, a, c)).then((l) => ht(I({}, l), {
+        cancelled: u
+      }));
+    }
+    return Promise.resolve({ data: r, cancelled: !1, options: o });
+  };
+  return i(t, {}, e);
+};
+class tt {
+  constructor(t, e, s) {
+    this.platform = t, this.target = e, this.ns = s, this.subscriptions = [], this.create = this.create.bind(this);
+  }
+  create(t, e = () => {
+  }) {
+    const s = {
+      key: t,
+      fn: e,
+      target: this.target,
+      ns: this.ns
+    };
+    this.platform.actionsState.handlers.push(s);
+    const i = () => {
+      const r = this.platform.actionsState.handlers.indexOf(s);
+      r > -1 && this.platform.actionsState.handlers.splice(r, 1);
+    };
+    return this.subscriptions.push(i), i;
+  }
+  dispatch(t, e) {
+    const s = this.platform.nodes.all.concat(
+      this.platform.nodes.detached
+    ), i = {}, r = this.platform.actionsState.handlers.filter(
+      (o) => o.key === t && (!o.ns || !this.ns || o.ns === this.ns)
+    );
+    return Promise.all(
+      r.map((o) => {
+        const c = s.filter(
+          (h) => o.target.match(h) && this.target.match(h)
+        ), u = this.platform.actionsState.watchers.filter((h) => h.key === t && (!h.ns || !this.ns || h.ns === this.ns) && c.some((a) => h.target.match(a))).map((h) => h.fn);
+        return Promise.all(
+          c.map((h) => {
+            const a = new Mt(
+              this.platform,
+              h,
+              this.ns
+            );
+            return _e(u, e, a).then((l) => {
+              const { data: p = {}, options: d, cancelled: C } = l;
+              return Promise.resolve(
+                C ? {} : o.fn(p, d, a)
+              ).then((N) => {
+                i[h.id] = N;
+              });
+            });
+          })
+        );
+      })
+    ).then(() => i);
+  }
+  watch(t, e) {
+    let s = t, i = this.ns;
+    const r = t.split(".");
+    r.length > 1 && (i = r[0], s = r.splice(1).join("."));
+    const o = {
+      fn: e,
+      target: this.target,
+      key: s,
+      ns: i
+    };
+    this.platform.actionsState.watchers.push(o);
+    const c = () => {
+      const u = this.platform.actionsState.watchers.indexOf(o);
+      u > -1 && this.platform.actionsState.watchers.splice(u, 1);
+    };
+    return this.subscriptions.push(c), c;
+  }
+  dispose() {
+    this.subscriptions.forEach((t) => t());
+  }
+}
+const Ye = _t((n) => {
+  n.createCommand("components", (t) => (e) => {
+    t.events.subscribeOnce(
+      "components:platform-created",
+      (s, { platform: i }) => {
+        e.handlers && e.handlers.forEach(([r, o]) => {
+          i.addComponentHandler(r, o);
+        });
+      }
+    );
+  });
+}), T = (n, t, ...e) => typeof t == "string" ? n(`[humany] ${t}`, ...e) : n(t, ...e), R = class {
+  constructor() {
+    this.keys = [], this.log = (n, ...t) => this.lookup(n, () => R.log(...t)), this.warn = (n, ...t) => this.lookup(n, () => R.warn(...t)), this.error = (n, ...t) => this.lookup(n, () => R.error(...t)), this.info = (n, ...t) => this.lookup(n, () => R.info(...t));
+  }
+  lookup(n, t) {
+    this.keys.indexOf(n) === -1 && (this.keys.push(n), t());
+  }
+};
+let P = R;
+P.log = (...n) => T(console.log, ...n);
+P.warn = (...n) => T(console.warn, ...n);
+P.error = (...n) => T(console.error, ...n);
+P.info = (...n) => T(console.info, ...n);
+const k = () => Math.floor((1 + Math.random()) * 65536).toString(16).substring(1);
+function et() {
+  return k() + k() + "-" + k() + "-" + k() + "-" + k() + "-" + k() + k() + k();
+}
+class xt {
+  constructor(t, e) {
+    this.events = t, this.tags = [], this.children = {}, this.changesets = [], this.mountCount = 0, this.id = et(), this.type = e, this.attributes = {
+      context: {},
+      properties: {},
+      layout: {},
+      tags: []
+    }, this.writeLayout({ size: "full", indent: 0 });
+  }
+  mount(t, e) {
+    let s = t.get("mounted-nodes");
+    return s || (s = /* @__PURE__ */ new Map(), t.register("mounted-nodes", s)), s.has(this) ? (process.env.NODE_ENV !== "production" && P.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 })), () => {
+      s.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(t, e = "default") {
+    if (t.parent) {
+      if (t.parent === this)
+        return;
+      t.parent.removeChild(t);
+    }
+    t.parent = this, this.children[e] || (this.children[e] = []), this.children[e].push(t), this.events.dispatch("components:node-appended", { node: t });
+  }
+  prependChild(t, e = "default") {
+    if (t.parent) {
+      if (t.parent === this)
+        return;
+      t.parent.removeChild(t);
+    }
+    t.parent = this, this.children[e] || (this.children[e] = []), this.children[e].unshift(t), this.events.dispatch("components:node-appended", { node: t });
+  }
+  touchProperties(t, e = {}, s) {
+    const r = [{ properties: t }, e];
+    return this.changesets.push(r), this.events.dispatch("components:set-properties", { node: this }), () => {
+      if (s) {
+        const o = this.changesets.indexOf(r);
+        o > -1 && (this.changesets.splice(o, 1), this.events.dispatch("components:set-properties", { node: this }));
+      }
+    };
+  }
+  writeProperties(t, e = {}, s) {
+    const r = [{ properties: t }, e];
+    return this.changesets.push(r), this.events.dispatch("components:set-properties", { node: this }), () => {
+      if (s) {
+        const o = this.changesets.indexOf(r);
+        o > -1 && (this.changesets.splice(o, 1), this.events.dispatch("components:set-properties", { node: this }));
+      }
+    };
+  }
+  writeLayout(t, e = {}, s) {
+    const r = [{ layout: t }, e];
+    return this.changesets.push(r), this.events.dispatch("components:set-layout", { node: this }), () => {
+      if (!s)
+        return;
+      const o = this.changesets.indexOf(r);
+      o > -1 && (this.changesets.splice(o, 1), this.events.dispatch("components:set-layout", { node: this }));
+    };
+  }
+  writeContext(t, e = {}, s) {
+    const r = [{ context: t }, e];
+    return this.changesets.push(r), this.events.dispatch("components:set-context", { node: this }), () => {
+      if (!s)
+        return;
+      const o = this.changesets.indexOf(r);
+      o > -1 && (this.changesets.splice(o, 1), this.events.dispatch("components:set-context", { node: this }));
+    };
+  }
+  getChildren(t = "default") {
+    const e = this.children[t] || [];
+    return e.reduce((s, i, r) => {
+      const { order: o = r } = i.attributes.layout;
+      return s[o] ? s.splice(o, 0, i) : s[o] = i, s;
+    }, Array(e.length));
+  }
+  remove() {
+    this.parent && this.parent.removeChild(this);
+  }
+  removeChild(t) {
+    Object.keys(this.children).forEach((e) => {
+      const s = this.children[e], i = s.indexOf(t);
+      i > -1 && (s.splice(i, 1), this.events.dispatch("components:node-removed", {
+        node: t,
+        parentNode: this
+      }));
+    }), delete t.parent;
+  }
+}
+const zt = (n, t, e) => {
+  for (let s = 0, i = n.length; s < i && e(n[s]) !== !0; s++) {
+    const r = t[n[s].id] || "default", o = n[s].getChildren(r);
+    zt(o, t, e);
+  }
+}, st = (n, t, e) => {
+  if (e(n) !== !0) {
+    const s = t[n.id] || "default", i = n.children[s];
+    zt(i, t, e);
+  }
+}, B = (n, t) => {
+  const e = [];
+  return st(n, t, (s) => {
+    e.push(s);
+  }), e;
+}, Re = (n, t, e) => {
+  let s;
+  return st(n, t, (i) => {
+    if (e(i))
+      return s = i, !0;
+  }), s;
+};
+class De {
+  constructor(t, e, s) {
+    this.root = t, this.switches = e, this.all = [], this.visible = [], this.detached = [], s.subscribe(
+      "components:node-appended",
+      (i, r) => {
+        this.all.push(r.node), this.visible = B(t, e);
+      }
+    ), s.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 = B(t, e);
+      }
+    ), s.subscribe(
+      "components:node-switched",
+      (i, r) => {
+        this.visible = B(t, e);
+      }
+    );
+  }
+  query(t = {}) {
+    const e = [];
+    return st(this.root, this.switches, (s) => {
+      Object.keys(t).every((r) => t[r] === s[r]) && e.push(s);
+    }), e;
+  }
+  get(t) {
+    return Re(this.root, this.switches, (e) => e.id === t) || this.detached.find((e) => e.id === t);
+  }
+}
+class Ie {
+  constructor() {
+    this.handlers = /* @__PURE__ */ new Map();
+  }
+  add(t, e) {
+    this.handlers.set(t, e);
+  }
+  get(t) {
+    return this.handlers.get(t);
+  }
+}
+const Le = (n) => {
+  let t = n, e = 0;
+  for (; t.parent; )
+    e = e + 1, t = t.parent;
+  return e;
+}, Me = (n) => n.map(([e, s]) => [Le(e), e, s]).sort(([e], [s]) => e - s).map(([, e, s]) => [e, s]), Q = (n) => n instanceof Date ? !1 : n && typeof n == "object" && !Array.isArray(n), w = (n, ...t) => {
+  if (!t.length)
+    return n;
+  const e = t.shift();
+  if (Q(n) && Q(e))
+    for (const s in e)
+      Q(e[s]) ? (n[s] || Object.assign(n, { [s]: {} }), w(n[s], e[s])) : Object.assign(n, { [s]: e[s] });
+  return w(n, ...t);
+}, ze = (n, t) => !n || n === "all" ? !0 : n.some((e) => t.indexOf(e) > -1), Se = (n, t) => {
+  let e = [], s = [], i;
+  const r = () => {
+    process.env.NODE_ENV !== "production" && console.time("state-processor.flush");
+    const c = /* @__PURE__ */ new Map(), u = Me(e.map((a, l) => [a, s[l]])), h = (a, l) => {
+      var ot;
+      const p = c.get(a) || {}, d = l.context && !p.context, C = l.properties && !p.properties, N = l.layout && !p.layout;
+      c.set(a, {
+        context: p.context || d,
+        properties: p.properties || C,
+        layout: p.layout || N
+      }), C && (a.attributes.properties = {}), N && (a.attributes.layout = {}), d && (a.attributes.context = w({}, (ot = a.parent) == null ? void 0 : ot.attributes.context));
+      const nt = [], it = [], rt = [];
+      if (a.changesets.forEach((y) => {
+        const [f, V] = y;
+        ze(V.breakpoints, n.breakpoints) && (C && (typeof f.properties == "function" ? nt.push(
+          f.properties
+        ) : w(a.attributes.properties, f.properties)), N && (typeof f.layout == "function" ? it.push(f.layout) : w(a.attributes.layout, f.layout)), d && (typeof f.context == "function" ? rt.push(f.context) : w(a.attributes.context, f.context)));
+      }), nt.forEach((y) => {
+        w(a.attributes.properties, y(a.attributes.properties));
+      }), it.forEach((y) => {
+        w(a.attributes.layout, y(a.attributes.layout));
+      }), rt.forEach((y) => {
+        w(a.attributes.context, y(a.attributes.context));
+      }), d || l.recursive) {
+        const y = n.getBranch(a), f = l.recursive ? l : {
+          context: !!d
+        };
+        a.getChildren(y).forEach((V) => {
+          h(V, f);
+        });
+      }
+    };
+    process.env.NODE_ENV !== "production" && console.timeEnd("state-processor.flush"), u.forEach(([a, l]) => {
+      h(a, l);
+    }), e = [], s = [], t(c);
+  }, o = () => {
+    clearTimeout(i), i = setTimeout(r, 0);
+  };
+  return (c, u) => {
+    const h = e.indexOf(c);
+    if (h > -1) {
+      const a = s[h];
+      return u.context && (a.context = !0), u.properties && (a.properties = !0), u.layout && (a.layout = !0), u.recursive && (a.recursive = !0), o();
+    }
+    return e.push(c), s.push(u), o();
+  };
+};
+class Te {
+  constructor(t, e = {}) {
+    this.providers = e, this.breakpoints = [], this.actionsState = { handlers: [], watchers: [] }, this.switches = {}, this.changesets = [], this.subscriptions = [], this.customComponentHandler = new Ie(), this.events = t.events.createChild(this);
+    const s = new xt(this.events, "root");
+    s.name = `root-${t.name}`, this.nodes = new De(s, this.switches, this.events);
+    const i = this.processNode = Se(
+      this,
+      (r) => {
+        const o = Array.from(r.keys());
+        process.env.NODE_ENV !== "production" && console.info(`STATE PROCESSOR: ${o.length} node(s) processed:
+${o.map(
+          (c) => `${c.name || "<no name>"} (${c.id})
+`
+        )}`), o.forEach((c) => {
+          const u = r.get(c);
+          c.parent && c.parent.type === "root" && this.events.dispatch("components:root-children-changed", { node: c }), u != null && u.context && this.events.dispatch("components:context-changed", { node: c }), u != null && u.properties && this.events.dispatch("components:properties-changed", { node: c }), u != null && u.layout && this.events.dispatch("components:layout-changed", { node: c });
+        }), this.events.dispatch(
+          "components:component-model-initialized",
+          {},
+          { bubbles: !0 }
+        );
+      }
+    );
+    Promise.all(
+      Object.keys(e).map((r) => e[r].load(this))
+    ), this.subscriptions.push(
+      this.events.subscribe(
+        "components:node-appended",
+        (r, o) => {
+          const { node: c } = o;
+          this.changesets.forEach((u) => {
+            const { changeset: h, target: a, removes: l } = u, [p, d] = h;
+            a.match(o.node) && (p.properties && l.push(c.writeProperties(p.properties, d)), p.context && l.push(c.writeContext(p.context, d)), p.layout && l.push(c.writeLayout(p.layout, d)));
+          });
+        }
+      )
+    ), 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: c }) => {
+          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(t) {
+    return t.getAsync("components");
+  }
+  addBreakpoint(t) {
+    this.breakpoints.indexOf(t) === -1 && (this.breakpoints.push(t), this.processNode(this.nodes.root, {
+      context: !0,
+      properties: !0,
+      layout: !0,
+      recursive: !0
+    }));
+  }
+  removeBreakpoint(t) {
+    const e = this.breakpoints.indexOf(t);
+    e > -1 && (this.breakpoints.splice(e, 1), this.processNode(this.nodes.root, {
+      context: !0,
+      properties: !0,
+      layout: !0,
+      recursive: !0
+    }));
+  }
+  setSwitch(t, e) {
+    this.switches[t.id] = e, this.events.dispatch("components:node-switched", { node: t, branch: e });
+  }
+  getBranch(t) {
+    return this.switches[t.id];
+  }
+  /**
+   * Creates a `ComponentNode` of the specified type.
+   * @param type Type of node.
+   */
+  createNode(t, e = {}) {
+    const s = new xt(this.events, t);
+    return e.detached && this.nodes.detached.push(s), s;
+  }
+  components() {
+    return new Z(this);
+  }
+  actions(t, e) {
+    return new tt(this, t, e);
+  }
+  write(t) {
+    const {
+      provider: e,
+      target: s,
+      attributes: i,
+      options: r = {},
+      removable: o
+    } = t, c = t.key || et(), h = { changeset: [i, r], target: s, removes: [] };
+    if (e) {
+      const a = this.providers[e];
+      a.write(c, s, i, r), h.removes.push(() => {
+        a.remove(c);
+      });
+    }
+    return this.changesets.push(h), this.nodes.all.forEach((a) => {
+      if (s.match(a)) {
+        let l = () => {
+        };
+        i.properties && (l = a.writeProperties(
+          i.properties,
+          r,
+          o
+        )), i.context && (l = a.writeContext(i.context, r, o)), i.layout && (l = a.writeContext(i.layout, r, o)), h.removes.push(l);
+      }
+    }), () => {
+      if (o) {
+        h.removes.forEach((l) => l());
+        const a = this.changesets.indexOf(h);
+        a > -1 && this.changesets.splice(a, 1);
+      }
+    };
+  }
+  addComponentHandler(t, e) {
+    this.customComponentHandler.add(t, e);
+  }
+  getComponentHandler(t) {
+    return this.customComponentHandler.get(t);
+  }
+  dispose() {
+    this.subscriptions.forEach((t) => t());
+  }
+}
+const Ve = (n) => {
+  if (Array.isArray(n)) {
+    const [t, ...e] = n;
+    return {
+      definitionId: t,
+      overrides: e
+    };
+  }
+  return {
+    definitionId: n,
+    overrides: []
+  };
+}, Y = (n, t, e, s, i, r) => {
+  e.forEach((o) => {
+    const c = Ve(o), u = s[c.definitionId];
+    if (c.definitionId === "view") {
+      const h = n.createNode("view");
+      h.name = "view", Object.keys(i).forEach((a) => {
+        const l = i[a];
+        Y(n, h, [l.entry], s, i, a);
+      }), t.appendChild(h), c.overrides.forEach((a) => {
+        a.properties && h.writeProperties(a.properties, {
+          breakpoints: a.breakpoints
+        }), a.context && h.writeContext(a.context, { breakpoints: a.breakpoints }), a.layout && h.writeLayout(a.layout, { breakpoints: a.breakpoints });
+      });
+    } else if (n.getComponentHandler(u.type)) {
+      const h = n.getComponentHandler(u.type);
+      h && h(c, {
+        platform: n,
+        node: t,
+        references: e,
+        definitions: s,
+        views: i,
+        branch: r
+      });
+    } else {
+      const h = s[c.definitionId];
+      if (process.env.NODE_ENV !== "production" && !h) {
+        P.error(
+          `No definition found for component type '${c.definitionId}'.`
+        );
+        return;
+      }
+      const a = n.createNode(h.type);
+      a.name = c.definitionId, a.tags = h.tags || [], h.properties && a.writeProperties(h.properties), h.context && a.writeContext(h.context), h.layout && a.writeLayout(h.layout), t.appendChild(a, r), c.overrides.forEach((l) => {
+        const p = { breakpoints: l.breakpoints };
+        l.properties && a.writeProperties(l.properties, p), l.context && a.writeContext(l.context, p), l.layout && a.writeLayout(l.layout, p);
+      }), h.children && Y(n, a, h.children, s, i);
+    }
+  });
+}, Ue = (n, t) => {
+  const { entry: e, components: s, breakpoints: i, views: r } = t, o = [];
+  return Object.keys(i).forEach((c) => {
+    const u = i[c], h = window.matchMedia(u);
+    h.matches && n.breakpoints.push(c);
+    const a = (l) => {
+      l.matches ? n.addBreakpoint(c) : n.removeBreakpoint(c);
+    };
+    h.addListener(a), o.push(() => h.removeListener(a));
+  }), Y(n, n.nodes.root, [e], s, r), () => o.forEach((c) => {
+    c();
+  });
+}, Ge = (n, t) => ({
+  id: n.id,
+  type: n.type,
+  name: n.name,
+  branch: t || "default"
+}), Ke = (n, t, e, s = et(), i = {}) => n.getAsync("components").then((r) => {
+  let o;
+  if (typeof t == "string") {
+    const h = new Z(r);
+    h.ofType(t), o = h;
+  } else
+    o = t;
+  const c = {}, u = (h) => {
+    const a = c[h.id];
+    return a ? Promise.resolve(a.controller) : Te.getInstance(n).then((l) => new Mt(l, h, s));
+  };
+  r.events.subscribe(
+    "components:node-enter",
+    (h, { node: a }) => {
+      o.match(a) && u(a).then((l) => {
+        Promise.resolve(e(l)).then((p) => {
+          c[a.id] = {
+            dispose: p,
+            controller: l
+          };
+        });
+      });
+    }
+  ), r.events.subscribe(
+    "components:node-exit",
+    (h, { node: a }) => {
+      const l = c[a.id];
+      l && (l.dispose && l.dispose(), i.reuseController || (l.controller.dispose(), delete c[a.id]));
+    }
+  );
+});
+class Je {
+  constructor(t) {
+    this.aliases = /* @__PURE__ */ new Map(), this.components = /* @__PURE__ */ new Map(), this.logger = new P();
+    const { events: e } = t.get("$widget");
+    this.events = e;
+  }
+  getComponent(t) {
+    const e = this.aliases.get(t), s = this.components.get(e || t) || null;
+    return process.env.NODE_ENV !== "production" && (s || this.logger.warn(
+      e || t,
+      `Unable to resolve component: "${e || t}". You most likely forgot to register the required plugin for: ${e || t}.`
+    )), s;
+  }
+  registerComponent(t, e) {
+    return this.components.set(t, e), this.events.dispatch("component-resolver:resolve", t), () => {
+      this.components.delete(t);
+    };
+  }
+  registerResolver(t, e) {
+    return this.events.subscribe(
+      "component-resolver:resolve",
+      (s, i) => {
+        if (i === t) {
+          const r = this.getComponent(t);
+          e(r);
+        }
+      }
+    );
+  }
+  registerAlias(t, e) {
+    return this.aliases.set(t, e), this.events.dispatch("component-resolver:resolve", t), () => {
+      this.aliases.delete(t);
+    };
+  }
+}
+const je = "#____version____#", St = class Tt extends Lt {
+  constructor(t, e = []) {
+    super(t, e, {
+      transformPluginSettings: (s, i, r) => {
+        const o = r.get("$settings"), c = o.plugins && i ? o.plugins[i] || {} : {};
+        return I(I({}, c), s);
+      }
+    });
+  }
+  createImplementation(t) {
+    const e = super.createImplementation(t);
+    return e.bindings = t.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(t, e, s) {
+    this.widgets.query(t).forEach((i) => i.invoke("navigate", { route: e, params: s }));
+  }
+  /**
+   * Creates a runtime based on provided configuration.
+   * @param configuration Runtime configuration.
+   */
+  static create(t = {}) {
+    const e = [ne].concat(
+      t.configurationApiExtensions || []
+    );
+    return new Tt("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(t, e = {}) {
+    if (this.isRuntime(t))
+      return t.patch(e), t;
+    const s = [], i = t && t._c;
+    i && i.forEach(
+      (o) => s.push(o)
+    );
+    const r = this.create(e);
+    return r.container.register("$runtimecfg", s), r;
+  }
+  /**
+   * Determines whether the specified object is a valid widget runtime.
+   * @param obj Object to compare.
+   */
+  static isRuntime(t) {
+    return !!(t && typeof t == "object" && t.container && typeof t.container.get == "function" && t.container.get("$environment") === t && t.container.owner === t);
+  }
+};
+St.version = `${je} (${X})`;
+let Xe = St;
+class Ze extends Rt {
+  constructor() {
+    super(...arguments), this.bindings = [];
+  }
+}
+class ts extends ge {
+  constructor(t, e) {
+    super(t, e);
+  }
+}
+var qe = /* @__PURE__ */ ((n) => (n.open = "open", n.closed = "closed", n.hidden = "hidden", n))(qe || {});
+class es extends Ee {
+  constructor(t) {
+    super(t);
+  }
+}
+export {
+  He as ActionResolver,
+  tt as ActionsController,
+  xt as ComponentNode,
+  Mt as ComponentNodeController,
+  Te as ComponentPlatform,
+  Z as ComponentQuery,
+  Je as ComponentResolver,
+  Xe as Environment,
+  Ze as Implementation,
+  ts as Plugin,
+  qe as WidgetRenderState,
+  es as WidgetType,
+  Ge as asDescriptor,
+  Qe as bootstrap,
+  Ye as componentConfigurationApi,
+  Y as createChildren,
+  Ue as createComponentModel,
+  Ae as createEventSubscriber,
+  Ke as extendComponent,
+  Re as findComponent,
+  B as findVisibleComponents,
+  st as traverseComponents,
+  je as version
+};
+//# sourceMappingURL=index.js.map