@fewangsit/wangsvue 1.5.219-alpha.1 → 1.5.219-alpha.2

package/vendor/rope-sequence/dist/index.es.js

@@ -1,100 +1,183 @@
-var l = 200, p = function() {
+var GOOD_LEAF_SIZE = 200;
+var RopeSequence = function RopeSequence2() {
 };
-p.prototype.append = function(t) {
-  return t.length ? (t = p.from(t), !this.length && t || t.length < l && this.leafAppend(t) || this.length < l && t.leafPrepend(this) || this.appendInner(t)) : this;
+RopeSequence.prototype.append = function append(other) {
+  if (!other.length) {
+    return this;
+  }
+  other = RopeSequence.from(other);
+  return !this.length && other || other.length < GOOD_LEAF_SIZE && this.leafAppend(other) || this.length < GOOD_LEAF_SIZE && other.leafPrepend(this) || this.appendInner(other);
 };
-p.prototype.prepend = function(t) {
-  return t.length ? p.from(t).append(this) : this;
+RopeSequence.prototype.prepend = function prepend(other) {
+  if (!other.length) {
+    return this;
+  }
+  return RopeSequence.from(other).append(this);
 };
-p.prototype.appendInner = function(t) {
-  return new u(this, t);
+RopeSequence.prototype.appendInner = function appendInner(other) {
+  return new Append(this, other);
 };
-p.prototype.slice = function(t, r) {
-  return t === void 0 && (t = 0), r === void 0 && (r = this.length), t >= r ? p.empty : this.sliceInner(Math.max(0, t), Math.min(this.length, r));
+RopeSequence.prototype.slice = function slice(from2, to) {
+  if (from2 === void 0) from2 = 0;
+  if (to === void 0) to = this.length;
+  if (from2 >= to) {
+    return RopeSequence.empty;
+  }
+  return this.sliceInner(Math.max(0, from2), Math.min(this.length, to));
 };
-p.prototype.get = function(t) {
-  if (!(t < 0 || t >= this.length))
-    return this.getInner(t);
+RopeSequence.prototype.get = function get(i) {
+  if (i < 0 || i >= this.length) {
+    return void 0;
+  }
+  return this.getInner(i);
 };
-p.prototype.forEach = function(t, r, e) {
-  r === void 0 && (r = 0), e === void 0 && (e = this.length), r <= e ? this.forEachInner(t, r, e, 0) : this.forEachInvertedInner(t, r, e, 0);
+RopeSequence.prototype.forEach = function forEach(f, from2, to) {
+  if (from2 === void 0) from2 = 0;
+  if (to === void 0) to = this.length;
+  if (from2 <= to) {
+    this.forEachInner(f, from2, to, 0);
+  } else {
+    this.forEachInvertedInner(f, from2, to, 0);
+  }
 };
-p.prototype.map = function(t, r, e) {
-  r === void 0 && (r = 0), e === void 0 && (e = this.length);
-  var n = [];
-  return this.forEach(function(i, s) {
-    return n.push(t(i, s));
-  }, r, e), n;
+RopeSequence.prototype.map = function map(f, from2, to) {
+  if (from2 === void 0) from2 = 0;
+  if (to === void 0) to = this.length;
+  var result = [];
+  this.forEach(function(elt, i) {
+    return result.push(f(elt, i));
+  }, from2, to);
+  return result;
 };
-p.from = function(t) {
-  return t instanceof p ? t : t && t.length ? new o(t) : p.empty;
+RopeSequence.from = function from(values) {
+  if (values instanceof RopeSequence) {
+    return values;
+  }
+  return values && values.length ? new Leaf(values) : RopeSequence.empty;
 };
-var o = /* @__PURE__ */ function(h) {
-  function t(e) {
-    h.call(this), this.values = e;
+var Leaf = /* @__PURE__ */ function(RopeSequence3) {
+  function Leaf2(values) {
+    RopeSequence3.call(this);
+    this.values = values;
   }
-  h && (t.__proto__ = h), t.prototype = Object.create(h && h.prototype), t.prototype.constructor = t;
-  var r = { length: { configurable: !0 }, depth: { configurable: !0 } };
-  return t.prototype.flatten = function() {
+  if (RopeSequence3) Leaf2.__proto__ = RopeSequence3;
+  Leaf2.prototype = Object.create(RopeSequence3 && RopeSequence3.prototype);
+  Leaf2.prototype.constructor = Leaf2;
+  var prototypeAccessors = { length: { configurable: true }, depth: { configurable: true } };
+  Leaf2.prototype.flatten = function flatten() {
     return this.values;
-  }, t.prototype.sliceInner = function(n, i) {
-    return n == 0 && i == this.length ? this : new t(this.values.slice(n, i));
-  }, t.prototype.getInner = function(n) {
-    return this.values[n];
-  }, t.prototype.forEachInner = function(n, i, s, f) {
-    for (var a = i; a < s; a++)
-      if (n(this.values[a], f + a) === !1)
-        return !1;
-  }, t.prototype.forEachInvertedInner = function(n, i, s, f) {
-    for (var a = i - 1; a >= s; a--)
-      if (n(this.values[a], f + a) === !1)
-        return !1;
-  }, t.prototype.leafAppend = function(n) {
-    if (this.length + n.length <= l)
-      return new t(this.values.concat(n.flatten()));
-  }, t.prototype.leafPrepend = function(n) {
-    if (this.length + n.length <= l)
-      return new t(n.flatten().concat(this.values));
-  }, r.length.get = function() {
+  };
+  Leaf2.prototype.sliceInner = function sliceInner(from2, to) {
+    if (from2 == 0 && to == this.length) {
+      return this;
+    }
+    return new Leaf2(this.values.slice(from2, to));
+  };
+  Leaf2.prototype.getInner = function getInner(i) {
+    return this.values[i];
+  };
+  Leaf2.prototype.forEachInner = function forEachInner(f, from2, to, start) {
+    for (var i = from2; i < to; i++) {
+      if (f(this.values[i], start + i) === false) {
+        return false;
+      }
+    }
+  };
+  Leaf2.prototype.forEachInvertedInner = function forEachInvertedInner(f, from2, to, start) {
+    for (var i = from2 - 1; i >= to; i--) {
+      if (f(this.values[i], start + i) === false) {
+        return false;
+      }
+    }
+  };
+  Leaf2.prototype.leafAppend = function leafAppend(other) {
+    if (this.length + other.length <= GOOD_LEAF_SIZE) {
+      return new Leaf2(this.values.concat(other.flatten()));
+    }
+  };
+  Leaf2.prototype.leafPrepend = function leafPrepend(other) {
+    if (this.length + other.length <= GOOD_LEAF_SIZE) {
+      return new Leaf2(other.flatten().concat(this.values));
+    }
+  };
+  prototypeAccessors.length.get = function() {
     return this.values.length;
-  }, r.depth.get = function() {
+  };
+  prototypeAccessors.depth.get = function() {
     return 0;
-  }, Object.defineProperties(t.prototype, r), t;
-}(p);
-p.empty = new o([]);
-var u = /* @__PURE__ */ function(h) {
-  function t(r, e) {
-    h.call(this), this.left = r, this.right = e, this.length = r.length + e.length, this.depth = Math.max(r.depth, e.depth) + 1;
+  };
+  Object.defineProperties(Leaf2.prototype, prototypeAccessors);
+  return Leaf2;
+}(RopeSequence);
+RopeSequence.empty = new Leaf([]);
+var Append = /* @__PURE__ */ function(RopeSequence3) {
+  function Append2(left, right) {
+    RopeSequence3.call(this);
+    this.left = left;
+    this.right = right;
+    this.length = left.length + right.length;
+    this.depth = Math.max(left.depth, right.depth) + 1;
   }
-  return h && (t.__proto__ = h), t.prototype = Object.create(h && h.prototype), t.prototype.constructor = t, t.prototype.flatten = function() {
+  if (RopeSequence3) Append2.__proto__ = RopeSequence3;
+  Append2.prototype = Object.create(RopeSequence3 && RopeSequence3.prototype);
+  Append2.prototype.constructor = Append2;
+  Append2.prototype.flatten = function flatten() {
     return this.left.flatten().concat(this.right.flatten());
-  }, t.prototype.getInner = function(e) {
-    return e < this.left.length ? this.left.get(e) : this.right.get(e - this.left.length);
-  }, t.prototype.forEachInner = function(e, n, i, s) {
-    var f = this.left.length;
-    if (n < f && this.left.forEachInner(e, n, Math.min(i, f), s) === !1 || i > f && this.right.forEachInner(e, Math.max(n - f, 0), Math.min(this.length, i) - f, s + f) === !1)
-      return !1;
-  }, t.prototype.forEachInvertedInner = function(e, n, i, s) {
-    var f = this.left.length;
-    if (n > f && this.right.forEachInvertedInner(e, n - f, Math.max(i, f) - f, s + f) === !1 || i < f && this.left.forEachInvertedInner(e, Math.min(n, f), i, s) === !1)
-      return !1;
-  }, t.prototype.sliceInner = function(e, n) {
-    if (e == 0 && n == this.length)
+  };
+  Append2.prototype.getInner = function getInner(i) {
+    return i < this.left.length ? this.left.get(i) : this.right.get(i - this.left.length);
+  };
+  Append2.prototype.forEachInner = function forEachInner(f, from2, to, start) {
+    var leftLen = this.left.length;
+    if (from2 < leftLen && this.left.forEachInner(f, from2, Math.min(to, leftLen), start) === false) {
+      return false;
+    }
+    if (to > leftLen && this.right.forEachInner(f, Math.max(from2 - leftLen, 0), Math.min(this.length, to) - leftLen, start + leftLen) === false) {
+      return false;
+    }
+  };
+  Append2.prototype.forEachInvertedInner = function forEachInvertedInner(f, from2, to, start) {
+    var leftLen = this.left.length;
+    if (from2 > leftLen && this.right.forEachInvertedInner(f, from2 - leftLen, Math.max(to, leftLen) - leftLen, start + leftLen) === false) {
+      return false;
+    }
+    if (to < leftLen && this.left.forEachInvertedInner(f, Math.min(from2, leftLen), to, start) === false) {
+      return false;
+    }
+  };
+  Append2.prototype.sliceInner = function sliceInner(from2, to) {
+    if (from2 == 0 && to == this.length) {
       return this;
-    var i = this.left.length;
-    return n <= i ? this.left.slice(e, n) : e >= i ? this.right.slice(e - i, n - i) : this.left.slice(e, i).append(this.right.slice(0, n - i));
-  }, t.prototype.leafAppend = function(e) {
-    var n = this.right.leafAppend(e);
-    if (n)
-      return new t(this.left, n);
-  }, t.prototype.leafPrepend = function(e) {
-    var n = this.left.leafPrepend(e);
-    if (n)
-      return new t(n, this.right);
-  }, t.prototype.appendInner = function(e) {
-    return this.left.depth >= Math.max(this.right.depth, e.depth) + 1 ? new t(this.left, new t(this.right, e)) : new t(this, e);
-  }, t;
-}(p);
+    }
+    var leftLen = this.left.length;
+    if (to <= leftLen) {
+      return this.left.slice(from2, to);
+    }
+    if (from2 >= leftLen) {
+      return this.right.slice(from2 - leftLen, to - leftLen);
+    }
+    return this.left.slice(from2, leftLen).append(this.right.slice(0, to - leftLen));
+  };
+  Append2.prototype.leafAppend = function leafAppend(other) {
+    var inner = this.right.leafAppend(other);
+    if (inner) {
+      return new Append2(this.left, inner);
+    }
+  };
+  Append2.prototype.leafPrepend = function leafPrepend(other) {
+    var inner = this.left.leafPrepend(other);
+    if (inner) {
+      return new Append2(inner, this.right);
+    }
+  };
+  Append2.prototype.appendInner = function appendInner2(other) {
+    if (this.left.depth >= Math.max(this.right.depth, other.depth) + 1) {
+      return new Append2(this.left, new Append2(this.right, other));
+    }
+    return new Append2(this, other);
+  };
+  return Append2;
+}(RopeSequence);
 export {
-  p as R
+  RopeSequence as R
 };