melonjs 16.1.0 → 16.1.2

package/dist/melonjs.mjs/node_modules/semver/node_modules/yallist/yallist.js

@@ -0,0 +1,444 @@
+/*!
+ * melonJS Game Engine - v16.1.2
+ * http://www.melonjs.org
+ * melonjs is licensed under the MIT License.
+ * http://www.opensource.org/licenses/mit-license
+ * @copyright (C) 2011 - 2024 Olivier Biot (AltByte Pte Ltd)
+ */
+import { __require as requireIterator } from './iterator.js';
+
+var yallist;
+var hasRequiredYallist;
+
+function requireYallist () {
+	if (hasRequiredYallist) return yallist;
+	hasRequiredYallist = 1;
+	yallist = Yallist;
+
+	Yallist.Node = Node;
+	Yallist.create = Yallist;
+
+	function Yallist (list) {
+	  var self = this;
+	  if (!(self instanceof Yallist)) {
+	    self = new Yallist();
+	  }
+
+	  self.tail = null;
+	  self.head = null;
+	  self.length = 0;
+
+	  if (list && typeof list.forEach === 'function') {
+	    list.forEach(function (item) {
+	      self.push(item);
+	    });
+	  } else if (arguments.length > 0) {
+	    for (var i = 0, l = arguments.length; i < l; i++) {
+	      self.push(arguments[i]);
+	    }
+	  }
+
+	  return self
+	}
+
+	Yallist.prototype.removeNode = function (node) {
+	  if (node.list !== this) {
+	    throw new Error('removing node which does not belong to this list')
+	  }
+
+	  var next = node.next;
+	  var prev = node.prev;
+
+	  if (next) {
+	    next.prev = prev;
+	  }
+
+	  if (prev) {
+	    prev.next = next;
+	  }
+
+	  if (node === this.head) {
+	    this.head = next;
+	  }
+	  if (node === this.tail) {
+	    this.tail = prev;
+	  }
+
+	  node.list.length--;
+	  node.next = null;
+	  node.prev = null;
+	  node.list = null;
+
+	  return next
+	};
+
+	Yallist.prototype.unshiftNode = function (node) {
+	  if (node === this.head) {
+	    return
+	  }
+
+	  if (node.list) {
+	    node.list.removeNode(node);
+	  }
+
+	  var head = this.head;
+	  node.list = this;
+	  node.next = head;
+	  if (head) {
+	    head.prev = node;
+	  }
+
+	  this.head = node;
+	  if (!this.tail) {
+	    this.tail = node;
+	  }
+	  this.length++;
+	};
+
+	Yallist.prototype.pushNode = function (node) {
+	  if (node === this.tail) {
+	    return
+	  }
+
+	  if (node.list) {
+	    node.list.removeNode(node);
+	  }
+
+	  var tail = this.tail;
+	  node.list = this;
+	  node.prev = tail;
+	  if (tail) {
+	    tail.next = node;
+	  }
+
+	  this.tail = node;
+	  if (!this.head) {
+	    this.head = node;
+	  }
+	  this.length++;
+	};
+
+	Yallist.prototype.push = function () {
+	  for (var i = 0, l = arguments.length; i < l; i++) {
+	    push(this, arguments[i]);
+	  }
+	  return this.length
+	};
+
+	Yallist.prototype.unshift = function () {
+	  for (var i = 0, l = arguments.length; i < l; i++) {
+	    unshift(this, arguments[i]);
+	  }
+	  return this.length
+	};
+
+	Yallist.prototype.pop = function () {
+	  if (!this.tail) {
+	    return undefined
+	  }
+
+	  var res = this.tail.value;
+	  this.tail = this.tail.prev;
+	  if (this.tail) {
+	    this.tail.next = null;
+	  } else {
+	    this.head = null;
+	  }
+	  this.length--;
+	  return res
+	};
+
+	Yallist.prototype.shift = function () {
+	  if (!this.head) {
+	    return undefined
+	  }
+
+	  var res = this.head.value;
+	  this.head = this.head.next;
+	  if (this.head) {
+	    this.head.prev = null;
+	  } else {
+	    this.tail = null;
+	  }
+	  this.length--;
+	  return res
+	};
+
+	Yallist.prototype.forEach = function (fn, thisp) {
+	  thisp = thisp || this;
+	  for (var walker = this.head, i = 0; walker !== null; i++) {
+	    fn.call(thisp, walker.value, i, this);
+	    walker = walker.next;
+	  }
+	};
+
+	Yallist.prototype.forEachReverse = function (fn, thisp) {
+	  thisp = thisp || this;
+	  for (var walker = this.tail, i = this.length - 1; walker !== null; i--) {
+	    fn.call(thisp, walker.value, i, this);
+	    walker = walker.prev;
+	  }
+	};
+
+	Yallist.prototype.get = function (n) {
+	  for (var i = 0, walker = this.head; walker !== null && i < n; i++) {
+	    // abort out of the list early if we hit a cycle
+	    walker = walker.next;
+	  }
+	  if (i === n && walker !== null) {
+	    return walker.value
+	  }
+	};
+
+	Yallist.prototype.getReverse = function (n) {
+	  for (var i = 0, walker = this.tail; walker !== null && i < n; i++) {
+	    // abort out of the list early if we hit a cycle
+	    walker = walker.prev;
+	  }
+	  if (i === n && walker !== null) {
+	    return walker.value
+	  }
+	};
+
+	Yallist.prototype.map = function (fn, thisp) {
+	  thisp = thisp || this;
+	  var res = new Yallist();
+	  for (var walker = this.head; walker !== null;) {
+	    res.push(fn.call(thisp, walker.value, this));
+	    walker = walker.next;
+	  }
+	  return res
+	};
+
+	Yallist.prototype.mapReverse = function (fn, thisp) {
+	  thisp = thisp || this;
+	  var res = new Yallist();
+	  for (var walker = this.tail; walker !== null;) {
+	    res.push(fn.call(thisp, walker.value, this));
+	    walker = walker.prev;
+	  }
+	  return res
+	};
+
+	Yallist.prototype.reduce = function (fn, initial) {
+	  var acc;
+	  var walker = this.head;
+	  if (arguments.length > 1) {
+	    acc = initial;
+	  } else if (this.head) {
+	    walker = this.head.next;
+	    acc = this.head.value;
+	  } else {
+	    throw new TypeError('Reduce of empty list with no initial value')
+	  }
+
+	  for (var i = 0; walker !== null; i++) {
+	    acc = fn(acc, walker.value, i);
+	    walker = walker.next;
+	  }
+
+	  return acc
+	};
+
+	Yallist.prototype.reduceReverse = function (fn, initial) {
+	  var acc;
+	  var walker = this.tail;
+	  if (arguments.length > 1) {
+	    acc = initial;
+	  } else if (this.tail) {
+	    walker = this.tail.prev;
+	    acc = this.tail.value;
+	  } else {
+	    throw new TypeError('Reduce of empty list with no initial value')
+	  }
+
+	  for (var i = this.length - 1; walker !== null; i--) {
+	    acc = fn(acc, walker.value, i);
+	    walker = walker.prev;
+	  }
+
+	  return acc
+	};
+
+	Yallist.prototype.toArray = function () {
+	  var arr = new Array(this.length);
+	  for (var i = 0, walker = this.head; walker !== null; i++) {
+	    arr[i] = walker.value;
+	    walker = walker.next;
+	  }
+	  return arr
+	};
+
+	Yallist.prototype.toArrayReverse = function () {
+	  var arr = new Array(this.length);
+	  for (var i = 0, walker = this.tail; walker !== null; i++) {
+	    arr[i] = walker.value;
+	    walker = walker.prev;
+	  }
+	  return arr
+	};
+
+	Yallist.prototype.slice = function (from, to) {
+	  to = to || this.length;
+	  if (to < 0) {
+	    to += this.length;
+	  }
+	  from = from || 0;
+	  if (from < 0) {
+	    from += this.length;
+	  }
+	  var ret = new Yallist();
+	  if (to < from || to < 0) {
+	    return ret
+	  }
+	  if (from < 0) {
+	    from = 0;
+	  }
+	  if (to > this.length) {
+	    to = this.length;
+	  }
+	  for (var i = 0, walker = this.head; walker !== null && i < from; i++) {
+	    walker = walker.next;
+	  }
+	  for (; walker !== null && i < to; i++, walker = walker.next) {
+	    ret.push(walker.value);
+	  }
+	  return ret
+	};
+
+	Yallist.prototype.sliceReverse = function (from, to) {
+	  to = to || this.length;
+	  if (to < 0) {
+	    to += this.length;
+	  }
+	  from = from || 0;
+	  if (from < 0) {
+	    from += this.length;
+	  }
+	  var ret = new Yallist();
+	  if (to < from || to < 0) {
+	    return ret
+	  }
+	  if (from < 0) {
+	    from = 0;
+	  }
+	  if (to > this.length) {
+	    to = this.length;
+	  }
+	  for (var i = this.length, walker = this.tail; walker !== null && i > to; i--) {
+	    walker = walker.prev;
+	  }
+	  for (; walker !== null && i > from; i--, walker = walker.prev) {
+	    ret.push(walker.value);
+	  }
+	  return ret
+	};
+
+	Yallist.prototype.splice = function (start, deleteCount, ...nodes) {
+	  if (start > this.length) {
+	    start = this.length - 1;
+	  }
+	  if (start < 0) {
+	    start = this.length + start;
+	  }
+
+	  for (var i = 0, walker = this.head; walker !== null && i < start; i++) {
+	    walker = walker.next;
+	  }
+
+	  var ret = [];
+	  for (var i = 0; walker && i < deleteCount; i++) {
+	    ret.push(walker.value);
+	    walker = this.removeNode(walker);
+	  }
+	  if (walker === null) {
+	    walker = this.tail;
+	  }
+
+	  if (walker !== this.head && walker !== this.tail) {
+	    walker = walker.prev;
+	  }
+
+	  for (var i = 0; i < nodes.length; i++) {
+	    walker = insert(this, walker, nodes[i]);
+	  }
+	  return ret;
+	};
+
+	Yallist.prototype.reverse = function () {
+	  var head = this.head;
+	  var tail = this.tail;
+	  for (var walker = head; walker !== null; walker = walker.prev) {
+	    var p = walker.prev;
+	    walker.prev = walker.next;
+	    walker.next = p;
+	  }
+	  this.head = tail;
+	  this.tail = head;
+	  return this
+	};
+
+	function insert (self, node, value) {
+	  var inserted = node === self.head ?
+	    new Node(value, null, node, self) :
+	    new Node(value, node, node.next, self);
+
+	  if (inserted.next === null) {
+	    self.tail = inserted;
+	  }
+	  if (inserted.prev === null) {
+	    self.head = inserted;
+	  }
+
+	  self.length++;
+
+	  return inserted
+	}
+
+	function push (self, item) {
+	  self.tail = new Node(item, self.tail, null, self);
+	  if (!self.head) {
+	    self.head = self.tail;
+	  }
+	  self.length++;
+	}
+
+	function unshift (self, item) {
+	  self.head = new Node(item, null, self.head, self);
+	  if (!self.tail) {
+	    self.tail = self.head;
+	  }
+	  self.length++;
+	}
+
+	function Node (value, prev, next, list) {
+	  if (!(this instanceof Node)) {
+	    return new Node(value, prev, next, list)
+	  }
+
+	  this.list = list;
+	  this.value = value;
+
+	  if (prev) {
+	    prev.next = this;
+	    this.prev = prev;
+	  } else {
+	    this.prev = null;
+	  }
+
+	  if (next) {
+	    next.prev = this;
+	    this.next = next;
+	  } else {
+	    this.next = null;
+	  }
+	}
+
+	try {
+	  // add if support for Symbol.iterator is present
+	  requireIterator()(Yallist);
+	} catch (er) {}
+	return yallist;
+}
+
+export { requireYallist as __require };

