976 lines
27 KiB
JavaScript
976 lines
27 KiB
JavaScript
|
var extendStatics = function(e, r) {
|
||
|
|
extendStatics = Object.setPrototypeOf || {
|
||
|
|
__proto__: []
|
||
|
|
} instanceof Array && function(e, r) {
|
||
|
|
e.__proto__ = r;
|
||
|
|
} || function(e, r) {
|
||
|
|
for (var t in r) if (Object.prototype.hasOwnProperty.call(r, t)) e[t] = r[t];
|
||
|
|
};
|
||
|
|
return extendStatics(e, r);
|
||
|
|
};
|
||
|
|
|
||
|
|
function __extends(e, r) {
|
||
|
|
if (typeof r !== "function" && r !== null) throw new TypeError("Class extends value " + String(r) + " is not a constructor or null");
|
||
|
|
extendStatics(e, r);
|
||
|
|
function __() {
|
||
|
|
this.constructor = e;
|
||
|
|
}
|
||
|
|
e.prototype = r === null ? Object.create(r) : (__.prototype = r.prototype, new __);
|
||
|
|
}
|
||
|
|
|
||
|
|
function __generator(e, r) {
|
||
|
|
var t = {
|
||
|
|
label: 0,
|
||
|
|
sent: function() {
|
||
|
|
if (s[0] & 1) throw s[1];
|
||
|
|
return s[1];
|
||
|
|
},
|
||
|
|
trys: [],
|
||
|
|
ops: []
|
||
|
|
}, i, n, s, h;
|
||
|
|
return h = {
|
||
|
|
next: verb(0),
|
||
|
|
throw: verb(1),
|
||
|
|
return: verb(2)
|
||
|
|
}, typeof Symbol === "function" && (h[Symbol.iterator] = function() {
|
||
|
|
return this;
|
||
|
|
}), h;
|
||
|
|
function verb(e) {
|
||
|
|
return function(r) {
|
||
|
|
return step([ e, r ]);
|
||
|
|
};
|
||
|
|
}
|
||
|
|
function step(a) {
|
||
|
|
if (i) throw new TypeError("Generator is already executing.");
|
||
|
|
while (h && (h = 0, a[0] && (t = 0)), t) try {
|
||
|
|
if (i = 1, n && (s = a[0] & 2 ? n["return"] : a[0] ? n["throw"] || ((s = n["return"]) && s.call(n),
|
||
|
|
0) : n.next) && !(s = s.call(n, a[1])).done) return s;
|
||
|
|
if (n = 0, s) a = [ a[0] & 2, s.value ];
|
||
|
|
switch (a[0]) {
|
||
|
|
case 0:
|
||
|
|
case 1:
|
||
|
|
s = a;
|
||
|
|
break;
|
||
|
|
|
||
|
|
case 4:
|
||
|
|
t.label++;
|
||
|
|
return {
|
||
|
|
value: a[1],
|
||
|
|
done: false
|
||
|
|
};
|
||
|
|
|
||
|
|
case 5:
|
||
|
|
t.label++;
|
||
|
|
n = a[1];
|
||
|
|
a = [ 0 ];
|
||
|
|
continue;
|
||
|
|
|
||
|
|
case 7:
|
||
|
|
a = t.ops.pop();
|
||
|
|
t.trys.pop();
|
||
|
|
continue;
|
||
|
|
|
||
|
|
default:
|
||
|
|
if (!(s = t.trys, s = s.length > 0 && s[s.length - 1]) && (a[0] === 6 || a[0] === 2)) {
|
||
|
|
t = 0;
|
||
|
|
continue;
|
||
|
|
}
|
||
|
|
if (a[0] === 3 && (!s || a[1] > s[0] && a[1] < s[3])) {
|
||
|
|
t.label = a[1];
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
if (a[0] === 6 && t.label < s[1]) {
|
||
|
|
t.label = s[1];
|
||
|
|
s = a;
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
if (s && t.label < s[2]) {
|
||
|
|
t.label = s[2];
|
||
|
|
t.ops.push(a);
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
if (s[2]) t.ops.pop();
|
||
|
|
t.trys.pop();
|
||
|
|
continue;
|
||
|
|
}
|
||
|
|
a = r.call(e, t);
|
||
|
|
} catch (e) {
|
||
|
|
a = [ 6, e ];
|
||
|
|
n = 0;
|
||
|
|
} finally {
|
||
|
|
i = s = 0;
|
||
|
|
}
|
||
|
|
if (a[0] & 5) throw a[1];
|
||
|
|
return {
|
||
|
|
value: a[0] ? a[1] : void 0,
|
||
|
|
done: true
|
||
|
|
};
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
typeof SuppressedError === "function" ? SuppressedError : function(e, r, t) {
|
||
|
|
var i = new Error(t);
|
||
|
|
return i.name = "SuppressedError", i.error = e, i.suppressed = r, i;
|
||
|
|
};
|
||
|
|
|
||
|
|
var TreeNode = function() {
|
||
|
|
function TreeNode(e, r, t) {
|
||
|
|
if (t === void 0) {
|
||
|
|
t = 1;
|
||
|
|
}
|
||
|
|
this.t = undefined;
|
||
|
|
this.i = undefined;
|
||
|
|
this.h = undefined;
|
||
|
|
this.u = e;
|
||
|
|
this.o = r;
|
||
|
|
this.l = t;
|
||
|
|
}
|
||
|
|
TreeNode.prototype.v = function() {
|
||
|
|
var e = this;
|
||
|
|
var r = e.h.h === e;
|
||
|
|
if (r && e.l === 1) {
|
||
|
|
e = e.i;
|
||
|
|
} else if (e.t) {
|
||
|
|
e = e.t;
|
||
|
|
while (e.i) {
|
||
|
|
e = e.i;
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
if (r) {
|
||
|
|
return e.h;
|
||
|
|
}
|
||
|
|
var t = e.h;
|
||
|
|
while (t.t === e) {
|
||
|
|
e = t;
|
||
|
|
t = e.h;
|
||
|
|
}
|
||
|
|
e = t;
|
||
|
|
}
|
||
|
|
return e;
|
||
|
|
};
|
||
|
|
TreeNode.prototype.p = function() {
|
||
|
|
var e = this;
|
||
|
|
if (e.i) {
|
||
|
|
e = e.i;
|
||
|
|
while (e.t) {
|
||
|
|
e = e.t;
|
||
|
|
}
|
||
|
|
return e;
|
||
|
|
} else {
|
||
|
|
var r = e.h;
|
||
|
|
while (r.i === e) {
|
||
|
|
e = r;
|
||
|
|
r = e.h;
|
||
|
|
}
|
||
|
|
if (e.i !== r) {
|
||
|
|
return r;
|
||
|
|
} else return e;
|
||
|
|
}
|
||
|
|
};
|
||
|
|
TreeNode.prototype.T = function() {
|
||
|
|
var e = this.h;
|
||
|
|
var r = this.i;
|
||
|
|
var t = r.t;
|
||
|
|
if (e.h === this) e.h = r; else if (e.t === this) e.t = r; else e.i = r;
|
||
|
|
r.h = e;
|
||
|
|
r.t = this;
|
||
|
|
this.h = r;
|
||
|
|
this.i = t;
|
||
|
|
if (t) t.h = this;
|
||
|
|
return r;
|
||
|
|
};
|
||
|
|
TreeNode.prototype.I = function() {
|
||
|
|
var e = this.h;
|
||
|
|
var r = this.t;
|
||
|
|
var t = r.i;
|
||
|
|
if (e.h === this) e.h = r; else if (e.t === this) e.t = r; else e.i = r;
|
||
|
|
r.h = e;
|
||
|
|
r.i = this;
|
||
|
|
this.h = r;
|
||
|
|
this.t = t;
|
||
|
|
if (t) t.h = this;
|
||
|
|
return r;
|
||
|
|
};
|
||
|
|
return TreeNode;
|
||
|
|
}();
|
||
|
|
|
||
|
|
var TreeNodeEnableIndex = function(e) {
|
||
|
|
__extends(TreeNodeEnableIndex, e);
|
||
|
|
function TreeNodeEnableIndex() {
|
||
|
|
var r = e !== null && e.apply(this, arguments) || this;
|
||
|
|
r.O = 1;
|
||
|
|
return r;
|
||
|
|
}
|
||
|
|
TreeNodeEnableIndex.prototype.T = function() {
|
||
|
|
var r = e.prototype.T.call(this);
|
||
|
|
this.M();
|
||
|
|
r.M();
|
||
|
|
return r;
|
||
|
|
};
|
||
|
|
TreeNodeEnableIndex.prototype.I = function() {
|
||
|
|
var r = e.prototype.I.call(this);
|
||
|
|
this.M();
|
||
|
|
r.M();
|
||
|
|
return r;
|
||
|
|
};
|
||
|
|
TreeNodeEnableIndex.prototype.M = function() {
|
||
|
|
this.O = 1;
|
||
|
|
if (this.t) {
|
||
|
|
this.O += this.t.O;
|
||
|
|
}
|
||
|
|
if (this.i) {
|
||
|
|
this.O += this.i.O;
|
||
|
|
}
|
||
|
|
};
|
||
|
|
return TreeNodeEnableIndex;
|
||
|
|
}(TreeNode);
|
||
|
|
|
||
|
|
var ContainerIterator = function() {
|
||
|
|
function ContainerIterator(e) {
|
||
|
|
if (e === void 0) {
|
||
|
|
e = 0;
|
||
|
|
}
|
||
|
|
this.iteratorType = e;
|
||
|
|
}
|
||
|
|
ContainerIterator.prototype.equals = function(e) {
|
||
|
|
return this.C === e.C;
|
||
|
|
};
|
||
|
|
return ContainerIterator;
|
||
|
|
}();
|
||
|
|
|
||
|
|
var Base = function() {
|
||
|
|
function Base() {
|
||
|
|
this._ = 0;
|
||
|
|
}
|
||
|
|
Object.defineProperty(Base.prototype, "length", {
|
||
|
|
get: function() {
|
||
|
|
return this._;
|
||
|
|
},
|
||
|
|
enumerable: false,
|
||
|
|
configurable: true
|
||
|
|
});
|
||
|
|
Base.prototype.size = function() {
|
||
|
|
return this._;
|
||
|
|
};
|
||
|
|
Base.prototype.empty = function() {
|
||
|
|
return this._ === 0;
|
||
|
|
};
|
||
|
|
return Base;
|
||
|
|
}();
|
||
|
|
|
||
|
|
var Container = function(e) {
|
||
|
|
__extends(Container, e);
|
||
|
|
function Container() {
|
||
|
|
return e !== null && e.apply(this, arguments) || this;
|
||
|
|
}
|
||
|
|
return Container;
|
||
|
|
}(Base);
|
||
|
|
|
||
|
|
function throwIteratorAccessError() {
|
||
|
|
throw new RangeError("Iterator access denied!");
|
||
|
|
}
|
||
|
|
|
||
|
|
var TreeContainer = function(e) {
|
||
|
|
__extends(TreeContainer, e);
|
||
|
|
function TreeContainer(r, t) {
|
||
|
|
if (r === void 0) {
|
||
|
|
r = function(e, r) {
|
||
|
|
if (e < r) return -1;
|
||
|
|
if (e > r) return 1;
|
||
|
|
return 0;
|
||
|
|
};
|
||
|
|
}
|
||
|
|
if (t === void 0) {
|
||
|
|
t = false;
|
||
|
|
}
|
||
|
|
var i = e.call(this) || this;
|
||
|
|
i.N = undefined;
|
||
|
|
i.g = r;
|
||
|
|
i.enableIndex = t;
|
||
|
|
i.S = t ? TreeNodeEnableIndex : TreeNode;
|
||
|
|
i.A = new i.S;
|
||
|
|
return i;
|
||
|
|
}
|
||
|
|
TreeContainer.prototype.m = function(e, r) {
|
||
|
|
var t = this.A;
|
||
|
|
while (e) {
|
||
|
|
var i = this.g(e.u, r);
|
||
|
|
if (i < 0) {
|
||
|
|
e = e.i;
|
||
|
|
} else if (i > 0) {
|
||
|
|
t = e;
|
||
|
|
e = e.t;
|
||
|
|
} else return e;
|
||
|
|
}
|
||
|
|
return t;
|
||
|
|
};
|
||
|
|
TreeContainer.prototype.B = function(e, r) {
|
||
|
|
var t = this.A;
|
||
|
|
while (e) {
|
||
|
|
var i = this.g(e.u, r);
|
||
|
|
if (i <= 0) {
|
||
|
|
e = e.i;
|
||
|
|
} else {
|
||
|
|
t = e;
|
||
|
|
e = e.t;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return t;
|
||
|
|
};
|
||
|
|
TreeContainer.prototype.j = function(e, r) {
|
||
|
|
var t = this.A;
|
||
|
|
while (e) {
|
||
|
|
var i = this.g(e.u, r);
|
||
|
|
if (i < 0) {
|
||
|
|
t = e;
|
||
|
|
e = e.i;
|
||
|
|
} else if (i > 0) {
|
||
|
|
e = e.t;
|
||
|
|
} else return e;
|
||
|
|
}
|
||
|
|
return t;
|
||
|
|
};
|
||
|
|
TreeContainer.prototype.k = function(e, r) {
|
||
|
|
var t = this.A;
|
||
|
|
while (e) {
|
||
|
|
var i = this.g(e.u, r);
|
||
|
|
if (i < 0) {
|
||
|
|
t = e;
|
||
|
|
e = e.i;
|
||
|
|
} else {
|
||
|
|
e = e.t;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return t;
|
||
|
|
};
|
||
|
|
TreeContainer.prototype.R = function(e) {
|
||
|
|
while (true) {
|
||
|
|
var r = e.h;
|
||
|
|
if (r === this.A) return;
|
||
|
|
if (e.l === 1) {
|
||
|
|
e.l = 0;
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
if (e === r.t) {
|
||
|
|
var t = r.i;
|
||
|
|
if (t.l === 1) {
|
||
|
|
t.l = 0;
|
||
|
|
r.l = 1;
|
||
|
|
if (r === this.N) {
|
||
|
|
this.N = r.T();
|
||
|
|
} else r.T();
|
||
|
|
} else {
|
||
|
|
if (t.i && t.i.l === 1) {
|
||
|
|
t.l = r.l;
|
||
|
|
r.l = 0;
|
||
|
|
t.i.l = 0;
|
||
|
|
if (r === this.N) {
|
||
|
|
this.N = r.T();
|
||
|
|
} else r.T();
|
||
|
|
return;
|
||
|
|
} else if (t.t && t.t.l === 1) {
|
||
|
|
t.l = 1;
|
||
|
|
t.t.l = 0;
|
||
|
|
t.I();
|
||
|
|
} else {
|
||
|
|
t.l = 1;
|
||
|
|
e = r;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
var t = r.t;
|
||
|
|
if (t.l === 1) {
|
||
|
|
t.l = 0;
|
||
|
|
r.l = 1;
|
||
|
|
if (r === this.N) {
|
||
|
|
this.N = r.I();
|
||
|
|
} else r.I();
|
||
|
|
} else {
|
||
|
|
if (t.t && t.t.l === 1) {
|
||
|
|
t.l = r.l;
|
||
|
|
r.l = 0;
|
||
|
|
t.t.l = 0;
|
||
|
|
if (r === this.N) {
|
||
|
|
this.N = r.I();
|
||
|
|
} else r.I();
|
||
|
|
return;
|
||
|
|
} else if (t.i && t.i.l === 1) {
|
||
|
|
t.l = 1;
|
||
|
|
t.i.l = 0;
|
||
|
|
t.T();
|
||
|
|
} else {
|
||
|
|
t.l = 1;
|
||
|
|
e = r;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
};
|
||
|
|
TreeContainer.prototype.G = function(e) {
|
||
|
|
if (this._ === 1) {
|
||
|
|
this.clear();
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
var r = e;
|
||
|
|
while (r.t || r.i) {
|
||
|
|
if (r.i) {
|
||
|
|
r = r.i;
|
||
|
|
while (r.t) r = r.t;
|
||
|
|
} else {
|
||
|
|
r = r.t;
|
||
|
|
}
|
||
|
|
var t = e.u;
|
||
|
|
e.u = r.u;
|
||
|
|
r.u = t;
|
||
|
|
var i = e.o;
|
||
|
|
e.o = r.o;
|
||
|
|
r.o = i;
|
||
|
|
e = r;
|
||
|
|
}
|
||
|
|
if (this.A.t === r) {
|
||
|
|
this.A.t = r.h;
|
||
|
|
} else if (this.A.i === r) {
|
||
|
|
this.A.i = r.h;
|
||
|
|
}
|
||
|
|
this.R(r);
|
||
|
|
var n = r.h;
|
||
|
|
if (r === n.t) {
|
||
|
|
n.t = undefined;
|
||
|
|
} else n.i = undefined;
|
||
|
|
this._ -= 1;
|
||
|
|
this.N.l = 0;
|
||
|
|
if (this.enableIndex) {
|
||
|
|
while (n !== this.A) {
|
||
|
|
n.O -= 1;
|
||
|
|
n = n.h;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
};
|
||
|
|
TreeContainer.prototype.P = function(e) {
|
||
|
|
var r = typeof e === "number" ? e : undefined;
|
||
|
|
var t = typeof e === "function" ? e : undefined;
|
||
|
|
var i = typeof e === "undefined" ? [] : undefined;
|
||
|
|
var n = 0;
|
||
|
|
var s = this.N;
|
||
|
|
var h = [];
|
||
|
|
while (h.length || s) {
|
||
|
|
if (s) {
|
||
|
|
h.push(s);
|
||
|
|
s = s.t;
|
||
|
|
} else {
|
||
|
|
s = h.pop();
|
||
|
|
if (n === r) return s;
|
||
|
|
i && i.push(s);
|
||
|
|
t && t(s, n, this);
|
||
|
|
n += 1;
|
||
|
|
s = s.i;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return i;
|
||
|
|
};
|
||
|
|
TreeContainer.prototype.q = function(e) {
|
||
|
|
while (true) {
|
||
|
|
var r = e.h;
|
||
|
|
if (r.l === 0) return;
|
||
|
|
var t = r.h;
|
||
|
|
if (r === t.t) {
|
||
|
|
var i = t.i;
|
||
|
|
if (i && i.l === 1) {
|
||
|
|
i.l = r.l = 0;
|
||
|
|
if (t === this.N) return;
|
||
|
|
t.l = 1;
|
||
|
|
e = t;
|
||
|
|
continue;
|
||
|
|
} else if (e === r.i) {
|
||
|
|
e.l = 0;
|
||
|
|
if (e.t) {
|
||
|
|
e.t.h = r;
|
||
|
|
}
|
||
|
|
if (e.i) {
|
||
|
|
e.i.h = t;
|
||
|
|
}
|
||
|
|
r.i = e.t;
|
||
|
|
t.t = e.i;
|
||
|
|
e.t = r;
|
||
|
|
e.i = t;
|
||
|
|
if (t === this.N) {
|
||
|
|
this.N = e;
|
||
|
|
this.A.h = e;
|
||
|
|
} else {
|
||
|
|
var n = t.h;
|
||
|
|
if (n.t === t) {
|
||
|
|
n.t = e;
|
||
|
|
} else n.i = e;
|
||
|
|
}
|
||
|
|
e.h = t.h;
|
||
|
|
r.h = e;
|
||
|
|
t.h = e;
|
||
|
|
t.l = 1;
|
||
|
|
} else {
|
||
|
|
r.l = 0;
|
||
|
|
if (t === this.N) {
|
||
|
|
this.N = t.I();
|
||
|
|
} else t.I();
|
||
|
|
t.l = 1;
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
var i = t.t;
|
||
|
|
if (i && i.l === 1) {
|
||
|
|
i.l = r.l = 0;
|
||
|
|
if (t === this.N) return;
|
||
|
|
t.l = 1;
|
||
|
|
e = t;
|
||
|
|
continue;
|
||
|
|
} else if (e === r.t) {
|
||
|
|
e.l = 0;
|
||
|
|
if (e.t) {
|
||
|
|
e.t.h = t;
|
||
|
|
}
|
||
|
|
if (e.i) {
|
||
|
|
e.i.h = r;
|
||
|
|
}
|
||
|
|
t.i = e.t;
|
||
|
|
r.t = e.i;
|
||
|
|
e.t = t;
|
||
|
|
e.i = r;
|
||
|
|
if (t === this.N) {
|
||
|
|
this.N = e;
|
||
|
|
this.A.h = e;
|
||
|
|
} else {
|
||
|
|
var n = t.h;
|
||
|
|
if (n.t === t) {
|
||
|
|
n.t = e;
|
||
|
|
} else n.i = e;
|
||
|
|
}
|
||
|
|
e.h = t.h;
|
||
|
|
r.h = e;
|
||
|
|
t.h = e;
|
||
|
|
t.l = 1;
|
||
|
|
} else {
|
||
|
|
r.l = 0;
|
||
|
|
if (t === this.N) {
|
||
|
|
this.N = t.T();
|
||
|
|
} else t.T();
|
||
|
|
t.l = 1;
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if (this.enableIndex) {
|
||
|
|
r.M();
|
||
|
|
t.M();
|
||
|
|
e.M();
|
||
|
|
}
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
};
|
||
|
|
TreeContainer.prototype.D = function(e, r, t) {
|
||
|
|
if (this.N === undefined) {
|
||
|
|
this._ += 1;
|
||
|
|
this.N = new this.S(e, r, 0);
|
||
|
|
this.N.h = this.A;
|
||
|
|
this.A.h = this.A.t = this.A.i = this.N;
|
||
|
|
return this._;
|
||
|
|
}
|
||
|
|
var i;
|
||
|
|
var n = this.A.t;
|
||
|
|
var s = this.g(n.u, e);
|
||
|
|
if (s === 0) {
|
||
|
|
n.o = r;
|
||
|
|
return this._;
|
||
|
|
} else if (s > 0) {
|
||
|
|
n.t = new this.S(e, r);
|
||
|
|
n.t.h = n;
|
||
|
|
i = n.t;
|
||
|
|
this.A.t = i;
|
||
|
|
} else {
|
||
|
|
var h = this.A.i;
|
||
|
|
var a = this.g(h.u, e);
|
||
|
|
if (a === 0) {
|
||
|
|
h.o = r;
|
||
|
|
return this._;
|
||
|
|
} else if (a < 0) {
|
||
|
|
h.i = new this.S(e, r);
|
||
|
|
h.i.h = h;
|
||
|
|
i = h.i;
|
||
|
|
this.A.i = i;
|
||
|
|
} else {
|
||
|
|
if (t !== undefined) {
|
||
|
|
var u = t.C;
|
||
|
|
if (u !== this.A) {
|
||
|
|
var f = this.g(u.u, e);
|
||
|
|
if (f === 0) {
|
||
|
|
u.o = r;
|
||
|
|
return this._;
|
||
|
|
} else if (f > 0) {
|
||
|
|
var o = u.v();
|
||
|
|
var d = this.g(o.u, e);
|
||
|
|
if (d === 0) {
|
||
|
|
o.o = r;
|
||
|
|
return this._;
|
||
|
|
} else if (d < 0) {
|
||
|
|
i = new this.S(e, r);
|
||
|
|
if (o.i === undefined) {
|
||
|
|
o.i = i;
|
||
|
|
i.h = o;
|
||
|
|
} else {
|
||
|
|
u.t = i;
|
||
|
|
i.h = u;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if (i === undefined) {
|
||
|
|
i = this.N;
|
||
|
|
while (true) {
|
||
|
|
var c = this.g(i.u, e);
|
||
|
|
if (c > 0) {
|
||
|
|
if (i.t === undefined) {
|
||
|
|
i.t = new this.S(e, r);
|
||
|
|
i.t.h = i;
|
||
|
|
i = i.t;
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
i = i.t;
|
||
|
|
} else if (c < 0) {
|
||
|
|
if (i.i === undefined) {
|
||
|
|
i.i = new this.S(e, r);
|
||
|
|
i.i.h = i;
|
||
|
|
i = i.i;
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
i = i.i;
|
||
|
|
} else {
|
||
|
|
i.o = r;
|
||
|
|
return this._;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if (this.enableIndex) {
|
||
|
|
var l = i.h;
|
||
|
|
while (l !== this.A) {
|
||
|
|
l.O += 1;
|
||
|
|
l = l.h;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
this.q(i);
|
||
|
|
this._ += 1;
|
||
|
|
return this._;
|
||
|
|
};
|
||
|
|
TreeContainer.prototype.F = function(e, r) {
|
||
|
|
while (e) {
|
||
|
|
var t = this.g(e.u, r);
|
||
|
|
if (t < 0) {
|
||
|
|
e = e.i;
|
||
|
|
} else if (t > 0) {
|
||
|
|
e = e.t;
|
||
|
|
} else return e;
|
||
|
|
}
|
||
|
|
return e || this.A;
|
||
|
|
};
|
||
|
|
TreeContainer.prototype.clear = function() {
|
||
|
|
this._ = 0;
|
||
|
|
this.N = undefined;
|
||
|
|
this.A.h = undefined;
|
||
|
|
this.A.t = this.A.i = undefined;
|
||
|
|
};
|
||
|
|
TreeContainer.prototype.updateKeyByIterator = function(e, r) {
|
||
|
|
var t = e.C;
|
||
|
|
if (t === this.A) {
|
||
|
|
throwIteratorAccessError();
|
||
|
|
}
|
||
|
|
if (this._ === 1) {
|
||
|
|
t.u = r;
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
var i = t.p().u;
|
||
|
|
if (t === this.A.t) {
|
||
|
|
if (this.g(i, r) > 0) {
|
||
|
|
t.u = r;
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
var n = t.v().u;
|
||
|
|
if (t === this.A.i) {
|
||
|
|
if (this.g(n, r) < 0) {
|
||
|
|
t.u = r;
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
if (this.g(n, r) >= 0 || this.g(i, r) <= 0) return false;
|
||
|
|
t.u = r;
|
||
|
|
return true;
|
||
|
|
};
|
||
|
|
TreeContainer.prototype.eraseElementByPos = function(e) {
|
||
|
|
if (e < 0 || e > this._ - 1) {
|
||
|
|
throw new RangeError;
|
||
|
|
}
|
||
|
|
var r = this.P(e);
|
||
|
|
this.G(r);
|
||
|
|
return this._;
|
||
|
|
};
|
||
|
|
TreeContainer.prototype.eraseElementByKey = function(e) {
|
||
|
|
if (this._ === 0) return false;
|
||
|
|
var r = this.F(this.N, e);
|
||
|
|
if (r === this.A) return false;
|
||
|
|
this.G(r);
|
||
|
|
return true;
|
||
|
|
};
|
||
|
|
TreeContainer.prototype.eraseElementByIterator = function(e) {
|
||
|
|
var r = e.C;
|
||
|
|
if (r === this.A) {
|
||
|
|
throwIteratorAccessError();
|
||
|
|
}
|
||
|
|
var t = r.i === undefined;
|
||
|
|
var i = e.iteratorType === 0;
|
||
|
|
if (i) {
|
||
|
|
if (t) e.next();
|
||
|
|
} else {
|
||
|
|
if (!t || r.t === undefined) e.next();
|
||
|
|
}
|
||
|
|
this.G(r);
|
||
|
|
return e;
|
||
|
|
};
|
||
|
|
TreeContainer.prototype.getHeight = function() {
|
||
|
|
if (this._ === 0) return 0;
|
||
|
|
function traversal(e) {
|
||
|
|
if (!e) return 0;
|
||
|
|
return Math.max(traversal(e.t), traversal(e.i)) + 1;
|
||
|
|
}
|
||
|
|
return traversal(this.N);
|
||
|
|
};
|
||
|
|
return TreeContainer;
|
||
|
|
}(Container);
|
||
|
|
|
||
|
|
var TreeIterator = function(e) {
|
||
|
|
__extends(TreeIterator, e);
|
||
|
|
function TreeIterator(r, t, i) {
|
||
|
|
var n = e.call(this, i) || this;
|
||
|
|
n.C = r;
|
||
|
|
n.A = t;
|
||
|
|
if (n.iteratorType === 0) {
|
||
|
|
n.pre = function() {
|
||
|
|
if (this.C === this.A.t) {
|
||
|
|
throwIteratorAccessError();
|
||
|
|
}
|
||
|
|
this.C = this.C.v();
|
||
|
|
return this;
|
||
|
|
};
|
||
|
|
n.next = function() {
|
||
|
|
if (this.C === this.A) {
|
||
|
|
throwIteratorAccessError();
|
||
|
|
}
|
||
|
|
this.C = this.C.p();
|
||
|
|
return this;
|
||
|
|
};
|
||
|
|
} else {
|
||
|
|
n.pre = function() {
|
||
|
|
if (this.C === this.A.i) {
|
||
|
|
throwIteratorAccessError();
|
||
|
|
}
|
||
|
|
this.C = this.C.p();
|
||
|
|
return this;
|
||
|
|
};
|
||
|
|
n.next = function() {
|
||
|
|
if (this.C === this.A) {
|
||
|
|
throwIteratorAccessError();
|
||
|
|
}
|
||
|
|
this.C = this.C.v();
|
||
|
|
return this;
|
||
|
|
};
|
||
|
|
}
|
||
|
|
return n;
|
||
|
|
}
|
||
|
|
Object.defineProperty(TreeIterator.prototype, "index", {
|
||
|
|
get: function() {
|
||
|
|
var e = this.C;
|
||
|
|
var r = this.A.h;
|
||
|
|
if (e === this.A) {
|
||
|
|
if (r) {
|
||
|
|
return r.O - 1;
|
||
|
|
}
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
var t = 0;
|
||
|
|
if (e.t) {
|
||
|
|
t += e.t.O;
|
||
|
|
}
|
||
|
|
while (e !== r) {
|
||
|
|
var i = e.h;
|
||
|
|
if (e === i.i) {
|
||
|
|
t += 1;
|
||
|
|
if (i.t) {
|
||
|
|
t += i.t.O;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
e = i;
|
||
|
|
}
|
||
|
|
return t;
|
||
|
|
},
|
||
|
|
enumerable: false,
|
||
|
|
configurable: true
|
||
|
|
});
|
||
|
|
TreeIterator.prototype.isAccessible = function() {
|
||
|
|
return this.C !== this.A;
|
||
|
|
};
|
||
|
|
return TreeIterator;
|
||
|
|
}(ContainerIterator);
|
||
|
|
|
||
|
|
var OrderedMapIterator = function(e) {
|
||
|
|
__extends(OrderedMapIterator, e);
|
||
|
|
function OrderedMapIterator(r, t, i, n) {
|
||
|
|
var s = e.call(this, r, t, n) || this;
|
||
|
|
s.container = i;
|
||
|
|
return s;
|
||
|
|
}
|
||
|
|
Object.defineProperty(OrderedMapIterator.prototype, "pointer", {
|
||
|
|
get: function() {
|
||
|
|
if (this.C === this.A) {
|
||
|
|
throwIteratorAccessError();
|
||
|
|
}
|
||
|
|
var e = this;
|
||
|
|
return new Proxy([], {
|
||
|
|
get: function(r, t) {
|
||
|
|
if (t === "0") return e.C.u; else if (t === "1") return e.C.o;
|
||
|
|
r[0] = e.C.u;
|
||
|
|
r[1] = e.C.o;
|
||
|
|
return r[t];
|
||
|
|
},
|
||
|
|
set: function(r, t, i) {
|
||
|
|
if (t !== "1") {
|
||
|
|
throw new TypeError("prop must be 1");
|
||
|
|
}
|
||
|
|
e.C.o = i;
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
});
|
||
|
|
},
|
||
|
|
enumerable: false,
|
||
|
|
configurable: true
|
||
|
|
});
|
||
|
|
OrderedMapIterator.prototype.copy = function() {
|
||
|
|
return new OrderedMapIterator(this.C, this.A, this.container, this.iteratorType);
|
||
|
|
};
|
||
|
|
return OrderedMapIterator;
|
||
|
|
}(TreeIterator);
|
||
|
|
|
||
|
|
var OrderedMap = function(e) {
|
||
|
|
__extends(OrderedMap, e);
|
||
|
|
function OrderedMap(r, t, i) {
|
||
|
|
if (r === void 0) {
|
||
|
|
r = [];
|
||
|
|
}
|
||
|
|
var n = e.call(this, t, i) || this;
|
||
|
|
var s = n;
|
||
|
|
r.forEach((function(e) {
|
||
|
|
s.setElement(e[0], e[1]);
|
||
|
|
}));
|
||
|
|
return n;
|
||
|
|
}
|
||
|
|
OrderedMap.prototype.begin = function() {
|
||
|
|
return new OrderedMapIterator(this.A.t || this.A, this.A, this);
|
||
|
|
};
|
||
|
|
OrderedMap.prototype.end = function() {
|
||
|
|
return new OrderedMapIterator(this.A, this.A, this);
|
||
|
|
};
|
||
|
|
OrderedMap.prototype.rBegin = function() {
|
||
|
|
return new OrderedMapIterator(this.A.i || this.A, this.A, this, 1);
|
||
|
|
};
|
||
|
|
OrderedMap.prototype.rEnd = function() {
|
||
|
|
return new OrderedMapIterator(this.A, this.A, this, 1);
|
||
|
|
};
|
||
|
|
OrderedMap.prototype.front = function() {
|
||
|
|
if (this._ === 0) return;
|
||
|
|
var e = this.A.t;
|
||
|
|
return [ e.u, e.o ];
|
||
|
|
};
|
||
|
|
OrderedMap.prototype.back = function() {
|
||
|
|
if (this._ === 0) return;
|
||
|
|
var e = this.A.i;
|
||
|
|
return [ e.u, e.o ];
|
||
|
|
};
|
||
|
|
OrderedMap.prototype.lowerBound = function(e) {
|
||
|
|
var r = this.m(this.N, e);
|
||
|
|
return new OrderedMapIterator(r, this.A, this);
|
||
|
|
};
|
||
|
|
OrderedMap.prototype.upperBound = function(e) {
|
||
|
|
var r = this.B(this.N, e);
|
||
|
|
return new OrderedMapIterator(r, this.A, this);
|
||
|
|
};
|
||
|
|
OrderedMap.prototype.reverseLowerBound = function(e) {
|
||
|
|
var r = this.j(this.N, e);
|
||
|
|
return new OrderedMapIterator(r, this.A, this);
|
||
|
|
};
|
||
|
|
OrderedMap.prototype.reverseUpperBound = function(e) {
|
||
|
|
var r = this.k(this.N, e);
|
||
|
|
return new OrderedMapIterator(r, this.A, this);
|
||
|
|
};
|
||
|
|
OrderedMap.prototype.forEach = function(e) {
|
||
|
|
this.P((function(r, t, i) {
|
||
|
|
e([ r.u, r.o ], t, i);
|
||
|
|
}));
|
||
|
|
};
|
||
|
|
OrderedMap.prototype.setElement = function(e, r, t) {
|
||
|
|
return this.D(e, r, t);
|
||
|
|
};
|
||
|
|
OrderedMap.prototype.getElementByPos = function(e) {
|
||
|
|
if (e < 0 || e > this._ - 1) {
|
||
|
|
throw new RangeError;
|
||
|
|
}
|
||
|
|
var r = this.P(e);
|
||
|
|
return [ r.u, r.o ];
|
||
|
|
};
|
||
|
|
OrderedMap.prototype.find = function(e) {
|
||
|
|
var r = this.F(this.N, e);
|
||
|
|
return new OrderedMapIterator(r, this.A, this);
|
||
|
|
};
|
||
|
|
OrderedMap.prototype.getElementByKey = function(e) {
|
||
|
|
var r = this.F(this.N, e);
|
||
|
|
return r.o;
|
||
|
|
};
|
||
|
|
OrderedMap.prototype.union = function(e) {
|
||
|
|
var r = this;
|
||
|
|
e.forEach((function(e) {
|
||
|
|
r.setElement(e[0], e[1]);
|
||
|
|
}));
|
||
|
|
return this._;
|
||
|
|
};
|
||
|
|
OrderedMap.prototype[Symbol.iterator] = function() {
|
||
|
|
var e, r, t, i;
|
||
|
|
return __generator(this, (function(n) {
|
||
|
|
switch (n.label) {
|
||
|
|
case 0:
|
||
|
|
e = this._;
|
||
|
|
r = this.P();
|
||
|
|
t = 0;
|
||
|
|
n.label = 1;
|
||
|
|
|
||
|
|
case 1:
|
||
|
|
if (!(t < e)) return [ 3, 4 ];
|
||
|
|
i = r[t];
|
||
|
|
return [ 4, [ i.u, i.o ] ];
|
||
|
|
|
||
|
|
case 2:
|
||
|
|
n.sent();
|
||
|
|
n.label = 3;
|
||
|
|
|
||
|
|
case 3:
|
||
|
|
++t;
|
||
|
|
return [ 3, 1 ];
|
||
|
|
|
||
|
|
case 4:
|
||
|
|
return [ 2 ];
|
||
|
|
}
|
||
|
|
}));
|
||
|
|
};
|
||
|
|
return OrderedMap;
|
||
|
|
}(TreeContainer);
|
||
|
|
|
||
|
|
export { OrderedMap };
|
||
|
|
//# sourceMappingURL=index.js.map
|