orcaq 1.0.20

package/.output/server/node_modules/denque/index.js

@@ -0,0 +1,481 @@
+'use strict';
+
+/**
+ * Custom implementation of a double ended queue.
+ */
+function Denque(array, options) {
+  var options = options || {};
+  this._capacity = options.capacity;
+
+  this._head = 0;
+  this._tail = 0;
+
+  if (Array.isArray(array)) {
+    this._fromArray(array);
+  } else {
+    this._capacityMask = 0x3;
+    this._list = new Array(4);
+  }
+}
+
+/**
+ * --------------
+ *  PUBLIC API
+ * -------------
+ */
+
+/**
+ * Returns the item at the specified index from the list.
+ * 0 is the first element, 1 is the second, and so on...
+ * Elements at negative values are that many from the end: -1 is one before the end
+ * (the last element), -2 is two before the end (one before last), etc.
+ * @param index
+ * @returns {*}
+ */
+Denque.prototype.peekAt = function peekAt(index) {
+  var i = index;
+  // expect a number or return undefined
+  if ((i !== (i | 0))) {
+    return void 0;
+  }
+  var len = this.size();
+  if (i >= len || i < -len) return undefined;
+  if (i < 0) i += len;
+  i = (this._head + i) & this._capacityMask;
+  return this._list[i];
+};
+
+/**
+ * Alias for peekAt()
+ * @param i
+ * @returns {*}
+ */
+Denque.prototype.get = function get(i) {
+  return this.peekAt(i);
+};
+
+/**
+ * Returns the first item in the list without removing it.
+ * @returns {*}
+ */
+Denque.prototype.peek = function peek() {
+  if (this._head === this._tail) return undefined;
+  return this._list[this._head];
+};
+
+/**
+ * Alias for peek()
+ * @returns {*}
+ */
+Denque.prototype.peekFront = function peekFront() {
+  return this.peek();
+};
+
+/**
+ * Returns the item that is at the back of the queue without removing it.
+ * Uses peekAt(-1)
+ */
+Denque.prototype.peekBack = function peekBack() {
+  return this.peekAt(-1);
+};
+
+/**
+ * Returns the current length of the queue
+ * @return {Number}
+ */
+Object.defineProperty(Denque.prototype, 'length', {
+  get: function length() {
+    return this.size();
+  }
+});
+
+/**
+ * Return the number of items on the list, or 0 if empty.
+ * @returns {number}
+ */
+Denque.prototype.size = function size() {
+  if (this._head === this._tail) return 0;
+  if (this._head < this._tail) return this._tail - this._head;
+  else return this._capacityMask + 1 - (this._head - this._tail);
+};
+
+/**
+ * Add an item at the beginning of the list.
+ * @param item
+ */
+Denque.prototype.unshift = function unshift(item) {
+  if (arguments.length === 0) return this.size();
+  var len = this._list.length;
+  this._head = (this._head - 1 + len) & this._capacityMask;
+  this._list[this._head] = item;
+  if (this._tail === this._head) this._growArray();
+  if (this._capacity && this.size() > this._capacity) this.pop();
+  if (this._head < this._tail) return this._tail - this._head;
+  else return this._capacityMask + 1 - (this._head - this._tail);
+};
+
+/**
+ * Remove and return the first item on the list,
+ * Returns undefined if the list is empty.
+ * @returns {*}
+ */
+Denque.prototype.shift = function shift() {
+  var head = this._head;
+  if (head === this._tail) return undefined;
+  var item = this._list[head];
+  this._list[head] = undefined;
+  this._head = (head + 1) & this._capacityMask;
+  if (head < 2 && this._tail > 10000 && this._tail <= this._list.length >>> 2) this._shrinkArray();
+  return item;
+};
+
+/**
+ * Add an item to the bottom of the list.
+ * @param item
+ */
+Denque.prototype.push = function push(item) {
+  if (arguments.length === 0) return this.size();
+  var tail = this._tail;
+  this._list[tail] = item;
+  this._tail = (tail + 1) & this._capacityMask;
+  if (this._tail === this._head) {
+    this._growArray();
+  }
+  if (this._capacity && this.size() > this._capacity) {
+    this.shift();
+  }
+  if (this._head < this._tail) return this._tail - this._head;
+  else return this._capacityMask + 1 - (this._head - this._tail);
+};
+
+/**
+ * Remove and return the last item on the list.
+ * Returns undefined if the list is empty.
+ * @returns {*}
+ */
+Denque.prototype.pop = function pop() {
+  var tail = this._tail;
+  if (tail === this._head) return undefined;
+  var len = this._list.length;
+  this._tail = (tail - 1 + len) & this._capacityMask;
+  var item = this._list[this._tail];
+  this._list[this._tail] = undefined;
+  if (this._head < 2 && tail > 10000 && tail <= len >>> 2) this._shrinkArray();
+  return item;
+};
+
+/**
+ * Remove and return the item at the specified index from the list.
+ * Returns undefined if the list is empty.
+ * @param index
+ * @returns {*}
+ */
+Denque.prototype.removeOne = function removeOne(index) {
+  var i = index;
+  // expect a number or return undefined
+  if ((i !== (i | 0))) {
+    return void 0;
+  }
+  if (this._head === this._tail) return void 0;
+  var size = this.size();
+  var len = this._list.length;
+  if (i >= size || i < -size) return void 0;
+  if (i < 0) i += size;
+  i = (this._head + i) & this._capacityMask;
+  var item = this._list[i];
+  var k;
+  if (index < size / 2) {
+    for (k = index; k > 0; k--) {
+      this._list[i] = this._list[i = (i - 1 + len) & this._capacityMask];
+    }
+    this._list[i] = void 0;
+    this._head = (this._head + 1 + len) & this._capacityMask;
+  } else {
+    for (k = size - 1 - index; k > 0; k--) {
+      this._list[i] = this._list[i = (i + 1 + len) & this._capacityMask];
+    }
+    this._list[i] = void 0;
+    this._tail = (this._tail - 1 + len) & this._capacityMask;
+  }
+  return item;
+};
+
+/**
+ * Remove number of items from the specified index from the list.
+ * Returns array of removed items.
+ * Returns undefined if the list is empty.
+ * @param index
+ * @param count
+ * @returns {array}
+ */
+Denque.prototype.remove = function remove(index, count) {
+  var i = index;
+  var removed;
+  var del_count = count;
+  // expect a number or return undefined
+  if ((i !== (i | 0))) {
+    return void 0;
+  }
+  if (this._head === this._tail) return void 0;
+  var size = this.size();
+  var len = this._list.length;
+  if (i >= size || i < -size || count < 1) return void 0;
+  if (i < 0) i += size;
+  if (count === 1 || !count) {
+    removed = new Array(1);
+    removed[0] = this.removeOne(i);
+    return removed;
+  }
+  if (i === 0 && i + count >= size) {
+    removed = this.toArray();
+    this.clear();
+    return removed;
+  }
+  if (i + count > size) count = size - i;
+  var k;
+  removed = new Array(count);
+  for (k = 0; k < count; k++) {
+    removed[k] = this._list[(this._head + i + k) & this._capacityMask];
+  }
+  i = (this._head + i) & this._capacityMask;
+  if (index + count === size) {
+    this._tail = (this._tail - count + len) & this._capacityMask;
+    for (k = count; k > 0; k--) {
+      this._list[i = (i + 1 + len) & this._capacityMask] = void 0;
+    }
+    return removed;
+  }
+  if (index === 0) {
+    this._head = (this._head + count + len) & this._capacityMask;
+    for (k = count - 1; k > 0; k--) {
+      this._list[i = (i + 1 + len) & this._capacityMask] = void 0;
+    }
+    return removed;
+  }
+  if (i < size / 2) {
+    this._head = (this._head + index + count + len) & this._capacityMask;
+    for (k = index; k > 0; k--) {
+      this.unshift(this._list[i = (i - 1 + len) & this._capacityMask]);
+    }
+    i = (this._head - 1 + len) & this._capacityMask;
+    while (del_count > 0) {
+      this._list[i = (i - 1 + len) & this._capacityMask] = void 0;
+      del_count--;
+    }
+    if (index < 0) this._tail = i;
+  } else {
+    this._tail = i;
+    i = (i + count + len) & this._capacityMask;
+    for (k = size - (count + index); k > 0; k--) {
+      this.push(this._list[i++]);
+    }
+    i = this._tail;
+    while (del_count > 0) {
+      this._list[i = (i + 1 + len) & this._capacityMask] = void 0;
+      del_count--;
+    }
+  }
+  if (this._head < 2 && this._tail > 10000 && this._tail <= len >>> 2) this._shrinkArray();
+  return removed;
+};
+
+/**
+ * Native splice implementation.
+ * Remove number of items from the specified index from the list and/or add new elements.
+ * Returns array of removed items or empty array if count == 0.
+ * Returns undefined if the list is empty.
+ *
+ * @param index
+ * @param count
+ * @param {...*} [elements]
+ * @returns {array}
+ */
+Denque.prototype.splice = function splice(index, count) {
+  var i = index;
+  // expect a number or return undefined
+  if ((i !== (i | 0))) {
+    return void 0;
+  }
+  var size = this.size();
+  if (i < 0) i += size;
+  if (i > size) return void 0;
+  if (arguments.length > 2) {
+    var k;
+    var temp;
+    var removed;
+    var arg_len = arguments.length;
+    var len = this._list.length;
+    var arguments_index = 2;
+    if (!size || i < size / 2) {
+      temp = new Array(i);
+      for (k = 0; k < i; k++) {
+        temp[k] = this._list[(this._head + k) & this._capacityMask];
+      }
+      if (count === 0) {
+        removed = [];
+        if (i > 0) {
+          this._head = (this._head + i + len) & this._capacityMask;
+        }
+      } else {
+        removed = this.remove(i, count);
+        this._head = (this._head + i + len) & this._capacityMask;
+      }
+      while (arg_len > arguments_index) {
+        this.unshift(arguments[--arg_len]);
+      }
+      for (k = i; k > 0; k--) {
+        this.unshift(temp[k - 1]);
+      }
+    } else {
+      temp = new Array(size - (i + count));
+      var leng = temp.length;
+      for (k = 0; k < leng; k++) {
+        temp[k] = this._list[(this._head + i + count + k) & this._capacityMask];
+      }
+      if (count === 0) {
+        removed = [];
+        if (i != size) {
+          this._tail = (this._head + i + len) & this._capacityMask;
+        }
+      } else {
+        removed = this.remove(i, count);
+        this._tail = (this._tail - leng + len) & this._capacityMask;
+      }
+      while (arguments_index < arg_len) {
+        this.push(arguments[arguments_index++]);
+      }
+      for (k = 0; k < leng; k++) {
+        this.push(temp[k]);
+      }
+    }
+    return removed;
+  } else {
+    return this.remove(i, count);
+  }
+};
+
+/**
+ * Soft clear - does not reset capacity.
+ */
+Denque.prototype.clear = function clear() {
+  this._list = new Array(this._list.length);
+  this._head = 0;
+  this._tail = 0;
+};
+
+/**
+ * Returns true or false whether the list is empty.
+ * @returns {boolean}
+ */
+Denque.prototype.isEmpty = function isEmpty() {
+  return this._head === this._tail;
+};
+
+/**
+ * Returns an array of all queue items.
+ * @returns {Array}
+ */
+Denque.prototype.toArray = function toArray() {
+  return this._copyArray(false);
+};
+
+/**
+ * -------------
+ *   INTERNALS
+ * -------------
+ */
+
+/**
+ * Fills the queue with items from an array
+ * For use in the constructor
+ * @param array
+ * @private
+ */
+Denque.prototype._fromArray = function _fromArray(array) {
+  var length = array.length;
+  var capacity = this._nextPowerOf2(length);
+
+  this._list = new Array(capacity);
+  this._capacityMask = capacity - 1;
+  this._tail = length;
+
+  for (var i = 0; i < length; i++) this._list[i] = array[i];
+};
+
+/**
+ *
+ * @param fullCopy
+ * @param size Initialize the array with a specific size. Will default to the current list size
+ * @returns {Array}
+ * @private
+ */
+Denque.prototype._copyArray = function _copyArray(fullCopy, size) {
+  var src = this._list;
+  var capacity = src.length;
+  var length = this.length;
+  size = size | length;
+
+  // No prealloc requested and the buffer is contiguous
+  if (size == length && this._head < this._tail) {
+    // Simply do a fast slice copy
+    return this._list.slice(this._head, this._tail);
+  }
+
+  var dest = new Array(size);
+
+  var k = 0;
+  var i;
+  if (fullCopy || this._head > this._tail) {
+    for (i = this._head; i < capacity; i++) dest[k++] = src[i];
+    for (i = 0; i < this._tail; i++) dest[k++] = src[i];
+  } else {
+    for (i = this._head; i < this._tail; i++) dest[k++] = src[i];
+  }
+
+  return dest;
+}
+
+/**
+ * Grows the internal list array.
+ * @private
+ */
+Denque.prototype._growArray = function _growArray() {
+  if (this._head != 0) {
+    // double array size and copy existing data, head to end, then beginning to tail.
+    var newList = this._copyArray(true, this._list.length << 1);
+
+    this._tail = this._list.length;
+    this._head = 0;
+
+    this._list = newList;
+  } else {
+    this._tail = this._list.length;
+    this._list.length <<= 1;
+  }
+
+  this._capacityMask = (this._capacityMask << 1) | 1;
+};
+
+/**
+ * Shrinks the internal list array.
+ * @private
+ */
+Denque.prototype._shrinkArray = function _shrinkArray() {
+  this._list.length >>>= 1;
+  this._capacityMask >>>= 1;
+};
+
+/**
+ * Find the next power of 2, at least 4
+ * @private
+ * @param {number} num 
+ * @returns {number}
+ */
+Denque.prototype._nextPowerOf2 = function _nextPowerOf2(num) {
+  var log2 = Math.log(num) / Math.log(2);
+  var nextPow2 = 1 << (log2 + 1);
+
+  return Math.max(nextPow2, 4);
+}
+
+module.exports = Denque;