package/dist/melonjs.mjs/node_modules/semver/ranges/gtr.js

@@ -0,0 +1,15 @@
+/*!
+ * melonJS Game Engine - v16.1.2
+ * http://www.melonjs.org
+ * melonjs is licensed under the MIT License.
+ * http://www.opensource.org/licenses/mit-license
+ * @copyright (C) 2011 - 2024 Olivier Biot (AltByte Pte Ltd)
+ */
+import { o as outside_1 } from './outside.js';
+
+// Determine if version is greater than all the versions possible in the range.
+const outside = outside_1;
+const gtr = (version, range, options) => outside(version, range, '>', options);
+var gtr_1 = gtr;
+
+export { gtr_1 as g };

package/dist/melonjs.mjs/node_modules/semver/ranges/intersects.js

@@ -0,0 +1,18 @@
+/*!
+ * melonJS Game Engine - v16.1.2
+ * http://www.melonjs.org
+ * melonjs is licensed under the MIT License.
+ * http://www.opensource.org/licenses/mit-license
+ * @copyright (C) 2011 - 2024 Olivier Biot (AltByte Pte Ltd)
+ */
+import { __require as requireRange } from '../classes/range.js';
+
+const Range = requireRange();
+const intersects = (r1, r2, options) => {
+  r1 = new Range(r1, options);
+  r2 = new Range(r2, options);
+  return r1.intersects(r2, options)
+};
+var intersects_1 = intersects;
+
+export { intersects_1 as i };

