@vonage/vivid 4.31.0 → 5.1.0

package/bundled/vivid-element.js

@@ -0,0 +1,1761 @@
+const v = function() {
+  if (typeof globalThis < "u")
+    return globalThis;
+  if (typeof global < "u")
+    return global;
+  if (typeof self < "u")
+    return self;
+  if (typeof window < "u")
+    return window;
+  try {
+    return new Function("return this")();
+  } catch {
+    return {};
+  }
+}();
+v.trustedTypes === void 0 && (v.trustedTypes = { createPolicy: (s, e) => e });
+const ee = {
+  configurable: !1,
+  enumerable: !1,
+  writable: !1
+};
+v.FAST === void 0 && Reflect.defineProperty(v, "FAST", Object.assign({ value: /* @__PURE__ */ Object.create(null) }, ee));
+const S = v.FAST;
+if (S.getById === void 0) {
+  const s = /* @__PURE__ */ Object.create(null);
+  Reflect.defineProperty(S, "getById", Object.assign({ value(e, t) {
+    let i = s[e];
+    return i === void 0 && (i = t ? s[e] = t() : null), i;
+  } }, ee));
+}
+const Ke = Object.freeze([]);
+function _() {
+  const s = /* @__PURE__ */ new WeakMap();
+  return function(e) {
+    let t = s.get(e);
+    if (t === void 0) {
+      let i = Reflect.getPrototypeOf(e);
+      for (; t === void 0 && i !== null; )
+        t = s.get(i), i = Reflect.getPrototypeOf(i);
+      t = t === void 0 ? [] : t.slice(0), s.set(e, t);
+    }
+    return t;
+  };
+}
+const N = v.FAST.getById(1, () => {
+  const s = [], e = [];
+  function t() {
+    if (e.length)
+      throw e.shift();
+  }
+  function i(o) {
+    try {
+      o.call();
+    } catch (a) {
+      e.push(a), setTimeout(t, 0);
+    }
+  }
+  function n() {
+    let a = 0;
+    for (; a < s.length; )
+      if (i(s[a]), a++, a > 1024) {
+        for (let c = 0, l = s.length - a; c < l; c++)
+          s[c] = s[c + a];
+        s.length -= a, a = 0;
+      }
+    s.length = 0;
+  }
+  function r(o) {
+    s.length < 1 && v.requestAnimationFrame(n), s.push(o);
+  }
+  return Object.freeze({
+    enqueue: r,
+    process: n
+  });
+}), te = v.trustedTypes.createPolicy("fast-html", {
+  createHTML: (s) => s
+});
+let k = te;
+const m = `fast-${Math.random().toString(36).substring(2, 8)}`, se = `${m}{`, R = `}${m}`, u = Object.freeze({
+  /**
+   * Indicates whether the DOM supports the adoptedStyleSheets feature.
+   */
+  supportsAdoptedStyleSheets: Array.isArray(document.adoptedStyleSheets) && "replace" in CSSStyleSheet.prototype,
+  /**
+   * Sets the HTML trusted types policy used by the templating engine.
+   * @param policy - The policy to set for HTML.
+   * @remarks
+   * This API can only be called once, for security reasons. It should be
+   * called by the application developer at the start of their program.
+   */
+  setHTMLPolicy(s) {
+    if (k !== te)
+      throw new Error("The HTML policy can only be set once.");
+    k = s;
+  },
+  /**
+   * Turns a string into trusted HTML using the configured trusted types policy.
+   * @param html - The string to turn into trusted HTML.
+   * @remarks
+   * Used internally by the template engine when creating templates
+   * and setting innerHTML.
+   */
+  createHTML(s) {
+    return k.createHTML(s);
+  },
+  /**
+   * Determines if the provided node is a template marker used by the runtime.
+   * @param node - The node to test.
+   */
+  isMarker(s) {
+    return s && s.nodeType === 8 && s.data.startsWith(m);
+  },
+  /**
+   * Given a marker node, extract the {@link HTMLDirective} index from the placeholder.
+   * @param node - The marker node to extract the index from.
+   */
+  extractDirectiveIndexFromMarker(s) {
+    return parseInt(s.data.replace(`${m}:`, ""));
+  },
+  /**
+   * Creates a placeholder string suitable for marking out a location *within*
+   * an attribute value or HTML content.
+   * @param index - The directive index to create the placeholder for.
+   * @remarks
+   * Used internally by binding directives.
+   */
+  createInterpolationPlaceholder(s) {
+    return `${se}${s}${R}`;
+  },
+  /**
+   * Creates a placeholder that manifests itself as an attribute on an
+   * element.
+   * @param attributeName - The name of the custom attribute.
+   * @param index - The directive index to create the placeholder for.
+   * @remarks
+   * Used internally by attribute directives such as `ref`, `slotted`, and `children`.
+   */
+  createCustomAttributePlaceholder(s, e) {
+    return `${s}="${this.createInterpolationPlaceholder(e)}"`;
+  },
+  /**
+   * Creates a placeholder that manifests itself as a marker within the DOM structure.
+   * @param index - The directive index to create the placeholder for.
+   * @remarks
+   * Used internally by structural directives such as `repeat`.
+   */
+  createBlockPlaceholder(s) {
+    return `<!--${m}:${s}-->`;
+  },
+  /**
+   * Schedules DOM update work in the next async batch.
+   * @param callable - The callable function or object to queue.
+   */
+  queueUpdate: N.enqueue,
+  /**
+   * Immediately processes all work previously scheduled
+   * through queueUpdate.
+   * @remarks
+   * This also forces nextUpdate promises
+   * to resolve.
+   */
+  processUpdates: N.process,
+  /**
+   * Resolves with the next DOM update.
+   */
+  nextUpdate() {
+    return new Promise(N.enqueue);
+  },
+  /**
+   * Sets an attribute value on an element.
+   * @param element - The element to set the attribute value on.
+   * @param attributeName - The attribute name to set.
+   * @param value - The value of the attribute to set.
+   * @remarks
+   * If the value is `null` or `undefined`, the attribute is removed, otherwise
+   * it is set to the provided value using the standard `setAttribute` API.
+   */
+  setAttribute(s, e, t) {
+    t == null ? s.removeAttribute(e) : s.setAttribute(e, t);
+  },
+  /**
+   * Sets a boolean attribute value.
+   * @param element - The element to set the boolean attribute value on.
+   * @param attributeName - The attribute name to set.
+   * @param value - The value of the attribute to set.
+   * @remarks
+   * If the value is true, the attribute is added; otherwise it is removed.
+   */
+  setBooleanAttribute(s, e, t) {
+    t ? s.setAttribute(e, "") : s.removeAttribute(e);
+  },
+  /**
+   * Removes all the child nodes of the provided parent node.
+   * @param parent - The node to remove the children from.
+   */
+  removeChildNodes(s) {
+    for (let e = s.firstChild; e !== null; e = s.firstChild)
+      s.removeChild(e);
+  },
+  /**
+   * Creates a TreeWalker configured to walk a template fragment.
+   * @param fragment - The fragment to walk.
+   */
+  createTemplateWalker(s) {
+    return document.createTreeWalker(
+      s,
+      133,
+      // element, text, comment
+      null,
+      !1
+    );
+  }
+});
+class I {
+  /**
+   * Creates an instance of SubscriberSet for the specified source.
+   * @param source - The object source that subscribers will receive notifications from.
+   * @param initialSubscriber - An initial subscriber to changes.
+   */
+  constructor(e, t) {
+    this.sub1 = void 0, this.sub2 = void 0, this.spillover = void 0, this.source = e, this.sub1 = t;
+  }
+  /**
+   * Checks whether the provided subscriber has been added to this set.
+   * @param subscriber - The subscriber to test for inclusion in this set.
+   */
+  has(e) {
+    return this.spillover === void 0 ? this.sub1 === e || this.sub2 === e : this.spillover.indexOf(e) !== -1;
+  }
+  /**
+   * Subscribes to notification of changes in an object's state.
+   * @param subscriber - The object that is subscribing for change notification.
+   */
+  subscribe(e) {
+    const t = this.spillover;
+    if (t === void 0) {
+      if (this.has(e))
+        return;
+      if (this.sub1 === void 0) {
+        this.sub1 = e;
+        return;
+      }
+      if (this.sub2 === void 0) {
+        this.sub2 = e;
+        return;
+      }
+      this.spillover = [this.sub1, this.sub2, e], this.sub1 = void 0, this.sub2 = void 0;
+    } else
+      t.indexOf(e) === -1 && t.push(e);
+  }
+  /**
+   * Unsubscribes from notification of changes in an object's state.
+   * @param subscriber - The object that is unsubscribing from change notification.
+   */
+  unsubscribe(e) {
+    const t = this.spillover;
+    if (t === void 0)
+      this.sub1 === e ? this.sub1 = void 0 : this.sub2 === e && (this.sub2 = void 0);
+    else {
+      const i = t.indexOf(e);
+      i !== -1 && t.splice(i, 1);
+    }
+  }
+  /**
+   * Notifies all subscribers.
+   * @param args - Data passed along to subscribers during notification.
+   */
+  notify(e) {
+    const t = this.spillover, i = this.source;
+    if (t === void 0) {
+      const n = this.sub1, r = this.sub2;
+      n !== void 0 && n.handleChange(i, e), r !== void 0 && r.handleChange(i, e);
+    } else
+      for (let n = 0, r = t.length; n < r; ++n)
+        t[n].handleChange(i, e);
+  }
+}
+class ie {
+  /**
+   * Creates an instance of PropertyChangeNotifier for the specified source.
+   * @param source - The object source that subscribers will receive notifications from.
+   */
+  constructor(e) {
+    this.subscribers = {}, this.sourceSubscribers = null, this.source = e;
+  }
+  /**
+   * Notifies all subscribers, based on the specified property.
+   * @param propertyName - The property name, passed along to subscribers during notification.
+   */
+  notify(e) {
+    var t;
+    const i = this.subscribers[e];
+    i !== void 0 && i.notify(e), (t = this.sourceSubscribers) === null || t === void 0 || t.notify(e);
+  }
+  /**
+   * Subscribes to notification of changes in an object's state.
+   * @param subscriber - The object that is subscribing for change notification.
+   * @param propertyToWatch - The name of the property that the subscriber is interested in watching for changes.
+   */
+  subscribe(e, t) {
+    var i;
+    if (t) {
+      let n = this.subscribers[t];
+      n === void 0 && (this.subscribers[t] = n = new I(this.source)), n.subscribe(e);
+    } else
+      this.sourceSubscribers = (i = this.sourceSubscribers) !== null && i !== void 0 ? i : new I(this.source), this.sourceSubscribers.subscribe(e);
+  }
+  /**
+   * Unsubscribes from notification of changes in an object's state.
+   * @param subscriber - The object that is unsubscribing from change notification.
+   * @param propertyToUnwatch - The name of the property that the subscriber is no longer interested in watching.
+   */
+  unsubscribe(e, t) {
+    var i;
+    if (t) {
+      const n = this.subscribers[t];
+      n !== void 0 && n.unsubscribe(e);
+    } else
+      (i = this.sourceSubscribers) === null || i === void 0 || i.unsubscribe(e);
+  }
+}
+const b = S.getById(2, () => {
+  const s = /(:|&&|\|\||if)/, e = /* @__PURE__ */ new WeakMap(), t = u.queueUpdate;
+  let i, n = (l) => {
+    throw new Error("Must call enableArrayObservation before observing arrays.");
+  };
+  function r(l) {
+    let h = l.$fastController || e.get(l);
+    return h === void 0 && (Array.isArray(l) ? h = n(l) : e.set(l, h = new ie(l))), h;
+  }
+  const o = _();
+  class a {
+    constructor(h) {
+      this.name = h, this.field = `_${h}`, this.callback = `${h}Changed`;
+    }
+    getValue(h) {
+      return i !== void 0 && i.watch(h, this.name), h[this.field];
+    }
+    setValue(h, d) {
+      const f = this.field, y = h[f];
+      if (y !== d) {
+        h[f] = d;
+        const p = h[this.callback];
+        typeof p == "function" && p.call(h, y, d), r(h).notify(this.name);
+      }
+    }
+  }
+  class c extends I {
+    constructor(h, d, f = !1) {
+      super(h, d), this.binding = h, this.isVolatileBinding = f, this.needsRefresh = !0, this.needsQueue = !0, this.first = this, this.last = null, this.propertySource = void 0, this.propertyName = void 0, this.notifier = void 0, this.next = void 0;
+    }
+    observe(h, d) {
+      this.needsRefresh && this.last !== null && this.disconnect();
+      const f = i;
+      i = this.needsRefresh ? this : void 0, this.needsRefresh = this.isVolatileBinding;
+      const y = this.binding(h, d);
+      return i = f, y;
+    }
+    disconnect() {
+      if (this.last !== null) {
+        let h = this.first;
+        for (; h !== void 0; )
+          h.notifier.unsubscribe(this, h.propertyName), h = h.next;
+        this.last = null, this.needsRefresh = this.needsQueue = !0;
+      }
+    }
+    watch(h, d) {
+      const f = this.last, y = r(h), p = f === null ? this.first : {};
+      if (p.propertySource = h, p.propertyName = d, p.notifier = y, y.subscribe(this, d), f !== null) {
+        if (!this.needsRefresh) {
+          let z;
+          i = void 0, z = f.propertySource[f.propertyName], i = this, h === z && (this.needsRefresh = !0);
+        }
+        f.next = p;
+      }
+      this.last = p;
+    }
+    handleChange() {
+      this.needsQueue && (this.needsQueue = !1, t(this));
+    }
+    call() {
+      this.last !== null && (this.needsQueue = !0, this.notify(this));
+    }
+    records() {
+      let h = this.first;
+      return {
+        next: () => {
+          const d = h;
+          return d === void 0 ? { value: void 0, done: !0 } : (h = h.next, {
+            value: d,
+            done: !1
+          });
+        },
+        [Symbol.iterator]: function() {
+          return this;
+        }
+      };
+    }
+  }
+  return Object.freeze({
+    /**
+     * @internal
+     * @param factory - The factory used to create array observers.
+     */
+    setArrayObserverFactory(l) {
+      n = l;
+    },
+    /**
+     * Gets a notifier for an object or Array.
+     * @param source - The object or Array to get the notifier for.
+     */
+    getNotifier: r,
+    /**
+     * Records a property change for a source object.
+     * @param source - The object to record the change against.
+     * @param propertyName - The property to track as changed.
+     */
+    track(l, h) {
+      i !== void 0 && i.watch(l, h);
+    },
+    /**
+     * Notifies watchers that the currently executing property getter or function is volatile
+     * with respect to its observable dependencies.
+     */
+    trackVolatile() {
+      i !== void 0 && (i.needsRefresh = !0);
+    },
+    /**
+     * Notifies subscribers of a source object of changes.
+     * @param source - the object to notify of changes.
+     * @param args - The change args to pass to subscribers.
+     */
+    notify(l, h) {
+      r(l).notify(h);
+    },
+    /**
+     * Defines an observable property on an object or prototype.
+     * @param target - The target object to define the observable on.
+     * @param nameOrAccessor - The name of the property to define as observable;
+     * or a custom accessor that specifies the property name and accessor implementation.
+     */
+    defineProperty(l, h) {
+      typeof h == "string" && (h = new a(h)), o(l).push(h), Reflect.defineProperty(l, h.name, {
+        enumerable: !0,
+        get: function() {
+          return h.getValue(this);
+        },
+        set: function(d) {
+          h.setValue(this, d);
+        }
+      });
+    },
+    /**
+     * Finds all the observable accessors defined on the target,
+     * including its prototype chain.
+     * @param target - The target object to search for accessor on.
+     */
+    getAccessors: o,
+    /**
+     * Creates a {@link BindingObserver} that can watch the
+     * provided {@link Binding} for changes.
+     * @param binding - The binding to observe.
+     * @param initialSubscriber - An initial subscriber to changes in the binding value.
+     * @param isVolatileBinding - Indicates whether the binding's dependency list must be re-evaluated on every value evaluation.
+     */
+    binding(l, h, d = this.isVolatileBinding(l)) {
+      return new c(l, h, d);
+    },
+    /**
+     * Determines whether a binding expression is volatile and needs to have its dependency list re-evaluated
+     * on every evaluation of the value.
+     * @param binding - The binding to inspect.
+     */
+    isVolatileBinding(l) {
+      return s.test(l.toString());
+    }
+  });
+});
+function Ge(s, e) {
+  b.defineProperty(s, e);
+}
+function Je(s, e, t) {
+  return Object.assign({}, t, {
+    get: function() {
+      return b.trackVolatile(), t.get.apply(this);
+    }
+  });
+}
+const q = S.getById(3, () => {
+  let s = null;
+  return {
+    get() {
+      return s;
+    },
+    set(e) {
+      s = e;
+    }
+  };
+});
+class C {
+  constructor() {
+    this.index = 0, this.length = 0, this.parent = null, this.parentContext = null;
+  }
+  /**
+   * The current event within an event handler.
+   */
+  get event() {
+    return q.get();
+  }
+  /**
+   * Indicates whether the current item within a repeat context
+   * has an even index.
+   */
+  get isEven() {
+    return this.index % 2 === 0;
+  }
+  /**
+   * Indicates whether the current item within a repeat context
+   * has an odd index.
+   */
+  get isOdd() {
+    return this.index % 2 !== 0;
+  }
+  /**
+   * Indicates whether the current item within a repeat context
+   * is the first item in the collection.
+   */
+  get isFirst() {
+    return this.index === 0;
+  }
+  /**
+   * Indicates whether the current item within a repeat context
+   * is somewhere in the middle of the collection.
+   */
+  get isInMiddle() {
+    return !this.isFirst && !this.isLast;
+  }
+  /**
+   * Indicates whether the current item within a repeat context
+   * is the last item in the collection.
+   */
+  get isLast() {
+    return this.index === this.length - 1;
+  }
+  /**
+   * Sets the event for the current execution context.
+   * @param event - The event to set.
+   * @internal
+   */
+  static setEvent(e) {
+    q.set(e);
+  }
+}
+b.defineProperty(C.prototype, "index");
+b.defineProperty(C.prototype, "length");
+const w = Object.seal(new C());
+class P {
+  constructor() {
+    this.targetIndex = 0;
+  }
+}
+class ne extends P {
+  constructor() {
+    super(...arguments), this.createPlaceholder = u.createInterpolationPlaceholder;
+  }
+}
+class Xe extends P {
+  /**
+   *
+   * @param name - The name of the behavior; used as a custom attribute on the element.
+   * @param behavior - The behavior to instantiate and attach to the element.
+   * @param options - Options to pass to the behavior during creation.
+   */
+  constructor(e, t, i) {
+    super(), this.name = e, this.behavior = t, this.options = i;
+  }
+  /**
+   * Creates a placeholder string based on the directive's index within the template.
+   * @param index - The index of the directive within the template.
+   * @remarks
+   * Creates a custom attribute placeholder.
+   */
+  createPlaceholder(e) {
+    return u.createCustomAttributePlaceholder(this.name, e);
+  }
+  /**
+   * Creates a behavior for the provided target node.
+   * @param target - The node instance to create the behavior for.
+   * @remarks
+   * Creates an instance of the `behavior` type this directive was constructed with
+   * and passes the target and options to that `behavior`'s constructor.
+   */
+  createBehavior(e) {
+    return new this.behavior(e, this.options);
+  }
+}
+function be(s, e) {
+  this.source = s, this.context = e, this.bindingObserver === null && (this.bindingObserver = b.binding(this.binding, this, this.isBindingVolatile)), this.updateTarget(this.bindingObserver.observe(s, e));
+}
+function pe(s, e) {
+  this.source = s, this.context = e, this.target.addEventListener(this.targetName, this);
+}
+function ge() {
+  this.bindingObserver.disconnect(), this.source = null, this.context = null;
+}
+function ve() {
+  this.bindingObserver.disconnect(), this.source = null, this.context = null;
+  const s = this.target.$fastView;
+  s !== void 0 && s.isComposed && (s.unbind(), s.needsBindOnly = !0);
+}
+function ye() {
+  this.target.removeEventListener(this.targetName, this), this.source = null, this.context = null;
+}
+function me(s) {
+  u.setAttribute(this.target, this.targetName, s);
+}
+function Se(s) {
+  u.setBooleanAttribute(this.target, this.targetName, s);
+}
+function Ce(s) {
+  if (s == null && (s = ""), s.create) {
+    this.target.textContent = "";
+    let e = this.target.$fastView;
+    e === void 0 ? e = s.create() : this.target.$fastTemplate !== s && (e.isComposed && (e.remove(), e.unbind()), e = s.create()), e.isComposed ? e.needsBindOnly && (e.needsBindOnly = !1, e.bind(this.source, this.context)) : (e.isComposed = !0, e.bind(this.source, this.context), e.insertBefore(this.target), this.target.$fastView = e, this.target.$fastTemplate = s);
+  } else {
+    const e = this.target.$fastView;
+    e !== void 0 && e.isComposed && (e.isComposed = !1, e.remove(), e.needsBindOnly ? e.needsBindOnly = !1 : e.unbind()), this.target.textContent = s;
+  }
+}
+function we(s) {
+  this.target[this.targetName] = s;
+}
+function xe(s) {
+  const e = this.classVersions || /* @__PURE__ */ Object.create(null), t = this.target;
+  let i = this.version || 0;
+  if (s != null && s.length) {
+    const n = s.split(/\s+/);
+    for (let r = 0, o = n.length; r < o; ++r) {
+      const a = n[r];
+      a !== "" && (e[a] = i, t.classList.add(a));
+    }
+  }
+  if (this.classVersions = e, this.version = i + 1, i !== 0) {
+    i -= 1;
+    for (const n in e)
+      e[n] === i && t.classList.remove(n);
+  }
+}
+class L extends ne {
+  /**
+   * Creates an instance of BindingDirective.
+   * @param binding - A binding that returns the data used to update the DOM.
+   */
+  constructor(e) {
+    super(), this.binding = e, this.bind = be, this.unbind = ge, this.updateTarget = me, this.isBindingVolatile = b.isVolatileBinding(this.binding);
+  }
+  /**
+   * Gets/sets the name of the attribute or property that this
+   * binding is targeting.
+   */
+  get targetName() {
+    return this.originalTargetName;
+  }
+  set targetName(e) {
+    if (this.originalTargetName = e, e !== void 0)
+      switch (e[0]) {
+        case ":":
+          if (this.cleanedTargetName = e.substr(1), this.updateTarget = we, this.cleanedTargetName === "innerHTML") {
+            const t = this.binding;
+            this.binding = (i, n) => u.createHTML(t(i, n));
+          }
+          break;
+        case "?":
+          this.cleanedTargetName = e.substr(1), this.updateTarget = Se;
+          break;
+        case "@":
+          this.cleanedTargetName = e.substr(1), this.bind = pe, this.unbind = ye;
+          break;
+        default:
+          this.cleanedTargetName = e, e === "class" && (this.updateTarget = xe);
+          break;
+      }
+  }
+  /**
+   * Makes this binding target the content of an element rather than
+   * a particular attribute or property.
+   */
+  targetAtContent() {
+    this.updateTarget = Ce, this.unbind = ve;
+  }
+  /**
+   * Creates the runtime BindingBehavior instance based on the configuration
+   * information stored in the BindingDirective.
+   * @param target - The target node that the binding behavior should attach to.
+   */
+  createBehavior(e) {
+    return new Te(e, this.binding, this.isBindingVolatile, this.bind, this.unbind, this.updateTarget, this.cleanedTargetName);
+  }
+}
+class Te {
+  /**
+   * Creates an instance of BindingBehavior.
+   * @param target - The target of the data updates.
+   * @param binding - The binding that returns the latest value for an update.
+   * @param isBindingVolatile - Indicates whether the binding has volatile dependencies.
+   * @param bind - The operation to perform during binding.
+   * @param unbind - The operation to perform during unbinding.
+   * @param updateTarget - The operation to perform when updating.
+   * @param targetName - The name of the target attribute or property to update.
+   */
+  constructor(e, t, i, n, r, o, a) {
+    this.source = null, this.context = null, this.bindingObserver = null, this.target = e, this.binding = t, this.isBindingVolatile = i, this.bind = n, this.unbind = r, this.updateTarget = o, this.targetName = a;
+  }
+  /** @internal */
+  handleChange() {
+    this.updateTarget(this.bindingObserver.observe(this.source, this.context));
+  }
+  /** @internal */
+  handleEvent(e) {
+    C.setEvent(e);
+    const t = this.binding(this.source, this.context);
+    C.setEvent(null), t !== !0 && e.preventDefault();
+  }
+}
+let F = null;
+class j {
+  addFactory(e) {
+    e.targetIndex = this.targetIndex, this.behaviorFactories.push(e);
+  }
+  captureContentBinding(e) {
+    e.targetAtContent(), this.addFactory(e);
+  }
+  reset() {
+    this.behaviorFactories = [], this.targetIndex = -1;
+  }
+  release() {
+    F = this;
+  }
+  static borrow(e) {
+    const t = F || new j();
+    return t.directives = e, t.reset(), F = null, t;
+  }
+}
+function Ae(s) {
+  if (s.length === 1)
+    return s[0];
+  let e;
+  const t = s.length, i = s.map((o) => typeof o == "string" ? () => o : (e = o.targetName || e, o.binding)), n = (o, a) => {
+    let c = "";
+    for (let l = 0; l < t; ++l)
+      c += i[l](o, a);
+    return c;
+  }, r = new L(n);
+  return r.targetName = e, r;
+}
+const Be = R.length;
+function re(s, e) {
+  const t = e.split(se);
+  if (t.length === 1)
+    return null;
+  const i = [];
+  for (let n = 0, r = t.length; n < r; ++n) {
+    const o = t[n], a = o.indexOf(R);
+    let c;
+    if (a === -1)
+      c = o;
+    else {
+      const l = parseInt(o.substring(0, a));
+      i.push(s.directives[l]), c = o.substring(a + Be);
+    }
+    c !== "" && i.push(c);
+  }
+  return i;
+}
+function U(s, e, t = !1) {
+  const i = e.attributes;
+  for (let n = 0, r = i.length; n < r; ++n) {
+    const o = i[n], a = o.value, c = re(s, a);
+    let l = null;
+    c === null ? t && (l = new L(() => a), l.targetName = o.name) : l = Ae(c), l !== null && (e.removeAttributeNode(o), n--, r--, s.addFactory(l));
+  }
+}
+function Ne(s, e, t) {
+  const i = re(s, e.textContent);
+  if (i !== null) {
+    let n = e;
+    for (let r = 0, o = i.length; r < o; ++r) {
+      const a = i[r], c = r === 0 ? e : n.parentNode.insertBefore(document.createTextNode(""), n.nextSibling);
+      typeof a == "string" ? c.textContent = a : (c.textContent = " ", s.captureContentBinding(a)), n = c, s.targetIndex++, c !== e && t.nextNode();
+    }
+    s.targetIndex--;
+  }
+}
+function ke(s, e) {
+  const t = s.content;
+  document.adoptNode(t);
+  const i = j.borrow(e);
+  U(i, s, !0);
+  const n = i.behaviorFactories;
+  i.reset();
+  const r = u.createTemplateWalker(t);
+  let o;
+  for (; o = r.nextNode(); )
+    switch (i.targetIndex++, o.nodeType) {
+      case 1:
+        U(i, o);
+        break;
+      case 3:
+        Ne(i, o, r);
+        break;
+      case 8:
+        u.isMarker(o) && i.addFactory(e[u.extractDirectiveIndexFromMarker(o)]);
+    }
+  let a = 0;
+  // If the first node in a fragment is a marker, that means it's an unstable first node,
+  // because something like a when, repeat, etc. could add nodes before the marker.
+  // To mitigate this, we insert a stable first node. However, if we insert a node,
+  // that will alter the result of the TreeWalker. So, we also need to offset the target index.
+  (u.isMarker(t.firstChild) || // Or if there is only one node and a directive, it means the template's content
+  // is *only* the directive. In that case, HTMLView.dispose() misses any nodes inserted by
+  // the directive. Inserting a new node ensures proper disposal of nodes added by the directive.
+  t.childNodes.length === 1 && e.length) && (t.insertBefore(document.createComment(""), t.firstChild), a = -1);
+  const c = i.behaviorFactories;
+  return i.release(), {
+    fragment: t,
+    viewBehaviorFactories: c,
+    hostBehaviorFactories: n,
+    targetOffset: a
+  };
+}
+const O = document.createRange();
+class Fe {
+  /**
+   * Constructs an instance of HTMLView.
+   * @param fragment - The html fragment that contains the nodes for this view.
+   * @param behaviors - The behaviors to be applied to this view.
+   */
+  constructor(e, t) {
+    this.fragment = e, this.behaviors = t, this.source = null, this.context = null, this.firstChild = e.firstChild, this.lastChild = e.lastChild;
+  }
+  /**
+   * Appends the view's DOM nodes to the referenced node.
+   * @param node - The parent node to append the view's DOM nodes to.
+   */
+  appendTo(e) {
+    e.appendChild(this.fragment);
+  }
+  /**
+   * Inserts the view's DOM nodes before the referenced node.
+   * @param node - The node to insert the view's DOM before.
+   */
+  insertBefore(e) {
+    if (this.fragment.hasChildNodes())
+      e.parentNode.insertBefore(this.fragment, e);
+    else {
+      const t = this.lastChild;
+      if (e.previousSibling === t)
+        return;
+      const i = e.parentNode;
+      let n = this.firstChild, r;
+      for (; n !== t; )
+        r = n.nextSibling, i.insertBefore(n, e), n = r;
+      i.insertBefore(t, e);
+    }
+  }
+  /**
+   * Removes the view's DOM nodes.
+   * The nodes are not disposed and the view can later be re-inserted.
+   */
+  remove() {
+    const e = this.fragment, t = this.lastChild;
+    let i = this.firstChild, n;
+    for (; i !== t; )
+      n = i.nextSibling, e.appendChild(i), i = n;
+    e.appendChild(t);
+  }
+  /**
+   * Removes the view and unbinds its behaviors, disposing of DOM nodes afterward.
+   * Once a view has been disposed, it cannot be inserted or bound again.
+   */
+  dispose() {
+    const e = this.firstChild.parentNode, t = this.lastChild;
+    let i = this.firstChild, n;
+    for (; i !== t; )
+      n = i.nextSibling, e.removeChild(i), i = n;
+    e.removeChild(t);
+    const r = this.behaviors, o = this.source;
+    for (let a = 0, c = r.length; a < c; ++a)
+      r[a].unbind(o);
+  }
+  /**
+   * Binds a view's behaviors to its binding source.
+   * @param source - The binding source for the view's binding behaviors.
+   * @param context - The execution context to run the behaviors within.
+   */
+  bind(e, t) {
+    const i = this.behaviors;
+    if (this.source !== e)
+      if (this.source !== null) {
+        const n = this.source;
+        this.source = e, this.context = t;
+        for (let r = 0, o = i.length; r < o; ++r) {
+          const a = i[r];
+          a.unbind(n), a.bind(e, t);
+        }
+      } else {
+        this.source = e, this.context = t;
+        for (let n = 0, r = i.length; n < r; ++n)
+          i[n].bind(e, t);
+      }
+  }
+  /**
+   * Unbinds a view's behaviors from its binding source.
+   */
+  unbind() {
+    if (this.source === null)
+      return;
+    const e = this.behaviors, t = this.source;
+    for (let i = 0, n = e.length; i < n; ++i)
+      e[i].unbind(t);
+    this.source = null;
+  }
+  /**
+   * Efficiently disposes of a contiguous range of synthetic view instances.
+   * @param views - A contiguous range of views to be disposed.
+   */
+  static disposeContiguousBatch(e) {
+    if (e.length !== 0) {
+      O.setStartBefore(e[0].firstChild), O.setEndAfter(e[e.length - 1].lastChild), O.deleteContents();
+      for (let t = 0, i = e.length; t < i; ++t) {
+        const n = e[t], r = n.behaviors, o = n.source;
+        for (let a = 0, c = r.length; a < c; ++a)
+          r[a].unbind(o);
+      }
+    }
+  }
+}
+class W {
+  /**
+   * Creates an instance of ViewTemplate.
+   * @param html - The html representing what this template will instantiate, including placeholders for directives.
+   * @param directives - The directives that will be connected to placeholders in the html.
+   */
+  constructor(e, t) {
+    this.behaviorCount = 0, this.hasHostBehaviors = !1, this.fragment = null, this.targetOffset = 0, this.viewBehaviorFactories = null, this.hostBehaviorFactories = null, this.html = e, this.directives = t;
+  }
+  /**
+   * Creates an HTMLView instance based on this template definition.
+   * @param hostBindingTarget - The element that host behaviors will be bound to.
+   */
+  create(e) {
+    if (this.fragment === null) {
+      let l;
+      const h = this.html;
+      if (typeof h == "string") {
+        l = document.createElement("template"), l.innerHTML = u.createHTML(h);
+        const f = l.content.firstElementChild;
+        f !== null && f.tagName === "TEMPLATE" && (l = f);
+      } else
+        l = h;
+      const d = ke(l, this.directives);
+      this.fragment = d.fragment, this.viewBehaviorFactories = d.viewBehaviorFactories, this.hostBehaviorFactories = d.hostBehaviorFactories, this.targetOffset = d.targetOffset, this.behaviorCount = this.viewBehaviorFactories.length + this.hostBehaviorFactories.length, this.hasHostBehaviors = this.hostBehaviorFactories.length > 0;
+    }
+    const t = this.fragment.cloneNode(!0), i = this.viewBehaviorFactories, n = new Array(this.behaviorCount), r = u.createTemplateWalker(t);
+    let o = 0, a = this.targetOffset, c = r.nextNode();
+    for (let l = i.length; o < l; ++o) {
+      const h = i[o], d = h.targetIndex;
+      for (; c !== null; )
+        if (a === d) {
+          n[o] = h.createBehavior(c);
+          break;
+        } else
+          c = r.nextNode(), a++;
+    }
+    if (this.hasHostBehaviors) {
+      const l = this.hostBehaviorFactories;
+      for (let h = 0, d = l.length; h < d; ++h, ++o)
+        n[o] = l[h].createBehavior(e);
+    }
+    return new Fe(t, n);
+  }
+  /**
+   * Creates an HTMLView from this template, binds it to the source, and then appends it to the host.
+   * @param source - The data source to bind the template to.
+   * @param host - The Element where the template will be rendered.
+   * @param hostBindingTarget - An HTML element to target the host bindings at if different from the
+   * host that the template is being attached to.
+   */
+  render(e, t, i) {
+    typeof t == "string" && (t = document.getElementById(t)), i === void 0 && (i = t);
+    const n = this.create(i);
+    return n.bind(e, w), n.appendTo(t), n;
+  }
+}
+const Oe = (
+  /* eslint-disable-next-line no-control-regex */
+  /([ \x09\x0a\x0c\x0d])([^\0-\x1F\x7F-\x9F "'>=/]+)([ \x09\x0a\x0c\x0d]*=[ \x09\x0a\x0c\x0d]*(?:[^ \x09\x0a\x0c\x0d"'`<>=]*|"[^"]*|'[^']*))$/
+);
+function Ye(s, ...e) {
+  const t = [];
+  let i = "";
+  for (let n = 0, r = s.length - 1; n < r; ++n) {
+    const o = s[n];
+    let a = e[n];
+    if (i += o, a instanceof W) {
+      const c = a;
+      a = () => c;
+    }
+    if (typeof a == "function" && (a = new L(a)), a instanceof ne) {
+      const c = Oe.exec(o);
+      c !== null && (a.targetName = c[2]);
+    }
+    a instanceof P ? (i += a.createPlaceholder(t.length), t.push(a)) : i += a;
+  }
+  return i += s[s.length - 1], new W(i, t);
+}
+class g {
+  constructor() {
+    this.targets = /* @__PURE__ */ new WeakSet();
+  }
+  /** @internal */
+  addStylesTo(e) {
+    this.targets.add(e);
+  }
+  /** @internal */
+  removeStylesFrom(e) {
+    this.targets.delete(e);
+  }
+  /** @internal */
+  isAttachedTo(e) {
+    return this.targets.has(e);
+  }
+  /**
+   * Associates behaviors with this set of styles.
+   * @param behaviors - The behaviors to associate.
+   */
+  withBehaviors(...e) {
+    return this.behaviors = this.behaviors === null ? e : this.behaviors.concat(e), this;
+  }
+}
+g.create = (() => {
+  if (u.supportsAdoptedStyleSheets) {
+    const s = /* @__PURE__ */ new Map();
+    return (e) => (
+      // eslint-disable-next-line @typescript-eslint/no-use-before-define
+      new Me(e, s)
+    );
+  }
+  return (s) => new Ve(s);
+})();
+function H(s) {
+  return s.map((e) => e instanceof g ? H(e.styles) : [e]).reduce((e, t) => e.concat(t), []);
+}
+function oe(s) {
+  return s.map((e) => e instanceof g ? e.behaviors : null).reduce((e, t) => t === null ? e : (e === null && (e = []), e.concat(t)), null);
+}
+const Ee = Symbol("prependToAdoptedStyleSheets");
+function ae(s) {
+  const e = [], t = [];
+  return s.forEach((i) => (i[Ee] ? e : t).push(i)), { prepend: e, append: t };
+}
+let le = (s, e) => {
+  const { prepend: t, append: i } = ae(e);
+  s.adoptedStyleSheets = [...t, ...s.adoptedStyleSheets, ...i];
+}, he = (s, e) => {
+  s.adoptedStyleSheets = s.adoptedStyleSheets.filter((t) => e.indexOf(t) === -1);
+};
+if (u.supportsAdoptedStyleSheets)
+  try {
+    document.adoptedStyleSheets.push(), document.adoptedStyleSheets.splice(), le = (s, e) => {
+      const { prepend: t, append: i } = ae(e);
+      s.adoptedStyleSheets.splice(0, 0, ...t), s.adoptedStyleSheets.push(...i);
+    }, he = (s, e) => {
+      for (const t of e) {
+        const i = s.adoptedStyleSheets.indexOf(t);
+        i !== -1 && s.adoptedStyleSheets.splice(i, 1);
+      }
+    };
+  } catch {
+  }
+class Me extends g {
+  constructor(e, t) {
+    super(), this.styles = e, this.styleSheetCache = t, this._styleSheets = void 0, this.behaviors = oe(e);
+  }
+  get styleSheets() {
+    if (this._styleSheets === void 0) {
+      const e = this.styles, t = this.styleSheetCache;
+      this._styleSheets = H(e).map((i) => {
+        if (i instanceof CSSStyleSheet)
+          return i;
+        let n = t.get(i);
+        return n === void 0 && (n = new CSSStyleSheet(), n.replaceSync(i), t.set(i, n)), n;
+      });
+    }
+    return this._styleSheets;
+  }
+  addStylesTo(e) {
+    le(e, this.styleSheets), super.addStylesTo(e);
+  }
+  removeStylesFrom(e) {
+    he(e, this.styleSheets), super.removeStylesFrom(e);
+  }
+}
+let Ie = 0;
+function $e() {
+  return `fast-style-class-${++Ie}`;
+}
+class Ve extends g {
+  constructor(e) {
+    super(), this.styles = e, this.behaviors = null, this.behaviors = oe(e), this.styleSheets = H(e), this.styleClass = $e();
+  }
+  addStylesTo(e) {
+    const t = this.styleSheets, i = this.styleClass;
+    e = this.normalizeTarget(e);
+    for (let n = 0; n < t.length; n++) {
+      const r = document.createElement("style");
+      r.innerHTML = t[n], r.className = i, e.append(r);
+    }
+    super.addStylesTo(e);
+  }
+  removeStylesFrom(e) {
+    e = this.normalizeTarget(e);
+    const t = e.querySelectorAll(`.${this.styleClass}`);
+    for (let i = 0, n = t.length; i < n; ++i)
+      e.removeChild(t[i]);
+    super.removeStylesFrom(e);
+  }
+  isAttachedTo(e) {
+    return super.isAttachedTo(this.normalizeTarget(e));
+  }
+  normalizeTarget(e) {
+    return e === document ? document.body : e;
+  }
+}
+const ce = Object.freeze({
+  /**
+   * Locates all attribute configurations associated with a type.
+   */
+  locate: _()
+}), _e = {
+  toView(s) {
+    return s ? "true" : "false";
+  },
+  fromView(s) {
+    return !(s == null || s === "false" || s === !1 || s === 0);
+  }
+}, Ze = {
+  toView(s) {
+    if (s == null)
+      return null;
+    const e = s * 1;
+    return isNaN(e) ? null : e.toString();
+  },
+  fromView(s) {
+    if (s == null)
+      return null;
+    const e = s * 1;
+    return isNaN(e) ? null : e;
+  }
+};
+class x {
+  /**
+   * Creates an instance of AttributeDefinition.
+   * @param Owner - The class constructor that owns this attribute.
+   * @param name - The name of the property associated with the attribute.
+   * @param attribute - The name of the attribute in HTML.
+   * @param mode - The {@link AttributeMode} that describes the behavior of this attribute.
+   * @param converter - A {@link ValueConverter} that integrates with the property getter/setter
+   * to convert values to and from a DOM string.
+   */
+  constructor(e, t, i = t.toLowerCase(), n = "reflect", r) {
+    this.guards = /* @__PURE__ */ new Set(), this.Owner = e, this.name = t, this.attribute = i, this.mode = n, this.converter = r, this.fieldName = `_${t}`, this.callbackName = `${t}Changed`, this.hasCallback = this.callbackName in e.prototype, n === "boolean" && r === void 0 && (this.converter = _e);
+  }
+  /**
+   * Sets the value of the attribute/property on the source element.
+   * @param source - The source element to access.
+   * @param value - The value to set the attribute/property to.
+   */
+  setValue(e, t) {
+    const i = e[this.fieldName], n = this.converter;
+    n !== void 0 && (t = n.fromView(t)), i !== t && (e[this.fieldName] = t, this.tryReflectToAttribute(e), this.hasCallback && e[this.callbackName](i, t), e.$fastController.notify(this.name));
+  }
+  /**
+   * Gets the value of the attribute/property on the source element.
+   * @param source - The source element to access.
+   */
+  getValue(e) {
+    return b.track(e, this.name), e[this.fieldName];
+  }
+  /** @internal */
+  onAttributeChangedCallback(e, t) {
+    this.guards.has(e) || (this.guards.add(e), this.setValue(e, t), this.guards.delete(e));
+  }
+  tryReflectToAttribute(e) {
+    const t = this.mode, i = this.guards;
+    i.has(e) || t === "fromView" || u.queueUpdate(() => {
+      i.add(e);
+      const n = e[this.fieldName];
+      switch (t) {
+        case "reflect":
+          const r = this.converter;
+          u.setAttribute(e, this.attribute, r !== void 0 ? r.toView(n) : n);
+          break;
+        case "boolean":
+          u.setBooleanAttribute(e, this.attribute, n);
+          break;
+      }
+      i.delete(e);
+    });
+  }
+  /**
+   * Collects all attribute definitions associated with the owner.
+   * @param Owner - The class constructor to collect attribute for.
+   * @param attributeLists - Any existing attributes to collect and merge with those associated with the owner.
+   * @internal
+   */
+  static collect(e, ...t) {
+    const i = [];
+    t.push(ce.locate(e));
+    for (let n = 0, r = t.length; n < r; ++n) {
+      const o = t[n];
+      if (o !== void 0)
+        for (let a = 0, c = o.length; a < c; ++a) {
+          const l = o[a];
+          typeof l == "string" ? i.push(new x(e, l)) : i.push(new x(e, l.property, l.attribute, l.mode, l.converter));
+        }
+    }
+    return i;
+  }
+}
+function Re(s, e) {
+  let t;
+  function i(n, r) {
+    arguments.length > 1 && (t.property = r), ce.locate(n.constructor).push(t);
+  }
+  if (arguments.length > 1) {
+    t = {}, i(s, e);
+    return;
+  }
+  return t = s === void 0 ? {} : s, i;
+}
+const Q = { mode: "open" }, K = {}, $ = S.getById(4, () => {
+  const s = /* @__PURE__ */ new Map();
+  return Object.freeze({
+    register(e) {
+      return s.has(e.type) ? !1 : (s.set(e.type, e), !0);
+    },
+    getByType(e) {
+      return s.get(e);
+    }
+  });
+});
+class B {
+  /**
+   * Creates an instance of FASTElementDefinition.
+   * @param type - The type this definition is being created for.
+   * @param nameOrConfig - The name of the element to define or a config object
+   * that describes the element to define.
+   */
+  constructor(e, t = e.definition) {
+    typeof t == "string" && (t = { name: t }), this.type = e, this.name = t.name, this.template = t.template;
+    const i = x.collect(e, t.attributes), n = new Array(i.length), r = {}, o = {};
+    for (let a = 0, c = i.length; a < c; ++a) {
+      const l = i[a];
+      n[a] = l.attribute, r[l.name] = l, o[l.attribute] = l;
+    }
+    this.attributes = i, this.observedAttributes = n, this.propertyLookup = r, this.attributeLookup = o, this.shadowOptions = t.shadowOptions === void 0 ? Q : t.shadowOptions === null ? void 0 : Object.assign(Object.assign({}, Q), t.shadowOptions), this.elementOptions = t.elementOptions === void 0 ? K : Object.assign(Object.assign({}, K), t.elementOptions), this.styles = t.styles === void 0 ? void 0 : Array.isArray(t.styles) ? g.create(t.styles) : t.styles instanceof g ? t.styles : g.create([t.styles]);
+  }
+  /**
+   * Indicates if this element has been defined in at least one registry.
+   */
+  get isDefined() {
+    return !!$.getByType(this.type);
+  }
+  /**
+   * Defines a custom element based on this definition.
+   * @param registry - The element registry to define the element in.
+   */
+  define(e = customElements) {
+    const t = this.type;
+    if ($.register(this)) {
+      const i = this.attributes, n = t.prototype;
+      for (let r = 0, o = i.length; r < o; ++r)
+        b.defineProperty(n, i[r]);
+      Reflect.defineProperty(t, "observedAttributes", {
+        value: this.observedAttributes,
+        enumerable: !0
+      });
+    }
+    return e.get(this.name) || e.define(this.name, t, this.elementOptions), this;
+  }
+}
+B.forType = $.getByType;
+const de = /* @__PURE__ */ new WeakMap(), Pe = {
+  bubbles: !0,
+  composed: !0,
+  cancelable: !0
+};
+function E(s) {
+  return s.shadowRoot || de.get(s) || null;
+}
+class D extends ie {
+  /**
+   * Creates a Controller to control the specified element.
+   * @param element - The element to be controlled by this controller.
+   * @param definition - The element definition metadata that instructs this
+   * controller in how to handle rendering and other platform integrations.
+   * @internal
+   */
+  constructor(e, t) {
+    super(e), this.boundObservables = null, this.behaviors = null, this.needsInitialization = !0, this._template = null, this._styles = null, this._isConnected = !1, this.$fastController = this, this.view = null, this.element = e, this.definition = t;
+    const i = t.shadowOptions;
+    if (i !== void 0) {
+      const r = e.attachShadow(i);
+      i.mode === "closed" && de.set(e, r);
+    }
+    const n = b.getAccessors(e);
+    if (n.length > 0) {
+      const r = this.boundObservables = /* @__PURE__ */ Object.create(null);
+      for (let o = 0, a = n.length; o < a; ++o) {
+        const c = n[o].name, l = e[c];
+        l !== void 0 && (delete e[c], r[c] = l);
+      }
+    }
+  }
+  /**
+   * Indicates whether or not the custom element has been
+   * connected to the document.
+   */
+  get isConnected() {
+    return b.track(this, "isConnected"), this._isConnected;
+  }
+  setIsConnected(e) {
+    this._isConnected = e, b.notify(this, "isConnected");
+  }
+  /**
+   * Gets/sets the template used to render the component.
+   * @remarks
+   * This value can only be accurately read after connect but can be set at any time.
+   */
+  get template() {
+    return this._template;
+  }
+  set template(e) {
+    this._template !== e && (this._template = e, this.needsInitialization || this.renderTemplate(e));
+  }
+  /**
+   * Gets/sets the primary styles used for the component.
+   * @remarks
+   * This value can only be accurately read after connect but can be set at any time.
+   */
+  get styles() {
+    return this._styles;
+  }
+  set styles(e) {
+    this._styles !== e && (this._styles !== null && this.removeStyles(this._styles), this._styles = e, !this.needsInitialization && e !== null && this.addStyles(e));
+  }
+  /**
+   * Adds styles to this element. Providing an HTMLStyleElement will attach the element instance to the shadowRoot.
+   * @param styles - The styles to add.
+   */
+  addStyles(e) {
+    const t = E(this.element) || this.element.getRootNode();
+    if (e instanceof HTMLStyleElement)
+      t.append(e);
+    else if (!e.isAttachedTo(t)) {
+      const i = e.behaviors;
+      e.addStylesTo(t), i !== null && this.addBehaviors(i);
+    }
+  }
+  /**
+   * Removes styles from this element. Providing an HTMLStyleElement will detach the element instance from the shadowRoot.
+   * @param styles - the styles to remove.
+   */
+  removeStyles(e) {
+    const t = E(this.element) || this.element.getRootNode();
+    if (e instanceof HTMLStyleElement)
+      t.removeChild(e);
+    else if (e.isAttachedTo(t)) {
+      const i = e.behaviors;
+      e.removeStylesFrom(t), i !== null && this.removeBehaviors(i);
+    }
+  }
+  /**
+   * Adds behaviors to this element.
+   * @param behaviors - The behaviors to add.
+   */
+  addBehaviors(e) {
+    const t = this.behaviors || (this.behaviors = /* @__PURE__ */ new Map()), i = e.length, n = [];
+    for (let r = 0; r < i; ++r) {
+      const o = e[r];
+      t.has(o) ? t.set(o, t.get(o) + 1) : (t.set(o, 1), n.push(o));
+    }
+    if (this._isConnected) {
+      const r = this.element;
+      for (let o = 0; o < n.length; ++o)
+        n[o].bind(r, w);
+    }
+  }
+  /**
+   * Removes behaviors from this element.
+   * @param behaviors - The behaviors to remove.
+   * @param force - Forces unbinding of behaviors.
+   */
+  removeBehaviors(e, t = !1) {
+    const i = this.behaviors;
+    if (i === null)
+      return;
+    const n = e.length, r = [];
+    for (let o = 0; o < n; ++o) {
+      const a = e[o];
+      if (i.has(a)) {
+        const c = i.get(a) - 1;
+        c === 0 || t ? i.delete(a) && r.push(a) : i.set(a, c);
+      }
+    }
+    if (this._isConnected) {
+      const o = this.element;
+      for (let a = 0; a < r.length; ++a)
+        r[a].unbind(o);
+    }
+  }
+  /**
+   * Runs connected lifecycle behavior on the associated element.
+   */
+  onConnectedCallback() {
+    if (this._isConnected)
+      return;
+    const e = this.element;
+    this.needsInitialization ? this.finishInitialization() : this.view !== null && this.view.bind(e, w);
+    const t = this.behaviors;
+    if (t !== null)
+      for (const [i] of t)
+        i.bind(e, w);
+    this.setIsConnected(!0);
+  }
+  /**
+   * Runs disconnected lifecycle behavior on the associated element.
+   */
+  onDisconnectedCallback() {
+    if (!this._isConnected)
+      return;
+    this.setIsConnected(!1);
+    const e = this.view;
+    e !== null && e.unbind();
+    const t = this.behaviors;
+    if (t !== null) {
+      const i = this.element;
+      for (const [n] of t)
+        n.unbind(i);
+    }
+  }
+  /**
+   * Runs the attribute changed callback for the associated element.
+   * @param name - The name of the attribute that changed.
+   * @param oldValue - The previous value of the attribute.
+   * @param newValue - The new value of the attribute.
+   */
+  onAttributeChangedCallback(e, t, i) {
+    const n = this.definition.attributeLookup[e];
+    n !== void 0 && n.onAttributeChangedCallback(this.element, i);
+  }
+  /**
+   * Emits a custom HTML event.
+   * @param type - The type name of the event.
+   * @param detail - The event detail object to send with the event.
+   * @param options - The event options. By default bubbles and composed.
+   * @remarks
+   * Only emits events if connected.
+   */
+  emit(e, t, i) {
+    return this._isConnected ? this.element.dispatchEvent(new CustomEvent(e, Object.assign(Object.assign({ detail: t }, Pe), i))) : !1;
+  }
+  finishInitialization() {
+    const e = this.element, t = this.boundObservables;
+    if (t !== null) {
+      const n = Object.keys(t);
+      for (let r = 0, o = n.length; r < o; ++r) {
+        const a = n[r];
+        e[a] = t[a];
+      }
+      this.boundObservables = null;
+    }
+    const i = this.definition;
+    this._template === null && (this.element.resolveTemplate ? this._template = this.element.resolveTemplate() : i.template && (this._template = i.template || null)), this._template !== null && this.renderTemplate(this._template), this._styles === null && (this.element.resolveStyles ? this._styles = this.element.resolveStyles() : i.styles && (this._styles = i.styles || null)), this._styles !== null && this.addStyles(this._styles), this.needsInitialization = !1;
+  }
+  renderTemplate(e) {
+    const t = this.element, i = E(t) || t;
+    this.view !== null ? (this.view.dispose(), this.view = null) : this.needsInitialization || u.removeChildNodes(i), e && (this.view = e.render(t, i, t));
+  }
+  /**
+   * Locates or creates a controller for the specified element.
+   * @param element - The element to return the controller for.
+   * @remarks
+   * The specified element must have a {@link FASTElementDefinition}
+   * registered either through the use of the {@link customElement}
+   * decorator or a call to `FASTElement.define`.
+   */
+  static forCustomElement(e) {
+    const t = e.$fastController;
+    if (t !== void 0)
+      return t;
+    const i = B.forType(e.constructor);
+    if (i === void 0)
+      throw new Error("Missing FASTElement definition.");
+    return e.$fastController = new D(e, i);
+  }
+}
+function G(s) {
+  return class extends s {
+    constructor() {
+      super(), D.forCustomElement(this);
+    }
+    $emit(e, t, i) {
+      return this.$fastController.emit(e, t, i);
+    }
+    connectedCallback() {
+      this.$fastController.onConnectedCallback();
+    }
+    disconnectedCallback() {
+      this.$fastController.onDisconnectedCallback();
+    }
+    attributeChangedCallback(e, t, i) {
+      this.$fastController.onAttributeChangedCallback(e, t, i);
+    }
+  };
+}
+const Le = Object.assign(G(HTMLElement), {
+  /**
+   * Creates a new FASTElement base class inherited from the
+   * provided base type.
+   * @param BaseType - The base element type to inherit from.
+   */
+  from(s) {
+    return G(s);
+  },
+  /**
+   * Defines a platform custom element based on the provided type and definition.
+   * @param type - The custom element type to define.
+   * @param nameOrDef - The name of the element to define or a definition object
+   * that describes the element to define.
+   */
+  define(s, e) {
+    return new B(s, e).define().type;
+  }
+});
+function je(s, e) {
+  return s instanceof Function ? s(e) : s;
+}
+const J = /* @__PURE__ */ new Set(), M = /* @__PURE__ */ new Map(), et = (s) => (e = "vwc") => {
+  const t = (n) => `${e}-${n}`, i = (n) => {
+    const r = t(n.name);
+    let o = n.type;
+    if (o.componentName = n.name, J.has(r))
+      return;
+    M.has(o) && M.get(o) !== r && (o = class extends o {
+    }), J.add(r), M.set(o, r);
+    for (const l of n.dependencies)
+      i(l);
+    const a = new Map([
+      [n.type, r],
+      ...n.dependencies.map(
+        (l) => [l.type, t(l.name)]
+      )
+    ]), c = {
+      tagFor(l) {
+        if (!a.has(l))
+          throw new Error(
+            `Could not get tag for ${l.name} as it is not a dependency of ${n.name}.`
+          );
+        return a.get(l);
+      },
+      tagForNonDependency(l) {
+        return t(l);
+      }
+    };
+    new B(o, {
+      ...n.options,
+      template: je(
+        n.template,
+        c
+      ),
+      name: `${e}-${n.name}`
+    }).define();
+  };
+  i(s);
+}, tt = (s, e, t, i, n) => ({
+  name: s,
+  type: e,
+  template: t,
+  dependencies: i,
+  options: n
+}), X = /* @__PURE__ */ new WeakMap(), T = (s) => {
+  let e = X.get(s);
+  return e || (e = [], X.set(s, e)), e;
+}, st = (s, e) => {
+  T(s).push(e);
+}, it = (s, e) => {
+  T(s).splice(T(s).indexOf(e), 1);
+}, He = (s, e) => {
+  T(s).forEach((t) => t(s, e));
+}, De = (s) => s === "delegate", Y = (s) => `vvd${s.charAt(0).toUpperCase()}${s.slice(1)}`, ue = (s, e) => {
+  if (De(s._vividAriaBehaviour)) {
+    const t = s[e];
+    s[`_${e}`] = null, s.removeAttribute(V(e)), s[`_${e}`] = t, s[e] !== null ? s.dataset[Y(e)] = s[e] : delete s.dataset[Y(e)];
+  } else
+    u.setAttribute(
+      s,
+      V(e),
+      s[e]
+    );
+}, A = /* @__PURE__ */ new WeakMap(), ze = (s, e) => {
+  const t = A.get(s);
+  t ? t.add(e) : A.set(s, /* @__PURE__ */ new Set([e]));
+}, qe = (s, e) => {
+  s.isConnected ? ue(s, e) : ze(s, e);
+}, Ue = (s) => {
+  const e = A.get(s);
+  if (e) {
+    for (const t of e)
+      ue(s, t);
+    A.delete(s);
+  }
+}, Z = [
+  "role",
+  "ariaAtomic",
+  "ariaAutoComplete",
+  "ariaBusy",
+  "ariaChecked",
+  "ariaColCount",
+  "ariaColIndex",
+  "ariaColIndexText",
+  "ariaColSpan",
+  "ariaCurrent",
+  "ariaDescription",
+  "ariaDisabled",
+  "ariaExpanded",
+  "ariaHasPopup",
+  "ariaHidden",
+  "ariaInvalid",
+  "ariaKeyShortcuts",
+  "ariaLabel",
+  "ariaLevel",
+  "ariaLive",
+  "ariaModal",
+  "ariaMultiLine",
+  "ariaMultiSelectable",
+  "ariaOrientation",
+  "ariaPlaceholder",
+  "ariaPosInSet",
+  "ariaPressed",
+  "ariaReadOnly",
+  "ariaRequired",
+  "ariaRoleDescription",
+  "ariaRowCount",
+  "ariaRowIndex",
+  "ariaRowIndexText",
+  "ariaRowSpan",
+  "ariaSelected",
+  "ariaSetSize",
+  "ariaSort",
+  "ariaValueMax",
+  "ariaValueMin",
+  "ariaValueNow",
+  "ariaValueText",
+  "ariaRelevant"
+  // Non-standard
+], V = (s) => s.replace("aria", "aria-").toLowerCase(), We = (s) => {
+  class e extends s {
+    constructor(...i) {
+      super(...i), this._vividAriaBehaviour = "default";
+      for (const n of Z)
+        this[`_${n}`] = null;
+    }
+    connectedCallback() {
+      super.connectedCallback(), Ue(this);
+    }
+  }
+  for (const t of Z)
+    Re({
+      attribute: V(t),
+      mode: "fromView"
+    })(e.prototype, t), e.prototype[`${t}Changed`] = function() {
+      qe(this, t), this._vividAriaBehaviour !== "default" && He(this, t);
+    };
+  return e;
+}, fe = _(), nt = (s) => (e, t) => {
+  fe(e.constructor).push({
+    newPropertyName: t,
+    ...s
+  });
+}, Qe = (s) => {
+  class e extends s {
+    #e(i) {
+      let n = !1, r = !1;
+      const o = (h) => r && i.fromDeprecated(
+        h[i.deprecatedPropertyName]
+      ) === h[i.newPropertyName], a = (h) => n && i.toDeprecated && i.toDeprecated(h[i.newPropertyName]) === h[i.deprecatedPropertyName], c = {
+        handleChange(h, d) {
+          if (d === i.newPropertyName) {
+            if (n = !0, !i.toDeprecated || o(h))
+              return;
+            h[i.deprecatedPropertyName] = i.toDeprecated(h[i.newPropertyName]);
+          }
+          if (d === i.deprecatedPropertyName) {
+            if (r = !0, a(h))
+              return;
+            h[i.newPropertyName] = i.fromDeprecated(
+              h[i.deprecatedPropertyName]
+            );
+          }
+        }
+      }, l = b.getNotifier(this);
+      l.subscribe(c, i.newPropertyName), l.subscribe(c, i.deprecatedPropertyName);
+    }
+    constructor(...i) {
+      super(...i);
+      for (const n of fe(this.constructor))
+        this.#e(n);
+    }
+  }
+  return e;
+};
+class rt extends We(Qe(Le)) {
+  static {
+    this.VIVID_VERSION = "5.1.0";
+  }
+  /**
+   * Add data-vvd-component attribute with component name globally,
+   * for referring to the elements in CSS, testing or debugging
+   */
+  connectedCallback() {
+    super.connectedCallback();
+    const e = this.constructor.componentName;
+    this.setAttribute("data-vvd-component", e);
+  }
+}
+export {
+  Xe as A,
+  u as D,
+  g as E,
+  P as H,
+  b as O,
+  I as S,
+  rt as V,
+  Re as a,
+  w as b,
+  et as c,
+  tt as d,
+  Ke as e,
+  V as f,
+  Z as g,
+  Ye as h,
+  Fe as i,
+  Ze as n,
+  Ge as o,
+  nt as r,
+  st as s,
+  it as u,
+  Je as v
+};