package/.output/server/node_modules/denque/package.json

@@ -0,0 +1,58 @@
+{
+  "name": "denque",
+  "version": "2.1.0",
+  "description": "The fastest javascript implementation of a double-ended queue. Used by the official Redis, MongoDB, MariaDB & MySQL libraries for Node.js and many other libraries. Maintains compatability with deque.",
+  "main": "index.js",
+  "engines": {
+    "node": ">=0.10"
+  },
+  "keywords": [
+    "data-structure",
+    "data-structures",
+    "queue",
+    "double",
+    "end",
+    "ended",
+    "deque",
+    "denque",
+    "double-ended-queue"
+  ],
+  "scripts": {
+    "test": "istanbul cover --report lcov _mocha && npm run typescript",
+    "coveralls": "cat ./coverage/lcov.info | coveralls",
+    "typescript": "tsc --project ./test/type/tsconfig.json",
+    "benchmark_thousand": "node benchmark/thousand",
+    "benchmark_2mil": "node benchmark/two_million",
+    "benchmark_splice": "node benchmark/splice",
+    "benchmark_remove": "node benchmark/remove",
+    "benchmark_removeOne": "node benchmark/removeOne",
+    "benchmark_growth": "node benchmark/growth",
+    "benchmark_toArray": "node benchmark/toArray",
+    "benchmark_fromArray": "node benchmark/fromArray"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/invertase/denque.git"
+  },
+  "license": "Apache-2.0",
+  "author": {
+    "name": "Invertase",
+    "email": "oss@invertase.io",
+    "url": "http://github.com/invertase/"
+  },
+  "contributors": [
+    "Mike Diarmid (Salakar) <mike@invertase.io>"
+  ],
+  "bugs": {
+    "url": "https://github.com/invertase/denque/issues"
+  },
+  "homepage": "https://docs.page/invertase/denque",
+  "devDependencies": {
+    "benchmark": "^2.1.4",
+    "codecov": "^3.8.3",
+    "double-ended-queue": "^2.1.0-0",
+    "istanbul": "^0.4.5",
+    "mocha": "^3.5.3",
+    "typescript": "^3.4.1"
+  }
+}