package/dist/melonjs.mjs/node_modules/semver/ranges/ltr.js

@@ -0,0 +1,15 @@
+/*!
+ * melonJS Game Engine - v16.1.2
+ * http://www.melonjs.org
+ * melonjs is licensed under the MIT License.
+ * http://www.opensource.org/licenses/mit-license
+ * @copyright (C) 2011 - 2024 Olivier Biot (AltByte Pte Ltd)
+ */
+import { o as outside_1 } from './outside.js';
+
+const outside = outside_1;
+// Determine if version is less than all the versions possible in the range
+const ltr = (version, range, options) => outside(version, range, '<', options);
+var ltr_1 = ltr;
+
+export { ltr_1 as l };

package/dist/melonjs.mjs/node_modules/semver/ranges/max-satisfying.js

@@ -0,0 +1,37 @@
+/*!
+ * melonJS Game Engine - v16.1.2
+ * http://www.melonjs.org
+ * melonjs is licensed under the MIT License.
+ * http://www.opensource.org/licenses/mit-license
+ * @copyright (C) 2011 - 2024 Olivier Biot (AltByte Pte Ltd)
+ */
+import { s as semver } from '../classes/semver.js';
+import { __require as requireRange } from '../classes/range.js';
+
+const SemVer = semver;
+const Range = requireRange();
+
+const maxSatisfying = (versions, range, options) => {
+  let max = null;
+  let maxSV = null;
+  let rangeObj = null;
+  try {
+    rangeObj = new Range(range, options);
+  } catch (er) {
+    return null
+  }
+  versions.forEach((v) => {
+    if (rangeObj.test(v)) {
+      // satisfies(v, range, options)
+      if (!max || maxSV.compare(v) === -1) {
+        // compare(max, v, true)
+        max = v;
+        maxSV = new SemVer(max, options);
+      }
+    }
+  });
+  return max
+};
+var maxSatisfying_1 = maxSatisfying;
+
+export { maxSatisfying_1 as m };

