@vonage/vivid 5.1.0 → 5.3.0

package/bundled/repeat.js

@@ -1,341 +1,567 @@
-import { e as $, O as b, S as k, D as y, H as M, i as _ } from "./vivid-element.js";
-function p(i, e, t) {
-  return {
-    index: i,
-    removed: e,
-    addedCount: t
-  };
+import { O as y, l as $, U as H, e as O, M as E, m as S, p as q, q as D, t as x, H as P } from "./vivid-element.js";
+import { n as B } from "./normalize.js";
+class p {
+  /**
+   * Creates a splice.
+   * @param index - The index that the splice occurs at.
+   * @param removed - The items that were removed.
+   * @param addedCount - The  number of items that were added.
+   */
+  constructor(e, t, s) {
+    this.index = e, this.removed = t, this.addedCount = s;
+  }
+  /**
+   * Adjusts the splice index based on the provided array.
+   * @param array - The array to adjust to.
+   * @returns The same splice, mutated based on the reference array.
+   */
+  adjustTo(e) {
+    let t = this.index;
+    const s = e.length;
+    return t > s ? t = s - this.addedCount : t < 0 && (t = s + this.removed.length + t - this.addedCount), this.index = t < 0 ? 0 : t, this;
+  }
 }
-const j = 0, P = 1, O = 2, V = 3;
-function E(i, e, t, o, s, d) {
-  const c = d - s + 1, f = t - e + 1, n = new Array(c);
-  let r, h;
-  for (let l = 0; l < c; ++l)
-    n[l] = new Array(f), n[l][0] = l;
-  for (let l = 0; l < f; ++l)
-    n[0][l] = l;
-  for (let l = 1; l < c; ++l)
-    for (let u = 1; u < f; ++u)
-      i[e + u - 1] === o[s + l - 1] ? n[l][u] = n[l - 1][u - 1] : (r = n[l - 1][u] + 1, h = n[l][u - 1] + 1, n[l][u] = r < h ? r : h);
-  return n;
+class N {
+  /**
+   * Creates a sort update.
+   * @param sorted - The updated index of sorted items.
+   */
+  constructor(e) {
+    this.sorted = e;
+  }
 }
-function H(i) {
-  let e = i.length - 1, t = i[0].length - 1, o = i[e][t];
-  const s = [];
+const Q = Object.freeze({
+  /**
+   * Only supports resets.
+   */
+  reset: 1,
+  /**
+   * Supports tracking splices and resets.
+   */
+  splice: 2,
+  /**
+   * Supports tracking splices and resets, while applying some form
+   * of optimization, such as merging, to the splices.
+   */
+  optimized: 3
+}), z = new p(0, O, 0);
+z.reset = !0;
+const U = [z];
+function W(i, e, t, s, o, n) {
+  const l = n - o + 1, h = t - e + 1, d = new Array(l);
+  let a, c;
+  for (let r = 0; r < l; ++r)
+    d[r] = new Array(h), d[r][0] = r;
+  for (let r = 0; r < h; ++r)
+    d[0][r] = r;
+  for (let r = 1; r < l; ++r)
+    for (let u = 1; u < h; ++u)
+      i[e + u - 1] === s[o + r - 1] ? d[r][u] = d[r - 1][u - 1] : (a = d[r - 1][u] + 1, c = d[r][u - 1] + 1, d[r][u] = a < c ? a : c);
+  return d;
+}
+function F(i) {
+  let e = i.length - 1, t = i[0].length - 1, s = i[e][t];
+  const o = [];
   for (; e > 0 || t > 0; ) {
     if (e === 0) {
-      s.push(O), t--;
+      o.push(
+        2
+        /* Edit.add */
+      ), t--;
       continue;
     }
     if (t === 0) {
-      s.push(V), e--;
+      o.push(
+        3
+        /* Edit.delete */
+      ), e--;
       continue;
     }
-    const d = i[e - 1][t - 1], c = i[e - 1][t], f = i[e][t - 1];
-    let n;
-    c < f ? n = c < d ? c : d : n = f < d ? f : d, n === d ? (d === o ? s.push(j) : (s.push(P), o = d), e--, t--) : n === c ? (s.push(V), e--, o = c) : (s.push(O), t--, o = f);
+    const n = i[e - 1][t - 1], l = i[e - 1][t], h = i[e][t - 1];
+    let d;
+    l < h ? d = l < n ? l : n : d = h < n ? h : n, d === n ? (n === s ? o.push(
+      0
+      /* Edit.leave */
+    ) : (o.push(
+      1
+      /* Edit.update */
+    ), s = n), e--, t--) : d === l ? (o.push(
+      3
+      /* Edit.delete */
+    ), e--, s = l) : (o.push(
+      2
+      /* Edit.add */
+    ), t--, s = h);
   }
-  return s.reverse(), s;
+  return o.reverse();
 }
-function U(i, e, t) {
-  for (let o = 0; o < t; ++o)
-    if (i[o] !== e[o])
-      return o;
+function X(i, e, t) {
+  for (let s = 0; s < t; ++s)
+    if (i[s] !== e[s])
+      return s;
   return t;
 }
-function W(i, e, t) {
-  let o = i.length, s = e.length, d = 0;
-  for (; d < t && i[--o] === e[--s]; )
-    d++;
-  return d;
+function G(i, e, t) {
+  let s = i.length, o = e.length, n = 0;
+  for (; n < t && i[--s] === e[--o]; )
+    n++;
+  return n;
 }
-function q(i, e, t, o) {
-  return e < t || o < i ? -1 : e === t || o === i ? 0 : i < t ? e < o ? e - t : o - t : o < e ? o - i : e - i;
+function J(i, e, t, s) {
+  return e < t || s < i ? -1 : e === t || s === i ? 0 : i < t ? e < s ? e - t : s - t : s < e ? s - i : e - i;
 }
-function R(i, e, t, o, s, d) {
-  let c = 0, f = 0;
-  const n = Math.min(t - e, d - s);
-  if (e === 0 && s === 0 && (c = U(i, o, n)), t === i.length && d === o.length && (f = W(i, o, n - c)), e += c, s += c, t -= f, d -= f, t - e === 0 && d - s === 0)
-    return $;
+function K(i, e, t, s, o, n) {
+  let l = 0, h = 0;
+  const d = Math.min(t - e, n - o);
+  if (e === 0 && o === 0 && (l = X(i, s, d)), t === i.length && n === s.length && (h = G(i, s, d - l)), e += l, o += l, t -= h, n -= h, t - e === 0 && n - o === 0)
+    return O;
   if (e === t) {
-    const v = p(e, [], 0);
-    for (; s < d; )
-      v.removed.push(o[s++]);
+    const v = new p(e, [], 0);
+    for (; o < n; )
+      v.removed.push(s[o++]);
     return [v];
-  } else if (s === d)
-    return [p(e, [], t - e)];
-  const r = H(E(i, e, t, o, s, d)), h = [];
-  let l, u = e, a = s;
-  for (let v = 0; v < r.length; ++v)
-    switch (r[v]) {
-      case j:
-        l !== void 0 && (h.push(l), l = void 0), u++, a++;
+  } else if (o === n)
+    return [new p(e, [], t - e)];
+  const a = F(W(i, e, t, s, o, n)), c = [];
+  let r, u = e, f = o;
+  for (let v = 0; v < a.length; ++v)
+    switch (a[v]) {
+      case 0:
+        r !== void 0 && (c.push(r), r = void 0), u++, f++;
         break;
-      case P:
-        l === void 0 && (l = p(u, [], 0)), l.addedCount++, u++, l.removed.push(o[a]), a++;
+      case 1:
+        r === void 0 && (r = new p(u, [], 0)), r.addedCount++, u++, r.removed.push(s[f]), f++;
         break;
-      case O:
-        l === void 0 && (l = p(u, [], 0)), l.addedCount++, u++;
+      case 2:
+        r === void 0 && (r = new p(u, [], 0)), r.addedCount++, u++;
         break;
-      case V:
-        l === void 0 && (l = p(u, [], 0)), l.removed.push(o[a]), a++;
+      case 3:
+        r === void 0 && (r = new p(u, [], 0)), r.removed.push(s[f]), f++;
         break;
     }
-  return l !== void 0 && h.push(l), h;
+  return r !== void 0 && c.push(r), c;
 }
-const A = Array.prototype.push;
-function F(i, e, t, o) {
-  const s = p(e, t, o);
-  let d = !1, c = 0;
-  for (let f = 0; f < i.length; f++) {
-    const n = i[f];
-    if (n.index += c, d)
+function Y(i, e) {
+  let t = !1, s = 0;
+  for (let o = 0; o < e.length; o++) {
+    const n = e[o];
+    if (n.index += s, t)
       continue;
-    const r = q(s.index, s.index + s.removed.length, n.index, n.index + n.addedCount);
-    if (r >= 0) {
-      i.splice(f, 1), f--, c -= n.addedCount - n.removed.length, s.addedCount += n.addedCount - r;
-      const h = s.removed.length + n.removed.length - r;
-      if (!s.addedCount && !h)
-        d = !0;
+    const l = J(i.index, i.index + i.removed.length, n.index, n.index + n.addedCount);
+    if (l >= 0) {
+      e.splice(o, 1), o--, s -= n.addedCount - n.removed.length, i.addedCount += n.addedCount - l;
+      const h = i.removed.length + n.removed.length - l;
+      if (!i.addedCount && !h)
+        t = !0;
       else {
-        let l = n.removed;
-        if (s.index < n.index) {
-          const u = s.removed.slice(0, n.index - s.index);
-          A.apply(u, l), l = u;
+        let d = n.removed;
+        if (i.index < n.index) {
+          const a = i.removed.slice(0, n.index - i.index);
+          a.push(...d), d = a;
         }
-        if (s.index + s.removed.length > n.index + n.addedCount) {
-          const u = s.removed.slice(n.index + n.addedCount - s.index);
-          A.apply(l, u);
+        if (i.index + i.removed.length > n.index + n.addedCount) {
+          const a = i.removed.slice(n.index + n.addedCount - i.index);
+          d.push(...a);
         }
-        s.removed = l, n.index < s.index && (s.index = n.index);
+        i.removed = d, n.index < i.index && (i.index = n.index);
       }
-    } else if (s.index < n.index) {
-      d = !0, i.splice(f, 0, s), f++;
-      const h = s.addedCount - s.removed.length;
-      n.index += h, c += h;
+    } else if (i.index < n.index) {
+      t = !0, e.splice(o, 0, i), o++;
+      const h = i.addedCount - i.removed.length;
+      n.index += h, s += h;
     }
   }
-  d || i.push(s);
+  t || e.push(i);
 }
-function N(i) {
-  const e = [];
-  for (let t = 0, o = i.length; t < o; t++) {
-    const s = i[t];
-    F(e, s.index, s.removed, s.addedCount);
-  }
-  return e;
-}
-function z(i, e) {
+function Z(i, e) {
   let t = [];
-  const o = N(e);
-  for (let s = 0, d = o.length; s < d; ++s) {
-    const c = o[s];
-    if (c.addedCount === 1 && c.removed.length === 1) {
-      c.removed[0] !== i[c.index] && t.push(c);
+  const s = [];
+  for (let o = 0, n = e.length; o < n; o++)
+    Y(e[o], s);
+  for (let o = 0, n = s.length; o < n; ++o) {
+    const l = s[o];
+    if (l.addedCount === 1 && l.removed.length === 1) {
+      l.removed[0] !== i[l.index] && t.push(l);
       continue;
     }
-    t = t.concat(R(i, c.index, c.index + c.addedCount, c.removed, 0, c.removed.length));
+    t = t.concat(K(i, l.index, l.index + l.addedCount, l.removed, 0, l.removed.length));
   }
   return t;
 }
-let I = !1;
-function w(i, e) {
-  let t = i.index;
-  const o = e.length;
-  return t > o ? t = o - i.addedCount : t < 0 && (t = o + i.removed.length + t - i.addedCount), t < 0 && (t = 0), i.index = t, i;
+let I = Object.freeze({
+  support: Q.optimized,
+  normalize(i, e, t) {
+    return i === void 0 ? t === void 0 ? O : Z(e, t) : U;
+  },
+  pop(i, e, t, s) {
+    const o = i.length > 0, n = t.apply(i, s);
+    return o && e.addSplice(new p(i.length, [n], 0)), n;
+  },
+  push(i, e, t, s) {
+    const o = t.apply(i, s);
+    return e.addSplice(new p(i.length - s.length, [], s.length).adjustTo(i)), o;
+  },
+  reverse(i, e, t, s) {
+    const o = t.apply(i, s);
+    i.sorted++;
+    const n = [];
+    for (let l = i.length - 1; l >= 0; l--)
+      n.push(l);
+    return e.addSort(new N(n)), o;
+  },
+  shift(i, e, t, s) {
+    const o = i.length > 0, n = t.apply(i, s);
+    return o && e.addSplice(new p(0, [n], 0)), n;
+  },
+  sort(i, e, t, s) {
+    const o = /* @__PURE__ */ new Map();
+    for (let h = 0, d = i.length; h < d; ++h) {
+      const a = o.get(i[h]) || [];
+      o.set(i[h], [...a, h]);
+    }
+    const n = t.apply(i, s);
+    i.sorted++;
+    const l = [];
+    for (let h = 0, d = i.length; h < d; ++h) {
+      const a = o.get(i[h]);
+      l.push(a[0]), o.set(i[h], a.splice(1));
+    }
+    return e.addSort(new N(l)), n;
+  },
+  splice(i, e, t, s) {
+    const o = t.apply(i, s);
+    return e.addSplice(new p(+s[0], o, s.length > 2 ? s.length - 2 : 0).adjustTo(i)), o;
+  },
+  unshift(i, e, t, s) {
+    const o = t.apply(i, s);
+    return e.addSplice(new p(0, [], s.length).adjustTo(i)), o;
+  }
+});
+function C(i, e, t, s = !0) {
+  Reflect.defineProperty(i, e, {
+    value: t,
+    enumerable: !1,
+    writable: s
+  });
 }
-class G extends k {
+class ee extends $ {
   constructor(e) {
-    super(e), this.oldCollection = void 0, this.splices = void 0, this.needsQueue = !0, this.call = this.flush, Reflect.defineProperty(e, "$fastController", {
-      value: this,
-      enumerable: !1
-    });
+    super(e), this.oldCollection = void 0, this.splices = void 0, this.sorts = void 0, this.needsQueue = !0, this._strategy = null, this._lengthObserver = void 0, this._sortObserver = void 0, this.call = this.flush, C(e, "$fastController", this);
+  }
+  get strategy() {
+    return this._strategy;
+  }
+  set strategy(e) {
+    this._strategy = e;
+  }
+  get lengthObserver() {
+    let e = this._lengthObserver;
+    if (e === void 0) {
+      const t = this.subject;
+      this._lengthObserver = e = {
+        length: t.length,
+        handleChange() {
+          this.length !== t.length && (this.length = t.length, y.notify(e, "length"));
+        }
+      }, this.subscribe(e);
+    }
+    return e;
+  }
+  get sortObserver() {
+    let e = this._sortObserver;
+    if (e === void 0) {
+      const t = this.subject;
+      this._sortObserver = e = {
+        sorted: t.sorted,
+        handleChange() {
+          this.sorted !== t.sorted && (this.sorted = t.sorted, y.notify(e, "sorted"));
+        }
+      }, this.subscribe(e);
+    }
+    return e;
   }
   subscribe(e) {
     this.flush(), super.subscribe(e);
   }
   addSplice(e) {
-    this.splices === void 0 ? this.splices = [e] : this.splices.push(e), this.needsQueue && (this.needsQueue = !1, y.queueUpdate(this));
+    this.splices === void 0 ? this.splices = [e] : this.splices.push(e), this.enqueue();
+  }
+  addSort(e) {
+    this.sorts === void 0 ? this.sorts = [e] : this.sorts.push(e), this.enqueue();
   }
   reset(e) {
-    this.oldCollection = e, this.needsQueue && (this.needsQueue = !1, y.queueUpdate(this));
+    this.oldCollection = e, this.enqueue();
   }
   flush() {
-    const e = this.splices, t = this.oldCollection;
-    if (e === void 0 && t === void 0)
-      return;
-    this.needsQueue = !0, this.splices = void 0, this.oldCollection = void 0;
-    const o = t === void 0 ? z(this.source, e) : R(this.source, 0, this.source.length, t, 0, t.length);
-    this.notify(o);
+    var e;
+    const t = this.splices, s = this.sorts, o = this.oldCollection;
+    t === void 0 && o === void 0 && s === void 0 || (this.needsQueue = !0, this.splices = void 0, this.sorts = void 0, this.oldCollection = void 0, s !== void 0 ? this.notify(s) : this.notify(((e = this._strategy) !== null && e !== void 0 ? e : I).normalize(o, this.subject, t)));
+  }
+  enqueue() {
+    this.needsQueue && (this.needsQueue = !1, H.enqueue(this));
   }
 }
-function J() {
-  if (I)
-    return;
-  I = !0, b.setArrayObserverFactory((n) => new G(n));
-  const i = Array.prototype;
-  if (i.$fastPatch)
-    return;
-  Reflect.defineProperty(i, "$fastPatch", {
-    value: 1,
-    enumerable: !1
-  });
-  const e = i.pop, t = i.push, o = i.reverse, s = i.shift, d = i.sort, c = i.splice, f = i.unshift;
-  i.pop = function() {
-    const n = this.length > 0, r = e.apply(this, arguments), h = this.$fastController;
-    return h !== void 0 && n && h.addSplice(p(this.length, [r], 0)), r;
-  }, i.push = function() {
-    const n = t.apply(this, arguments), r = this.$fastController;
-    return r !== void 0 && r.addSplice(w(p(this.length - arguments.length, [], arguments.length), this)), n;
-  }, i.reverse = function() {
-    let n;
-    const r = this.$fastController;
-    r !== void 0 && (r.flush(), n = this.slice());
-    const h = o.apply(this, arguments);
-    return r !== void 0 && r.reset(n), h;
-  }, i.shift = function() {
-    const n = this.length > 0, r = s.apply(this, arguments), h = this.$fastController;
-    return h !== void 0 && n && h.addSplice(p(0, [r], 0)), r;
-  }, i.sort = function() {
-    let n;
-    const r = this.$fastController;
-    r !== void 0 && (r.flush(), n = this.slice());
-    const h = d.apply(this, arguments);
-    return r !== void 0 && r.reset(n), h;
-  }, i.splice = function() {
-    const n = c.apply(this, arguments), r = this.$fastController;
-    return r !== void 0 && r.addSplice(w(p(+arguments[0], n, arguments.length > 2 ? arguments.length - 2 : 0), this)), n;
-  }, i.unshift = function() {
-    const n = f.apply(this, arguments), r = this.$fastController;
-    return r !== void 0 && r.addSplice(w(p(0, [], arguments.length), this)), n;
-  };
-}
-const D = Object.freeze({
+let j = !1;
+const te = Object.freeze({
+  sorted: 0,
+  /**
+   * Enables the array observation mechanism.
+   * @remarks
+   * Array observation is enabled automatically when using the
+   * {@link RepeatDirective}, so calling this API manually is
+   * not typically necessary.
+   */
+  enable() {
+    if (j)
+      return;
+    j = !0, y.setArrayObserverFactory((e) => new ee(e));
+    const i = Array.prototype;
+    i.$fastPatch || (C(i, "$fastPatch", 1), C(i, "sorted", 0), [
+      i.pop,
+      i.push,
+      i.reverse,
+      i.shift,
+      i.sort,
+      i.splice,
+      i.unshift
+    ].forEach((e) => {
+      i[e.name] = function(...t) {
+        var s;
+        const o = this.$fastController;
+        return o === void 0 ? e.apply(this, t) : ((s = o.strategy) !== null && s !== void 0 ? s : I)[e.name](this, o, e, t);
+      };
+    }));
+  }
+}), M = Object.freeze({
   positioning: !1,
   recycle: !0
 });
-function K(i, e, t, o) {
-  i.bind(e[t], o);
+function ie(i, e, t, s) {
+  i.context.parent = s.source, i.context.parentContext = s.context, i.bind(e[t]);
 }
-function X(i, e, t, o) {
-  const s = Object.create(o);
-  s.index = t, s.length = e.length, i.bind(e[t], s);
+function se(i, e, t, s) {
+  i.context.parent = s.source, i.context.parentContext = s.context, i.context.length = e.length, i.context.index = t, i.bind(e[t]);
 }
-class Y {
+function R(i) {
+  return i.nodeType === Node.COMMENT_NODE;
+}
+class A extends Error {
+  constructor(e, t) {
+    super(e), this.propertyBag = t;
+  }
+}
+class ne {
   /**
    * Creates an instance of RepeatBehavior.
    * @param location - The location in the DOM to render the repeat.
-   * @param itemsBinding - The array to render.
+   * @param dataBinding - The array to render.
    * @param isItemsBindingVolatile - Indicates whether the items binding has volatile dependencies.
    * @param templateBinding - The template to render for each item.
    * @param isTemplateBindingVolatile - Indicates whether the template binding has volatile dependencies.
    * @param options - Options used to turn on special repeat features.
    */
-  constructor(e, t, o, s, d, c) {
-    this.location = e, this.itemsBinding = t, this.templateBinding = s, this.options = c, this.source = null, this.views = [], this.items = null, this.itemsObserver = null, this.originalContext = void 0, this.childContext = void 0, this.bindView = K, this.itemsBindingObserver = b.binding(t, this, o), this.templateBindingObserver = b.binding(s, this, d), c.positioning && (this.bindView = X);
+  constructor(e) {
+    this.directive = e, this.items = null, this.itemsObserver = null, this.bindView = ie, this.views = [], this.itemsBindingObserver = e.dataBinding.createObserver(this, e), this.templateBindingObserver = e.templateBinding.createObserver(this, e), e.options.positioning && (this.bindView = se);
   }
   /**
-   * Bind this behavior to the source.
-   * @param source - The source to bind to.
-   * @param context - The execution context that the binding is operating within.
+   * Bind this behavior.
+   * @param controller - The view controller that manages the lifecycle of this behavior.
    */
-  bind(e, t) {
-    this.source = e, this.originalContext = t, this.childContext = Object.create(t), this.childContext.parent = e, this.childContext.parentContext = this.originalContext, this.items = this.itemsBindingObserver.observe(e, this.originalContext), this.template = this.templateBindingObserver.observe(e, this.originalContext), this.observeItems(!0), this.refreshAllViews();
+  bind(e) {
+    this.location = e.targets[this.directive.targetNodeId], this.controller = e, this.items = this.itemsBindingObserver.bind(e), this.template = this.templateBindingObserver.bind(e), this.observeItems(!0), S(this.template) && S(e) && e.hydrationStage !== q.hydrated ? this.hydrateViews(this.template) : this.refreshAllViews(), e.onUnbind(this);
   }
   /**
-   * Unbinds this behavior from the source.
-   * @param source - The source to unbind from.
+   * Unbinds this behavior.
    */
   unbind() {
-    this.source = null, this.items = null, this.itemsObserver !== null && this.itemsObserver.unsubscribe(this), this.unbindAllViews(), this.itemsBindingObserver.disconnect(), this.templateBindingObserver.disconnect();
+    this.itemsObserver !== null && this.itemsObserver.unsubscribe(this), this.unbindAllViews();
   }
-  /** @internal */
+  /**
+   * Handles changes in the array, its items, and the repeat template.
+   * @param source - The source of the change.
+   * @param args - The details about what was changed.
+   */
   handleChange(e, t) {
-    e === this.itemsBinding ? (this.items = this.itemsBindingObserver.observe(this.source, this.originalContext), this.observeItems(), this.refreshAllViews()) : e === this.templateBinding ? (this.template = this.templateBindingObserver.observe(this.source, this.originalContext), this.refreshAllViews(!0)) : this.updateViews(t);
+    if (t === this.itemsBindingObserver)
+      this.items = this.itemsBindingObserver.bind(this.controller), this.observeItems(), this.refreshAllViews();
+    else if (t === this.templateBindingObserver)
+      this.template = this.templateBindingObserver.bind(this.controller), this.refreshAllViews(!0);
+    else if (t[0])
+      t[0].reset ? this.refreshAllViews() : t[0].sorted ? this.updateSortedViews(t) : this.updateSplicedViews(t);
+    else return;
   }
   observeItems(e = !1) {
     if (!this.items) {
-      this.items = $;
+      this.items = O;
       return;
     }
-    const t = this.itemsObserver, o = this.itemsObserver = b.getNotifier(this.items), s = t !== o;
-    s && t !== null && t.unsubscribe(this), (s || e) && o.subscribe(this);
-  }
-  updateViews(e) {
-    const t = this.childContext, o = this.views, s = this.bindView, d = this.items, c = this.template, f = this.options.recycle, n = [];
-    let r = 0, h = 0;
-    for (let l = 0, u = e.length; l < u; ++l) {
-      const a = e[l], v = a.removed;
-      let x = 0, m = a.index;
-      const T = m + a.addedCount, C = o.splice(a.index, v.length), L = h = n.length + C.length;
-      for (; m < T; ++m) {
-        const B = o[m], Q = B ? B.firstChild : this.location;
-        let g;
-        f && h > 0 ? (x <= L && C.length > 0 ? (g = C[x], x++) : (g = n[r], r++), h--) : g = c.create(), o.splice(m, 0, g), s(g, d, m, t), g.insertBefore(Q);
+    const t = this.itemsObserver, s = this.itemsObserver = y.getNotifier(this.items), o = t !== s;
+    o && t !== null && t.unsubscribe(this), (o || e) && s.subscribe(this);
+  }
+  updateSortedViews(e) {
+    const t = this.views;
+    for (let s = 0, o = e.length; s < o; ++s) {
+      const n = e[s].sorted.slice(), l = n.slice().sort();
+      for (let h = 0, d = n.length; h < d; ++h) {
+        const a = n.find((c) => n[h] === l[c]);
+        if (a !== h) {
+          const c = l.splice(a, 1);
+          l.splice(h, 0, ...c);
+          const r = t[h], u = r ? r.firstChild : this.location;
+          t[a].remove(), t[a].insertBefore(u);
+          const f = t.splice(a, 1);
+          t.splice(h, 0, ...f);
+        }
+      }
+    }
+  }
+  updateSplicedViews(e) {
+    const t = this.views, s = this.bindView, o = this.items, n = this.template, l = this.controller, h = this.directive.options.recycle, d = [];
+    let a = 0, c = 0;
+    for (let r = 0, u = e.length; r < u; ++r) {
+      const f = e[r], v = f.removed;
+      let b = 0, g = f.index;
+      const T = g + f.addedCount, w = t.splice(f.index, v.length), _ = c = d.length + w.length;
+      for (; g < T; ++g) {
+        const V = t[g], L = V ? V.firstChild : this.location;
+        let m;
+        h && c > 0 ? (b <= _ && w.length > 0 ? (m = w[b], b++) : (m = d[a], a++), c--) : m = n.create(), t.splice(g, 0, m), s(m, o, g, l), m.insertBefore(L);
       }
-      C[x] && n.push(...C.slice(x));
+      w[b] && d.push(...w.slice(b));
     }
-    for (let l = r, u = n.length; l < u; ++l)
-      n[l].dispose();
-    if (this.options.positioning)
-      for (let l = 0, u = o.length; l < u; ++l) {
-        const a = o[l].context;
-        a.length = u, a.index = l;
+    for (let r = a, u = d.length; r < u; ++r)
+      d[r].dispose();
+    if (this.directive.options.positioning)
+      for (let r = 0, u = t.length; r < u; ++r) {
+        const f = t[r].context;
+        f.length = u, f.index = r;
       }
   }
   refreshAllViews(e = !1) {
-    const t = this.items, o = this.childContext, s = this.template, d = this.location, c = this.bindView;
-    let f = t.length, n = this.views, r = n.length;
-    if ((f === 0 || e || !this.options.recycle) && (_.disposeContiguousBatch(n), r = 0), r === 0) {
-      this.views = n = new Array(f);
-      for (let h = 0; h < f; ++h) {
-        const l = s.create();
-        c(l, t, h, o), n[h] = l, l.insertBefore(d);
+    const t = this.items, s = this.template, o = this.location, n = this.bindView, l = this.controller;
+    let h = t.length, d = this.views, a = d.length;
+    if ((h === 0 || e || !this.directive.options.recycle) && (D.disposeContiguousBatch(d), a = 0), a === 0) {
+      this.views = d = new Array(h);
+      for (let c = 0; c < h; ++c) {
+        const r = s.create();
+        n(r, t, c, l), d[c] = r, r.insertBefore(o);
       }
     } else {
-      let h = 0;
-      for (; h < f; ++h)
-        if (h < r) {
-          const u = n[h];
-          c(u, t, h, o);
+      let c = 0;
+      for (; c < h; ++c)
+        if (c < a) {
+          const u = d[c];
+          if (!u) {
+            const f = new XMLSerializer();
+            throw new A(`View is null or undefined inside "${this.location.getRootNode().host.nodeName}".`, {
+              index: c,
+              hydrationStage: this.controller.hydrationStage,
+              itemsLength: h,
+              viewsState: d.map((v) => v ? "hydrated" : "empty"),
+              viewTemplateString: f.serializeToString(s.create().fragment),
+              rootNodeContent: f.serializeToString(this.location.getRootNode())
+            });
+          }
+          n(u, t, c, l);
         } else {
           const u = s.create();
-          c(u, t, h, o), n.push(u), u.insertBefore(d);
+          n(u, t, c, l), d.push(u), u.insertBefore(o);
         }
-      const l = n.splice(h, r - h);
-      for (h = 0, f = l.length; h < f; ++h)
-        l[h].dispose();
+      const r = d.splice(c, a - c);
+      for (c = 0, h = r.length; c < h; ++c)
+        r[c].dispose();
     }
   }
   unbindAllViews() {
     const e = this.views;
-    for (let t = 0, o = e.length; t < o; ++t)
-      e[t].unbind();
+    for (let t = 0, s = e.length; t < s; ++t) {
+      const o = e[t];
+      if (!o) {
+        const n = new XMLSerializer();
+        throw new A(`View is null or undefined inside "${this.location.getRootNode().host.nodeName}".`, {
+          index: t,
+          hydrationStage: this.controller.hydrationStage,
+          viewsState: e.map((l) => l ? "hydrated" : "empty"),
+          rootNodeContent: n.serializeToString(this.location.getRootNode())
+        });
+      }
+      o.unbind();
+    }
+  }
+  hydrateViews(e) {
+    if (!this.items)
+      return;
+    this.views = new Array(this.items.length);
+    let t = this.location.previousSibling;
+    for (; t !== null; ) {
+      if (!R(t)) {
+        t = t.previousSibling;
+        continue;
+      }
+      const s = x.parseRepeatEndMarker(t.data);
+      if (s === null) {
+        t = t.previousSibling;
+        continue;
+      }
+      t.data = "";
+      const o = t.previousSibling;
+      if (!o)
+        throw new Error(`Error when hydrating inside "${this.location.getRootNode().host.nodeName}": end should never be null.`);
+      let n = o, l = 0;
+      for (; n !== null; ) {
+        if (R(n)) {
+          if (x.isRepeatViewEndMarker(n.data))
+            l++;
+          else if (x.isRepeatViewStartMarker(n.data))
+            if (l)
+              l--;
+            else {
+              if (x.parseRepeatStartMarker(n.data) !== s)
+                throw new Error(`Error when hydrating inside "${this.location.getRootNode().host.nodeName}": Mismatched start and end markers.`);
+              n.data = "", t = n.previousSibling, n = n.nextSibling;
+              const h = e.hydrate(n, o);
+              this.views[s] = h, this.bindView(h, this.items, s, this.controller);
+              break;
+            }
+        }
+        n = n.previousSibling;
+      }
+      if (!n)
+        throw new Error(`Error when hydrating inside "${this.location.getRootNode().host.nodeName}": start should never be null.`);
+    }
   }
 }
-class Z extends M {
+class k {
   /**
    * Creates an instance of RepeatDirective.
-   * @param itemsBinding - The binding that provides the array to render.
+   * @param dataBinding - The binding that provides the array to render.
    * @param templateBinding - The template binding used to obtain a template to render for each item in the array.
    * @param options - Options used to turn on special repeat features.
    */
-  constructor(e, t, o) {
-    super(), this.itemsBinding = e, this.templateBinding = t, this.options = o, this.createPlaceholder = y.createBlockPlaceholder, J(), this.isItemsBindingVolatile = b.isVolatileBinding(e), this.isTemplateBindingVolatile = b.isVolatileBinding(t);
+  constructor(e, t, s) {
+    this.dataBinding = e, this.templateBinding = t, this.options = s, te.enable();
+  }
+  /**
+   * Creates a placeholder string based on the directive's index within the template.
+   * @param index - The index of the directive within the template.
+   */
+  createHTML(e) {
+    return E.comment(e(this));
   }
   /**
    * Creates a behavior for the provided target node.
    * @param target - The node instance to create the behavior for.
    */
-  createBehavior(e) {
-    return new Y(e, this.itemsBinding, this.isItemsBindingVolatile, this.templateBinding, this.isTemplateBindingVolatile, this.options);
+  createBehavior() {
+    return new ne(this);
   }
 }
-function ee(i, e, t = D) {
-  const o = typeof e == "function" ? e : () => e;
-  return new Z(i, o, Object.assign(Object.assign({}, D), t));
+P.define(k);
+function le(i, e, t = M) {
+  const s = B(i), o = B(e);
+  return new k(s, o, Object.assign(Object.assign({}, M), t));
 }
 export {
-  Z as R,
-  ee as r
+  k as R,
+  le as r
 };