package/.output/server/node_modules/devalue/index.js

@@ -0,0 +1,3 @@
+export { uneval } from './src/uneval.js';
+export { parse, unflatten } from './src/parse.js';
+export { stringify } from './src/stringify.js';

package/.output/server/node_modules/devalue/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "devalue",
+  "description": "Gets the job done when JSON.stringify can't",
+  "version": "5.1.1",
+  "repository": "Rich-Harris/devalue",
+  "sideEffects": false,
+  "exports": {
+    ".": {
+      "types": "./types/index.d.ts",
+      "import": "./index.js",
+      "default": "./index.js"
+    }
+  },
+  "files": [
+    "index.js",
+    "src",
+    "types"
+  ],
+  "types": "./types/index.d.ts",
+  "devDependencies": {
+    "dts-buddy": "^0.0.4",
+    "publint": "^0.1.7",
+    "typescript": "^3.1.3",
+    "uvu": "^0.5.6"
+  },
+  "scripts": {
+    "build": "dts-buddy",
+    "test": "uvu test",
+    "prepublishOnly": "npm test && npm run build && publint"
+  },
+  "license": "MIT",
+  "type": "module",
+  "packageManager": "pnpm@8.5.1"
+}

package/.output/server/node_modules/devalue/src/base64.js

@@ -0,0 +1,110 @@
+/**
+ * Base64 Encodes an arraybuffer
+ * @param {ArrayBuffer} arraybuffer
+ * @returns {string}
+ */
+export function encode64(arraybuffer) {
+  const dv = new DataView(arraybuffer);
+  let binaryString = "";
+
+  for (let i = 0; i < arraybuffer.byteLength; i++) {
+    binaryString += String.fromCharCode(dv.getUint8(i));
+  }
+
+  return binaryToAscii(binaryString);
+}
+
+/**
+ * Decodes a base64 string into an arraybuffer
+ * @param {string} string
+ * @returns {ArrayBuffer}
+ */
+export function decode64(string) {
+  const binaryString = asciiToBinary(string);
+  const arraybuffer = new ArrayBuffer(binaryString.length);
+  const dv = new DataView(arraybuffer);
+
+  for (let i = 0; i < arraybuffer.byteLength; i++) {
+    dv.setUint8(i, binaryString.charCodeAt(i));
+  }
+
+  return arraybuffer;
+}
+
+const KEY_STRING =
+  "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+
+/**
+ * Substitute for atob since it's deprecated in node.
+ * Does not do any input validation.
+ *
+ * @see https://github.com/jsdom/abab/blob/master/lib/atob.js
+ *
+ * @param {string} data
+ * @returns {string}
+ */
+function asciiToBinary(data) {
+  if (data.length % 4 === 0) {
+    data = data.replace(/==?$/, "");
+  }
+
+  let output = "";
+  let buffer = 0;
+  let accumulatedBits = 0;
+
+  for (let i = 0; i < data.length; i++) {
+    buffer <<= 6;
+    buffer |= KEY_STRING.indexOf(data[i]);
+    accumulatedBits += 6;
+    if (accumulatedBits === 24) {
+      output += String.fromCharCode((buffer & 0xff0000) >> 16);
+      output += String.fromCharCode((buffer & 0xff00) >> 8);
+      output += String.fromCharCode(buffer & 0xff);
+      buffer = accumulatedBits = 0;
+    }
+  }
+  if (accumulatedBits === 12) {
+    buffer >>= 4;
+    output += String.fromCharCode(buffer);
+  } else if (accumulatedBits === 18) {
+    buffer >>= 2;
+    output += String.fromCharCode((buffer & 0xff00) >> 8);
+    output += String.fromCharCode(buffer & 0xff);
+  }
+  return output;
+}
+
+/**
+ * Substitute for btoa since it's deprecated in node.
+ * Does not do any input validation.
+ *
+ * @see https://github.com/jsdom/abab/blob/master/lib/btoa.js
+ *
+ * @param {string} str
+ * @returns {string}
+ */
+function binaryToAscii(str) {
+  let out = "";
+  for (let i = 0; i < str.length; i += 3) {
+    /** @type {[number, number, number, number]} */
+    const groupsOfSix = [undefined, undefined, undefined, undefined];
+    groupsOfSix[0] = str.charCodeAt(i) >> 2;
+    groupsOfSix[1] = (str.charCodeAt(i) & 0x03) << 4;
+    if (str.length > i + 1) {
+      groupsOfSix[1] |= str.charCodeAt(i + 1) >> 4;
+      groupsOfSix[2] = (str.charCodeAt(i + 1) & 0x0f) << 2;
+    }
+    if (str.length > i + 2) {
+      groupsOfSix[2] |= str.charCodeAt(i + 2) >> 6;
+      groupsOfSix[3] = str.charCodeAt(i + 2) & 0x3f;
+    }
+    for (let j = 0; j < groupsOfSix.length; j++) {
+      if (typeof groupsOfSix[j] === "undefined") {
+        out += "=";
+      } else {
+        out += KEY_STRING[groupsOfSix[j]];
+      }
+    }
+  }
+  return out;
+}

package/.output/server/node_modules/devalue/src/constants.js

@@ -0,0 +1,6 @@
+export const UNDEFINED = -1;
+export const HOLE = -2;
+export const NAN = -3;
+export const POSITIVE_INFINITY = -4;
+export const NEGATIVE_INFINITY = -5;
+export const NEGATIVE_ZERO = -6;