package/dist/melonjs.mjs/node_modules/semver/ranges/min-satisfying.js

@@ -0,0 +1,36 @@
+/*!
+ * melonJS Game Engine - v16.1.2
+ * http://www.melonjs.org
+ * melonjs is licensed under the MIT License.
+ * http://www.opensource.org/licenses/mit-license
+ * @copyright (C) 2011 - 2024 Olivier Biot (AltByte Pte Ltd)
+ */
+import { s as semver } from '../classes/semver.js';
+import { __require as requireRange } from '../classes/range.js';
+
+const SemVer = semver;
+const Range = requireRange();
+const minSatisfying = (versions, range, options) => {
+  let min = null;
+  let minSV = null;
+  let rangeObj = null;
+  try {
+    rangeObj = new Range(range, options);
+  } catch (er) {
+    return null
+  }
+  versions.forEach((v) => {
+    if (rangeObj.test(v)) {
+      // satisfies(v, range, options)
+      if (!min || minSV.compare(v) === 1) {
+        // compare(min, v, true)
+        min = v;
+        minSV = new SemVer(min, options);
+      }
+    }
+  });
+  return min
+};
+var minSatisfying_1 = minSatisfying;
+
+export { minSatisfying_1 as m };

package/dist/melonjs.mjs/node_modules/semver/ranges/min-version.js

@@ -0,0 +1,74 @@
+/*!
+ * melonJS Game Engine - v16.1.2
+ * http://www.melonjs.org
+ * melonjs is licensed under the MIT License.
+ * http://www.opensource.org/licenses/mit-license
+ * @copyright (C) 2011 - 2024 Olivier Biot (AltByte Pte Ltd)
+ */
+import { s as semver } from '../classes/semver.js';
+import { __require as requireRange } from '../classes/range.js';
+import { g as gt_1 } from '../functions/gt.js';
+
+const SemVer = semver;
+const Range = requireRange();
+const gt = gt_1;
+
+const minVersion = (range, loose) => {
+  range = new Range(range, loose);
+
+  let minver = new SemVer('0.0.0');
+  if (range.test(minver)) {
+    return minver
+  }
+
+  minver = new SemVer('0.0.0-0');
+  if (range.test(minver)) {
+    return minver
+  }
+
+  minver = null;
+  for (let i = 0; i < range.set.length; ++i) {
+    const comparators = range.set[i];
+
+    let setMin = null;
+    comparators.forEach((comparator) => {
+      // Clone to avoid manipulating the comparator's semver object.
+      const compver = new SemVer(comparator.semver.version);
+      switch (comparator.operator) {
+        case '>':
+          if (compver.prerelease.length === 0) {
+            compver.patch++;
+          } else {
+            compver.prerelease.push(0);
+          }
+          compver.raw = compver.format();
+          /* fallthrough */
+        case '':
+        case '>=':
+          if (!setMin || gt(compver, setMin)) {
+            setMin = compver;
+          }
+          break
+        case '<':
+        case '<=':
+          /* Ignore maximum versions */
+          break
+        /* istanbul ignore next */
+        default:
+          throw new Error(`Unexpected operation: ${comparator.operator}`)
+      }
+    });
+    if (setMin && (!minver || gt(minver, setMin))) {
+      minver = setMin;
+    }
+  }
+
+  if (minver && range.test(minver)) {
+    return minver
+  }
+
+  return null
+};
+var minVersion_1 = minVersion;
+
+export { minVersion_1 as m };