328 lines
8.2 KiB
JavaScript
328 lines
8.2 KiB
JavaScript
// Module ID: 8
|
|
// Function ID: 9
|
|
// Name: Deque
|
|
// Dependencies: []
|
|
|
|
// Module 8 (Deque)
|
|
class Deque {
|
|
constructor(arg0) {
|
|
obj = {};
|
|
length = global;
|
|
if (typeof global === "number") {
|
|
tmp = globalThis;
|
|
_Math = Math;
|
|
_Math2 = Math;
|
|
num = 16;
|
|
num2 = 1073741824;
|
|
num3 = 0;
|
|
num4 = 1;
|
|
diff = (Math.min(require("module_16"), 1073741824) >>> 0) - 1;
|
|
tmp3 = diff | diff >> 1;
|
|
num5 = 2;
|
|
tmp4 = tmp3 | tmp3 >> 2;
|
|
num6 = 4;
|
|
tmp5 = tmp4 | tmp4 >> 4;
|
|
num7 = 8;
|
|
tmp6 = tmp5 | tmp5 >> 8;
|
|
num8 = 1 + (tmp6 | tmp6 >> 16);
|
|
} else {
|
|
tmp8 = isArray;
|
|
num8 = 16;
|
|
if (isArray(global)) {
|
|
length = global.length;
|
|
}
|
|
}
|
|
obj._capacity = num8;
|
|
obj._length = 0;
|
|
obj._front = 0;
|
|
_makeCapacityResult = obj._makeCapacity();
|
|
if (isArray(global)) {
|
|
length2 = global.length;
|
|
num9 = 1;
|
|
for (let num10 = 0; num10 < length2; num10 = num10 + 1) {
|
|
obj[num10] = global[num10];
|
|
}
|
|
obj._length = length2;
|
|
}
|
|
return;
|
|
}
|
|
toArray() {
|
|
_length = this._length;
|
|
array = new Array(_length);
|
|
for (let num = 0; num < _length; num = num + 1) {
|
|
array[num] = this[this._front + num & tmp2 - 1];
|
|
}
|
|
return array;
|
|
}
|
|
push(arg0) {
|
|
self = this;
|
|
length = arguments.length;
|
|
_length = this._length;
|
|
if (length > 1) {
|
|
_capacity = self._capacity;
|
|
if (_length + length > _capacity) {
|
|
num3 = 0;
|
|
tmp4 = _length;
|
|
tmp5 = _length;
|
|
if (0 < length) {
|
|
do {
|
|
_checkCapacityResult = self._checkCapacity(tmp4 + 1);
|
|
self[self._front + tmp4 & self._capacity - 1] = arguments[num3];
|
|
sum = tmp4 + 1;
|
|
self._length = sum;
|
|
num3 = num3 + 1;
|
|
tmp4 = sum;
|
|
tmp5 = sum;
|
|
} while (num3 < length);
|
|
}
|
|
return tmp5;
|
|
} else {
|
|
_front = self._front;
|
|
for (let num2 = 0; num2 < length; num2 = num2 + 1) {
|
|
self[_front + _length & _capacity - 1] = arguments[num2];
|
|
_front = _front + 1;
|
|
}
|
|
self._length = _length + length;
|
|
return _length + length;
|
|
}
|
|
} else {
|
|
num = 0;
|
|
sum1 = _length;
|
|
if (0 !== length) {
|
|
tmp2 = global;
|
|
_checkCapacityResult1 = self._checkCapacity(_length + 1);
|
|
self[self._front + _length & self._capacity - 1] = global;
|
|
self._length = _length + 1;
|
|
sum1 = _length + 1;
|
|
}
|
|
return sum1;
|
|
}
|
|
}
|
|
pop() {
|
|
self = this;
|
|
_length = this._length;
|
|
if (0 !== _length) {
|
|
num = 1;
|
|
tmp = self._front + _length - 1 & self._capacity - 1;
|
|
self[tmp] = undefined;
|
|
self._length = _length - 1;
|
|
return self[tmp];
|
|
} else {
|
|
return;
|
|
}
|
|
}
|
|
shift() {
|
|
self = this;
|
|
_length = this._length;
|
|
if (0 !== _length) {
|
|
_front = self._front;
|
|
self[_front] = undefined;
|
|
num = 1;
|
|
self._front = _front + 1 & self._capacity - 1;
|
|
self._length = _length - 1;
|
|
return self[_front];
|
|
} else {
|
|
return;
|
|
}
|
|
}
|
|
unshift(arg0) {
|
|
self = this;
|
|
_length = this._length;
|
|
length = arguments.length;
|
|
if (length > 1) {
|
|
_capacity2 = self._capacity;
|
|
if (_length + length > _capacity2) {
|
|
diff = length - 1;
|
|
num3 = 0;
|
|
tmp8 = _length;
|
|
tmp9 = _length;
|
|
if (0 <= diff) {
|
|
do {
|
|
_checkCapacityResult = self._checkCapacity(tmp8 + 1);
|
|
_capacity3 = self._capacity;
|
|
diff1 = (self._front - 1 & _capacity3 - 1 ^ _capacity3) - _capacity3;
|
|
self[diff1] = arguments[diff];
|
|
sum = tmp8 + 1;
|
|
self._length = sum;
|
|
self._front = diff1;
|
|
diff = diff - 1;
|
|
tmp8 = sum;
|
|
tmp9 = sum;
|
|
} while (0 <= diff);
|
|
}
|
|
return tmp9;
|
|
} else {
|
|
_front = self._front;
|
|
diff2 = length - 1;
|
|
num2 = 0;
|
|
tmp5 = _front;
|
|
if (0 <= diff2) {
|
|
do {
|
|
diff3 = (_front - 1 & _capacity2 - 1 ^ _capacity2) - _capacity2;
|
|
self[diff3] = arguments[diff2];
|
|
diff2 = diff2 - 1;
|
|
_front = diff3;
|
|
tmp5 = diff3;
|
|
} while (0 <= diff2);
|
|
}
|
|
self._front = tmp5;
|
|
self._length = _length + length;
|
|
return _length + length;
|
|
}
|
|
} else {
|
|
num = 0;
|
|
if (0 === length) {
|
|
return _length;
|
|
} else {
|
|
tmp = global;
|
|
_checkCapacityResult1 = self._checkCapacity(_length + 1);
|
|
_capacity = self._capacity;
|
|
diff4 = (self._front - 1 & _capacity - 1 ^ _capacity) - _capacity;
|
|
self[diff4] = global;
|
|
self._length = _length + 1;
|
|
self._front = diff4;
|
|
return _length + 1;
|
|
}
|
|
}
|
|
}
|
|
peekBack() {
|
|
self = this;
|
|
_length = this._length;
|
|
if (0 !== _length) {
|
|
num = 1;
|
|
return self[self._front + _length - 1 & self._capacity - 1];
|
|
} else {
|
|
return;
|
|
}
|
|
}
|
|
peekFront() {
|
|
self = this;
|
|
return 0 !== this._length ? self[self._front] : undefined;
|
|
}
|
|
get(arg0) {
|
|
if (global === (global | 0)) {
|
|
self = this;
|
|
_length = this._length;
|
|
num = 0;
|
|
sum = global;
|
|
if (global < 0) {
|
|
sum = global + _length;
|
|
}
|
|
if (sum >= 0) {
|
|
if (sum < _length) {
|
|
num2 = 1;
|
|
return self[self._front + sum & self._capacity - 1];
|
|
}
|
|
}
|
|
}
|
|
return;
|
|
}
|
|
isEmpty() {
|
|
return 0 === this._length;
|
|
}
|
|
clear() {
|
|
obj = { _length: 0, _front: 0 };
|
|
_makeCapacityResult = obj._makeCapacity();
|
|
return;
|
|
}
|
|
toString() {
|
|
str = this.toArray();
|
|
return str.toString();
|
|
}
|
|
_makeCapacity() {
|
|
_capacity = this._capacity;
|
|
for (let num = 0; num < _capacity; num = num + 1) {
|
|
this[num] = undefined;
|
|
}
|
|
return;
|
|
}
|
|
_checkCapacity(arg0) {
|
|
self = this;
|
|
if (this._capacity < global) {
|
|
num8 = 1.5;
|
|
num9 = 16;
|
|
sum = 1.5 * self._capacity + 16;
|
|
length = sum;
|
|
if (typeof sum === "number") {
|
|
tmp = globalThis;
|
|
_Math = Math;
|
|
_Math2 = Math;
|
|
num = 1073741824;
|
|
num2 = 0;
|
|
num3 = 1;
|
|
diff = (Math.min(require("module_16"), 1073741824) >>> 0) - 1;
|
|
tmp3 = diff | diff >> 1;
|
|
num4 = 2;
|
|
tmp4 = tmp3 | tmp3 >> 2;
|
|
num5 = 4;
|
|
tmp5 = tmp4 | tmp4 >> 4;
|
|
num6 = 8;
|
|
tmp6 = tmp5 | tmp5 >> 8;
|
|
num7 = 1 + (tmp6 | tmp6 >> 16);
|
|
} else {
|
|
tmp8 = isArray;
|
|
num7 = 16;
|
|
if (isArray(sum)) {
|
|
length = sum.length;
|
|
}
|
|
}
|
|
_resizeToResult = self._resizeTo(num7);
|
|
}
|
|
return;
|
|
}
|
|
_resizeTo(arg0) {
|
|
self = this;
|
|
({ _front, _capacity } = this);
|
|
array = new Array(_capacity);
|
|
_length = this._length;
|
|
for (let num = 0; num < _capacity; num = num + 1) {
|
|
tmp2 = num;
|
|
array[tmp2] = self[tmp2];
|
|
}
|
|
self._capacity = global;
|
|
_makeCapacityResult = self._makeCapacity();
|
|
self._front = 0;
|
|
if (_front + _length <= _capacity) {
|
|
for (let num4 = 0; num4 < _length; num4 = num4 + 1) {
|
|
self[num4] = array[num4 + _front];
|
|
}
|
|
} else {
|
|
diff = _length - (_front + _length & _capacity - 1);
|
|
num2 = 0;
|
|
if (0 < diff) {
|
|
do {
|
|
self[num2] = array[num2 + _front];
|
|
num2 = num2 + 1;
|
|
} while (num2 < diff);
|
|
}
|
|
diff1 = _length - diff;
|
|
num3 = 0;
|
|
if (0 < diff1) {
|
|
do {
|
|
self[num3 + diff] = array[num3];
|
|
num3 = num3 + 1;
|
|
} while (num3 < diff1);
|
|
}
|
|
}
|
|
return;
|
|
}
|
|
}
|
|
Deque.prototype.valueOf = Deque.prototype.toString;
|
|
Deque.prototype.removeFront = Deque.prototype.shift;
|
|
Deque.prototype.removeBack = Deque.prototype.pop;
|
|
Deque.prototype.insertFront = Deque.prototype.unshift;
|
|
Deque.prototype.insertBack = Deque.prototype.push;
|
|
Deque.prototype.enqueue = Deque.prototype.push;
|
|
Deque.prototype.dequeue = Deque.prototype.shift;
|
|
Deque.prototype.toJSON = Deque.prototype.toArray;
|
|
Object.defineProperty(Deque.prototype, "length", {
|
|
get() {
|
|
return this._length;
|
|
},
|
|
set() {
|
|
const rangeError = new RangeError("");
|
|
throw rangeError;
|
|
}
|
|
});
|
|
|
|
export default Deque;
|