tiny-essentials 1.11.0 → 1.12.1

package/dist/v1/TinyDragger.js

@@ -0,0 +1,3668 @@
+/******/ (() => { // webpackBootstrap
+/******/ 	var __webpack_modules__ = ({
+
+/***/ 251:
+/***/ ((__unused_webpack_module, exports) => {
+
+/*! ieee754. BSD-3-Clause License. Feross Aboukhadijeh <https://feross.org/opensource> */
+exports.read = function (buffer, offset, isLE, mLen, nBytes) {
+  var e, m
+  var eLen = (nBytes * 8) - mLen - 1
+  var eMax = (1 << eLen) - 1
+  var eBias = eMax >> 1
+  var nBits = -7
+  var i = isLE ? (nBytes - 1) : 0
+  var d = isLE ? -1 : 1
+  var s = buffer[offset + i]
+
+  i += d
+
+  e = s & ((1 << (-nBits)) - 1)
+  s >>= (-nBits)
+  nBits += eLen
+  for (; nBits > 0; e = (e * 256) + buffer[offset + i], i += d, nBits -= 8) {}
+
+  m = e & ((1 << (-nBits)) - 1)
+  e >>= (-nBits)
+  nBits += mLen
+  for (; nBits > 0; m = (m * 256) + buffer[offset + i], i += d, nBits -= 8) {}
+
+  if (e === 0) {
+    e = 1 - eBias
+  } else if (e === eMax) {
+    return m ? NaN : ((s ? -1 : 1) * Infinity)
+  } else {
+    m = m + Math.pow(2, mLen)
+    e = e - eBias
+  }
+  return (s ? -1 : 1) * m * Math.pow(2, e - mLen)
+}
+
+exports.write = function (buffer, value, offset, isLE, mLen, nBytes) {
+  var e, m, c
+  var eLen = (nBytes * 8) - mLen - 1
+  var eMax = (1 << eLen) - 1
+  var eBias = eMax >> 1
+  var rt = (mLen === 23 ? Math.pow(2, -24) - Math.pow(2, -77) : 0)
+  var i = isLE ? 0 : (nBytes - 1)
+  var d = isLE ? 1 : -1
+  var s = value < 0 || (value === 0 && 1 / value < 0) ? 1 : 0
+
+  value = Math.abs(value)
+
+  if (isNaN(value) || value === Infinity) {
+    m = isNaN(value) ? 1 : 0
+    e = eMax
+  } else {
+    e = Math.floor(Math.log(value) / Math.LN2)
+    if (value * (c = Math.pow(2, -e)) < 1) {
+      e--
+      c *= 2
+    }
+    if (e + eBias >= 1) {
+      value += rt / c
+    } else {
+      value += rt * Math.pow(2, 1 - eBias)
+    }
+    if (value * c >= 2) {
+      e++
+      c /= 2
+    }
+
+    if (e + eBias >= eMax) {
+      m = 0
+      e = eMax
+    } else if (e + eBias >= 1) {
+      m = ((value * c) - 1) * Math.pow(2, mLen)
+      e = e + eBias
+    } else {
+      m = value * Math.pow(2, eBias - 1) * Math.pow(2, mLen)
+      e = 0
+    }
+  }
+
+  for (; mLen >= 8; buffer[offset + i] = m & 0xff, i += d, m /= 256, mLen -= 8) {}
+
+  e = (e << mLen) | m
+  eLen += mLen
+  for (; eLen > 0; buffer[offset + i] = e & 0xff, i += d, e /= 256, eLen -= 8) {}
+
+  buffer[offset + i - d] |= s * 128
+}
+
+
+/***/ }),
+
+/***/ 287:
+/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
+
+"use strict";
+var __webpack_unused_export__;
+/*!
+ * The buffer module from node.js, for the browser.
+ *
+ * @author   Feross Aboukhadijeh <https://feross.org>
+ * @license  MIT
+ */
+/* eslint-disable no-proto */
+
+
+
+var base64 = __webpack_require__(526)
+var ieee754 = __webpack_require__(251)
+var customInspectSymbol =
+  (typeof Symbol === 'function' && typeof Symbol['for'] === 'function') // eslint-disable-line dot-notation
+    ? Symbol['for']('nodejs.util.inspect.custom') // eslint-disable-line dot-notation
+    : null
+
+exports.hp = Buffer
+__webpack_unused_export__ = SlowBuffer
+exports.IS = 50
+
+var K_MAX_LENGTH = 0x7fffffff
+__webpack_unused_export__ = K_MAX_LENGTH
+
+/**
+ * If `Buffer.TYPED_ARRAY_SUPPORT`:
+ *   === true    Use Uint8Array implementation (fastest)
+ *   === false   Print warning and recommend using `buffer` v4.x which has an Object
+ *               implementation (most compatible, even IE6)
+ *
+ * Browsers that support typed arrays are IE 10+, Firefox 4+, Chrome 7+, Safari 5.1+,
+ * Opera 11.6+, iOS 4.2+.
+ *
+ * We report that the browser does not support typed arrays if the are not subclassable
+ * using __proto__. Firefox 4-29 lacks support for adding new properties to `Uint8Array`
+ * (See: https://bugzilla.mozilla.org/show_bug.cgi?id=695438). IE 10 lacks support
+ * for __proto__ and has a buggy typed array implementation.
+ */
+Buffer.TYPED_ARRAY_SUPPORT = typedArraySupport()
+
+if (!Buffer.TYPED_ARRAY_SUPPORT && typeof console !== 'undefined' &&
+    typeof console.error === 'function') {
+  console.error(
+    'This browser lacks typed array (Uint8Array) support which is required by ' +
+    '`buffer` v5.x. Use `buffer` v4.x if you require old browser support.'
+  )
+}
+
+function typedArraySupport () {
+  // Can typed array instances can be augmented?
+  try {
+    var arr = new Uint8Array(1)
+    var proto = { foo: function () { return 42 } }
+    Object.setPrototypeOf(proto, Uint8Array.prototype)
+    Object.setPrototypeOf(arr, proto)
+    return arr.foo() === 42
+  } catch (e) {
+    return false
+  }
+}
+
+Object.defineProperty(Buffer.prototype, 'parent', {
+  enumerable: true,
+  get: function () {
+    if (!Buffer.isBuffer(this)) return undefined
+    return this.buffer
+  }
+})
+
+Object.defineProperty(Buffer.prototype, 'offset', {
+  enumerable: true,
+  get: function () {
+    if (!Buffer.isBuffer(this)) return undefined
+    return this.byteOffset
+  }
+})
+
+function createBuffer (length) {
+  if (length > K_MAX_LENGTH) {
+    throw new RangeError('The value "' + length + '" is invalid for option "size"')
+  }
+  // Return an augmented `Uint8Array` instance
+  var buf = new Uint8Array(length)
+  Object.setPrototypeOf(buf, Buffer.prototype)
+  return buf
+}
+
+/**
+ * The Buffer constructor returns instances of `Uint8Array` that have their
+ * prototype changed to `Buffer.prototype`. Furthermore, `Buffer` is a subclass of
+ * `Uint8Array`, so the returned instances will have all the node `Buffer` methods
+ * and the `Uint8Array` methods. Square bracket notation works as expected -- it
+ * returns a single octet.
+ *
+ * The `Uint8Array` prototype remains unmodified.
+ */
+
+function Buffer (arg, encodingOrOffset, length) {
+  // Common case.
+  if (typeof arg === 'number') {
+    if (typeof encodingOrOffset === 'string') {
+      throw new TypeError(
+        'The "string" argument must be of type string. Received type number'
+      )
+    }
+    return allocUnsafe(arg)
+  }
+  return from(arg, encodingOrOffset, length)
+}
+
+Buffer.poolSize = 8192 // not used by this implementation
+
+function from (value, encodingOrOffset, length) {
+  if (typeof value === 'string') {
+    return fromString(value, encodingOrOffset)
+  }
+
+  if (ArrayBuffer.isView(value)) {
+    return fromArrayView(value)
+  }
+
+  if (value == null) {
+    throw new TypeError(
+      'The first argument must be one of type string, Buffer, ArrayBuffer, Array, ' +
+      'or Array-like Object. Received type ' + (typeof value)
+    )
+  }
+
+  if (isInstance(value, ArrayBuffer) ||
+      (value && isInstance(value.buffer, ArrayBuffer))) {
+    return fromArrayBuffer(value, encodingOrOffset, length)
+  }
+
+  if (typeof SharedArrayBuffer !== 'undefined' &&
+      (isInstance(value, SharedArrayBuffer) ||
+      (value && isInstance(value.buffer, SharedArrayBuffer)))) {
+    return fromArrayBuffer(value, encodingOrOffset, length)
+  }
+
+  if (typeof value === 'number') {
+    throw new TypeError(
+      'The "value" argument must not be of type number. Received type number'
+    )
+  }
+
+  var valueOf = value.valueOf && value.valueOf()
+  if (valueOf != null && valueOf !== value) {
+    return Buffer.from(valueOf, encodingOrOffset, length)
+  }
+
+  var b = fromObject(value)
+  if (b) return b
+
+  if (typeof Symbol !== 'undefined' && Symbol.toPrimitive != null &&
+      typeof value[Symbol.toPrimitive] === 'function') {
+    return Buffer.from(
+      value[Symbol.toPrimitive]('string'), encodingOrOffset, length
+    )
+  }
+
+  throw new TypeError(
+    'The first argument must be one of type string, Buffer, ArrayBuffer, Array, ' +
+    'or Array-like Object. Received type ' + (typeof value)
+  )
+}
+
+/**
+ * Functionally equivalent to Buffer(arg, encoding) but throws a TypeError
+ * if value is a number.
+ * Buffer.from(str[, encoding])
+ * Buffer.from(array)
+ * Buffer.from(buffer)
+ * Buffer.from(arrayBuffer[, byteOffset[, length]])
+ **/
+Buffer.from = function (value, encodingOrOffset, length) {
+  return from(value, encodingOrOffset, length)
+}
+
+// Note: Change prototype *after* Buffer.from is defined to workaround Chrome bug:
+// https://github.com/feross/buffer/pull/148
+Object.setPrototypeOf(Buffer.prototype, Uint8Array.prototype)
+Object.setPrototypeOf(Buffer, Uint8Array)
+
+function assertSize (size) {
+  if (typeof size !== 'number') {
+    throw new TypeError('"size" argument must be of type number')
+  } else if (size < 0) {
+    throw new RangeError('The value "' + size + '" is invalid for option "size"')
+  }
+}
+
+function alloc (size, fill, encoding) {
+  assertSize(size)
+  if (size <= 0) {
+    return createBuffer(size)
+  }
+  if (fill !== undefined) {
+    // Only pay attention to encoding if it's a string. This
+    // prevents accidentally sending in a number that would
+    // be interpreted as a start offset.
+    return typeof encoding === 'string'
+      ? createBuffer(size).fill(fill, encoding)
+      : createBuffer(size).fill(fill)
+  }
+  return createBuffer(size)
+}
+
+/**
+ * Creates a new filled Buffer instance.
+ * alloc(size[, fill[, encoding]])
+ **/
+Buffer.alloc = function (size, fill, encoding) {
+  return alloc(size, fill, encoding)
+}
+
+function allocUnsafe (size) {
+  assertSize(size)
+  return createBuffer(size < 0 ? 0 : checked(size) | 0)
+}
+
+/**
+ * Equivalent to Buffer(num), by default creates a non-zero-filled Buffer instance.
+ * */
+Buffer.allocUnsafe = function (size) {
+  return allocUnsafe(size)
+}
+/**
+ * Equivalent to SlowBuffer(num), by default creates a non-zero-filled Buffer instance.
+ */
+Buffer.allocUnsafeSlow = function (size) {
+  return allocUnsafe(size)
+}
+
+function fromString (string, encoding) {
+  if (typeof encoding !== 'string' || encoding === '') {
+    encoding = 'utf8'
+  }
+
+  if (!Buffer.isEncoding(encoding)) {
+    throw new TypeError('Unknown encoding: ' + encoding)
+  }
+
+  var length = byteLength(string, encoding) | 0
+  var buf = createBuffer(length)
+
+  var actual = buf.write(string, encoding)
+
+  if (actual !== length) {
+    // Writing a hex string, for example, that contains invalid characters will
+    // cause everything after the first invalid character to be ignored. (e.g.
+    // 'abxxcd' will be treated as 'ab')
+    buf = buf.slice(0, actual)
+  }
+
+  return buf
+}
+
+function fromArrayLike (array) {
+  var length = array.length < 0 ? 0 : checked(array.length) | 0
+  var buf = createBuffer(length)
+  for (var i = 0; i < length; i += 1) {
+    buf[i] = array[i] & 255
+  }
+  return buf
+}
+
+function fromArrayView (arrayView) {
+  if (isInstance(arrayView, Uint8Array)) {
+    var copy = new Uint8Array(arrayView)
+    return fromArrayBuffer(copy.buffer, copy.byteOffset, copy.byteLength)
+  }
+  return fromArrayLike(arrayView)
+}
+
+function fromArrayBuffer (array, byteOffset, length) {
+  if (byteOffset < 0 || array.byteLength < byteOffset) {
+    throw new RangeError('"offset" is outside of buffer bounds')
+  }
+
+  if (array.byteLength < byteOffset + (length || 0)) {
+    throw new RangeError('"length" is outside of buffer bounds')
+  }
+
+  var buf
+  if (byteOffset === undefined && length === undefined) {
+    buf = new Uint8Array(array)
+  } else if (length === undefined) {
+    buf = new Uint8Array(array, byteOffset)
+  } else {
+    buf = new Uint8Array(array, byteOffset, length)
+  }
+
+  // Return an augmented `Uint8Array` instance
+  Object.setPrototypeOf(buf, Buffer.prototype)
+
+  return buf
+}
+
+function fromObject (obj) {
+  if (Buffer.isBuffer(obj)) {
+    var len = checked(obj.length) | 0
+    var buf = createBuffer(len)
+
+    if (buf.length === 0) {
+      return buf
+    }
+
+    obj.copy(buf, 0, 0, len)
+    return buf
+  }
+
+  if (obj.length !== undefined) {
+    if (typeof obj.length !== 'number' || numberIsNaN(obj.length)) {
+      return createBuffer(0)
+    }
+    return fromArrayLike(obj)
+  }
+
+  if (obj.type === 'Buffer' && Array.isArray(obj.data)) {
+    return fromArrayLike(obj.data)
+  }
+}
+
+function checked (length) {
+  // Note: cannot use `length < K_MAX_LENGTH` here because that fails when
+  // length is NaN (which is otherwise coerced to zero.)
+  if (length >= K_MAX_LENGTH) {
+    throw new RangeError('Attempt to allocate Buffer larger than maximum ' +
+                         'size: 0x' + K_MAX_LENGTH.toString(16) + ' bytes')
+  }
+  return length | 0
+}
+
+function SlowBuffer (length) {
+  if (+length != length) { // eslint-disable-line eqeqeq
+    length = 0
+  }
+  return Buffer.alloc(+length)
+}
+
+Buffer.isBuffer = function isBuffer (b) {
+  return b != null && b._isBuffer === true &&
+    b !== Buffer.prototype // so Buffer.isBuffer(Buffer.prototype) will be false
+}
+
+Buffer.compare = function compare (a, b) {
+  if (isInstance(a, Uint8Array)) a = Buffer.from(a, a.offset, a.byteLength)
+  if (isInstance(b, Uint8Array)) b = Buffer.from(b, b.offset, b.byteLength)
+  if (!Buffer.isBuffer(a) || !Buffer.isBuffer(b)) {
+    throw new TypeError(
+      'The "buf1", "buf2" arguments must be one of type Buffer or Uint8Array'
+    )
+  }
+
+  if (a === b) return 0
+
+  var x = a.length
+  var y = b.length
+
+  for (var i = 0, len = Math.min(x, y); i < len; ++i) {
+    if (a[i] !== b[i]) {
+      x = a[i]
+      y = b[i]
+      break
+    }
+  }
+
+  if (x < y) return -1
+  if (y < x) return 1
+  return 0
+}
+
+Buffer.isEncoding = function isEncoding (encoding) {
+  switch (String(encoding).toLowerCase()) {
+    case 'hex':
+    case 'utf8':
+    case 'utf-8':
+    case 'ascii':
+    case 'latin1':
+    case 'binary':
+    case 'base64':
+    case 'ucs2':
+    case 'ucs-2':
+    case 'utf16le':
+    case 'utf-16le':
+      return true
+    default:
+      return false
+  }
+}
+
+Buffer.concat = function concat (list, length) {
+  if (!Array.isArray(list)) {
+    throw new TypeError('"list" argument must be an Array of Buffers')
+  }
+
+  if (list.length === 0) {
+    return Buffer.alloc(0)
+  }
+
+  var i
+  if (length === undefined) {
+    length = 0
+    for (i = 0; i < list.length; ++i) {
+      length += list[i].length
+    }
+  }
+
+  var buffer = Buffer.allocUnsafe(length)
+  var pos = 0
+  for (i = 0; i < list.length; ++i) {
+    var buf = list[i]
+    if (isInstance(buf, Uint8Array)) {
+      if (pos + buf.length > buffer.length) {
+        Buffer.from(buf).copy(buffer, pos)
+      } else {
+        Uint8Array.prototype.set.call(
+          buffer,
+          buf,
+          pos
+        )
+      }
+    } else if (!Buffer.isBuffer(buf)) {
+      throw new TypeError('"list" argument must be an Array of Buffers')
+    } else {
+      buf.copy(buffer, pos)
+    }
+    pos += buf.length
+  }
+  return buffer
+}
+
+function byteLength (string, encoding) {
+  if (Buffer.isBuffer(string)) {
+    return string.length
+  }
+  if (ArrayBuffer.isView(string) || isInstance(string, ArrayBuffer)) {
+    return string.byteLength
+  }
+  if (typeof string !== 'string') {
+    throw new TypeError(
+      'The "string" argument must be one of type string, Buffer, or ArrayBuffer. ' +
+      'Received type ' + typeof string
+    )
+  }
+
+  var len = string.length
+  var mustMatch = (arguments.length > 2 && arguments[2] === true)
+  if (!mustMatch && len === 0) return 0
+
+  // Use a for loop to avoid recursion
+  var loweredCase = false
+  for (;;) {
+    switch (encoding) {
+      case 'ascii':
+      case 'latin1':
+      case 'binary':
+        return len
+      case 'utf8':
+      case 'utf-8':
+        return utf8ToBytes(string).length
+      case 'ucs2':
+      case 'ucs-2':
+      case 'utf16le':
+      case 'utf-16le':
+        return len * 2
+      case 'hex':
+        return len >>> 1
+      case 'base64':
+        return base64ToBytes(string).length
+      default:
+        if (loweredCase) {
+          return mustMatch ? -1 : utf8ToBytes(string).length // assume utf8
+        }
+        encoding = ('' + encoding).toLowerCase()
+        loweredCase = true
+    }
+  }
+}
+Buffer.byteLength = byteLength
+
+function slowToString (encoding, start, end) {
+  var loweredCase = false
+
+  // No need to verify that "this.length <= MAX_UINT32" since it's a read-only
+  // property of a typed array.
+
+  // This behaves neither like String nor Uint8Array in that we set start/end
+  // to their upper/lower bounds if the value passed is out of range.
+  // undefined is handled specially as per ECMA-262 6th Edition,
+  // Section 13.3.3.7 Runtime Semantics: KeyedBindingInitialization.
+  if (start === undefined || start < 0) {
+    start = 0
+  }
+  // Return early if start > this.length. Done here to prevent potential uint32
+  // coercion fail below.
+  if (start > this.length) {
+    return ''
+  }
+
+  if (end === undefined || end > this.length) {
+    end = this.length
+  }
+
+  if (end <= 0) {
+    return ''
+  }
+
+  // Force coercion to uint32. This will also coerce falsey/NaN values to 0.
+  end >>>= 0
+  start >>>= 0
+
+  if (end <= start) {
+    return ''
+  }
+
+  if (!encoding) encoding = 'utf8'
+
+  while (true) {
+    switch (encoding) {
+      case 'hex':
+        return hexSlice(this, start, end)
+
+      case 'utf8':
+      case 'utf-8':
+        return utf8Slice(this, start, end)
+
+      case 'ascii':
+        return asciiSlice(this, start, end)
+
+      case 'latin1':
+      case 'binary':
+        return latin1Slice(this, start, end)
+
+      case 'base64':
+        return base64Slice(this, start, end)
+
+      case 'ucs2':
+      case 'ucs-2':
+      case 'utf16le':
+      case 'utf-16le':
+        return utf16leSlice(this, start, end)
+
+      default:
+        if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding)
+        encoding = (encoding + '').toLowerCase()
+        loweredCase = true
+    }
+  }
+}
+
+// This property is used by `Buffer.isBuffer` (and the `is-buffer` npm package)
+// to detect a Buffer instance. It's not possible to use `instanceof Buffer`
+// reliably in a browserify context because there could be multiple different
+// copies of the 'buffer' package in use. This method works even for Buffer
+// instances that were created from another copy of the `buffer` package.
+// See: https://github.com/feross/buffer/issues/154
+Buffer.prototype._isBuffer = true
+
+function swap (b, n, m) {
+  var i = b[n]
+  b[n] = b[m]
+  b[m] = i
+}
+
+Buffer.prototype.swap16 = function swap16 () {
+  var len = this.length
+  if (len % 2 !== 0) {
+    throw new RangeError('Buffer size must be a multiple of 16-bits')
+  }
+  for (var i = 0; i < len; i += 2) {
+    swap(this, i, i + 1)
+  }
+  return this
+}
+
+Buffer.prototype.swap32 = function swap32 () {
+  var len = this.length
+  if (len % 4 !== 0) {
+    throw new RangeError('Buffer size must be a multiple of 32-bits')
+  }
+  for (var i = 0; i < len; i += 4) {
+    swap(this, i, i + 3)
+    swap(this, i + 1, i + 2)
+  }
+  return this
+}
+
+Buffer.prototype.swap64 = function swap64 () {
+  var len = this.length
+  if (len % 8 !== 0) {
+    throw new RangeError('Buffer size must be a multiple of 64-bits')
+  }
+  for (var i = 0; i < len; i += 8) {
+    swap(this, i, i + 7)
+    swap(this, i + 1, i + 6)
+    swap(this, i + 2, i + 5)
+    swap(this, i + 3, i + 4)
+  }
+  return this
+}
+
+Buffer.prototype.toString = function toString () {
+  var length = this.length
+  if (length === 0) return ''
+  if (arguments.length === 0) return utf8Slice(this, 0, length)
+  return slowToString.apply(this, arguments)
+}
+
+Buffer.prototype.toLocaleString = Buffer.prototype.toString
+
+Buffer.prototype.equals = function equals (b) {
+  if (!Buffer.isBuffer(b)) throw new TypeError('Argument must be a Buffer')
+  if (this === b) return true
+  return Buffer.compare(this, b) === 0
+}
+
+Buffer.prototype.inspect = function inspect () {
+  var str = ''
+  var max = exports.IS
+  str = this.toString('hex', 0, max).replace(/(.{2})/g, '$1 ').trim()
+  if (this.length > max) str += ' ... '
+  return '<Buffer ' + str + '>'
+}
+if (customInspectSymbol) {
+  Buffer.prototype[customInspectSymbol] = Buffer.prototype.inspect
+}
+
+Buffer.prototype.compare = function compare (target, start, end, thisStart, thisEnd) {
+  if (isInstance(target, Uint8Array)) {
+    target = Buffer.from(target, target.offset, target.byteLength)
+  }
+  if (!Buffer.isBuffer(target)) {
+    throw new TypeError(
+      'The "target" argument must be one of type Buffer or Uint8Array. ' +
+      'Received type ' + (typeof target)
+    )
+  }
+
+  if (start === undefined) {
+    start = 0
+  }
+  if (end === undefined) {
+    end = target ? target.length : 0
+  }
+  if (thisStart === undefined) {
+    thisStart = 0
+  }
+  if (thisEnd === undefined) {
+    thisEnd = this.length
+  }
+
+  if (start < 0 || end > target.length || thisStart < 0 || thisEnd > this.length) {
+    throw new RangeError('out of range index')
+  }
+
+  if (thisStart >= thisEnd && start >= end) {
+    return 0
+  }
+  if (thisStart >= thisEnd) {
+    return -1
+  }
+  if (start >= end) {
+    return 1
+  }
+
+  start >>>= 0
+  end >>>= 0
+  thisStart >>>= 0
+  thisEnd >>>= 0
+
+  if (this === target) return 0
+
+  var x = thisEnd - thisStart
+  var y = end - start
+  var len = Math.min(x, y)
+
+  var thisCopy = this.slice(thisStart, thisEnd)
+  var targetCopy = target.slice(start, end)
+
+  for (var i = 0; i < len; ++i) {
+    if (thisCopy[i] !== targetCopy[i]) {
+      x = thisCopy[i]
+      y = targetCopy[i]
+      break
+    }
+  }
+
+  if (x < y) return -1
+  if (y < x) return 1
+  return 0
+}
+
+// Finds either the first index of `val` in `buffer` at offset >= `byteOffset`,
+// OR the last index of `val` in `buffer` at offset <= `byteOffset`.
+//
+// Arguments:
+// - buffer - a Buffer to search
+// - val - a string, Buffer, or number
+// - byteOffset - an index into `buffer`; will be clamped to an int32
+// - encoding - an optional encoding, relevant is val is a string
+// - dir - true for indexOf, false for lastIndexOf
+function bidirectionalIndexOf (buffer, val, byteOffset, encoding, dir) {
+  // Empty buffer means no match
+  if (buffer.length === 0) return -1
+
+  // Normalize byteOffset
+  if (typeof byteOffset === 'string') {
+    encoding = byteOffset
+    byteOffset = 0
+  } else if (byteOffset > 0x7fffffff) {
+    byteOffset = 0x7fffffff
+  } else if (byteOffset < -0x80000000) {
+    byteOffset = -0x80000000
+  }
+  byteOffset = +byteOffset // Coerce to Number.
+  if (numberIsNaN(byteOffset)) {
+    // byteOffset: it it's undefined, null, NaN, "foo", etc, search whole buffer
+    byteOffset = dir ? 0 : (buffer.length - 1)
+  }
+
+  // Normalize byteOffset: negative offsets start from the end of the buffer
+  if (byteOffset < 0) byteOffset = buffer.length + byteOffset
+  if (byteOffset >= buffer.length) {
+    if (dir) return -1
+    else byteOffset = buffer.length - 1
+  } else if (byteOffset < 0) {
+    if (dir) byteOffset = 0
+    else return -1
+  }
+
+  // Normalize val
+  if (typeof val === 'string') {
+    val = Buffer.from(val, encoding)
+  }
+
+  // Finally, search either indexOf (if dir is true) or lastIndexOf
+  if (Buffer.isBuffer(val)) {
+    // Special case: looking for empty string/buffer always fails
+    if (val.length === 0) {
+      return -1
+    }
+    return arrayIndexOf(buffer, val, byteOffset, encoding, dir)
+  } else if (typeof val === 'number') {
+    val = val & 0xFF // Search for a byte value [0-255]
+    if (typeof Uint8Array.prototype.indexOf === 'function') {
+      if (dir) {
+        return Uint8Array.prototype.indexOf.call(buffer, val, byteOffset)
+      } else {
+        return Uint8Array.prototype.lastIndexOf.call(buffer, val, byteOffset)
+      }
+    }
+    return arrayIndexOf(buffer, [val], byteOffset, encoding, dir)
+  }
+
+  throw new TypeError('val must be string, number or Buffer')
+}
+
+function arrayIndexOf (arr, val, byteOffset, encoding, dir) {
+  var indexSize = 1
+  var arrLength = arr.length
+  var valLength = val.length
+
+  if (encoding !== undefined) {
+    encoding = String(encoding).toLowerCase()
+    if (encoding === 'ucs2' || encoding === 'ucs-2' ||
+        encoding === 'utf16le' || encoding === 'utf-16le') {
+      if (arr.length < 2 || val.length < 2) {
+        return -1
+      }
+      indexSize = 2
+      arrLength /= 2
+      valLength /= 2
+      byteOffset /= 2
+    }
+  }
+
+  function read (buf, i) {
+    if (indexSize === 1) {
+      return buf[i]
+    } else {
+      return buf.readUInt16BE(i * indexSize)
+    }
+  }
+
+  var i
+  if (dir) {
+    var foundIndex = -1
+    for (i = byteOffset; i < arrLength; i++) {
+      if (read(arr, i) === read(val, foundIndex === -1 ? 0 : i - foundIndex)) {
+        if (foundIndex === -1) foundIndex = i
+        if (i - foundIndex + 1 === valLength) return foundIndex * indexSize
+      } else {
+        if (foundIndex !== -1) i -= i - foundIndex
+        foundIndex = -1
+      }
+    }
+  } else {
+    if (byteOffset + valLength > arrLength) byteOffset = arrLength - valLength
+    for (i = byteOffset; i >= 0; i--) {
+      var found = true
+      for (var j = 0; j < valLength; j++) {
+        if (read(arr, i + j) !== read(val, j)) {
+          found = false
+          break
+        }
+      }
+      if (found) return i
+    }
+  }
+
+  return -1
+}
+
+Buffer.prototype.includes = function includes (val, byteOffset, encoding) {
+  return this.indexOf(val, byteOffset, encoding) !== -1
+}
+
+Buffer.prototype.indexOf = function indexOf (val, byteOffset, encoding) {
+  return bidirectionalIndexOf(this, val, byteOffset, encoding, true)
+}
+
+Buffer.prototype.lastIndexOf = function lastIndexOf (val, byteOffset, encoding) {
+  return bidirectionalIndexOf(this, val, byteOffset, encoding, false)
+}
+
+function hexWrite (buf, string, offset, length) {
+  offset = Number(offset) || 0
+  var remaining = buf.length - offset
+  if (!length) {
+    length = remaining
+  } else {
+    length = Number(length)
+    if (length > remaining) {
+      length = remaining
+    }
+  }
+
+  var strLen = string.length
+
+  if (length > strLen / 2) {
+    length = strLen / 2
+  }
+  for (var i = 0; i < length; ++i) {
+    var parsed = parseInt(string.substr(i * 2, 2), 16)
+    if (numberIsNaN(parsed)) return i
+    buf[offset + i] = parsed
+  }
+  return i
+}
+
+function utf8Write (buf, string, offset, length) {
+  return blitBuffer(utf8ToBytes(string, buf.length - offset), buf, offset, length)
+}
+
+function asciiWrite (buf, string, offset, length) {
+  return blitBuffer(asciiToBytes(string), buf, offset, length)
+}
+
+function base64Write (buf, string, offset, length) {
+  return blitBuffer(base64ToBytes(string), buf, offset, length)
+}
+
+function ucs2Write (buf, string, offset, length) {
+  return blitBuffer(utf16leToBytes(string, buf.length - offset), buf, offset, length)
+}
+
+Buffer.prototype.write = function write (string, offset, length, encoding) {
+  // Buffer#write(string)
+  if (offset === undefined) {
+    encoding = 'utf8'
+    length = this.length
+    offset = 0
+  // Buffer#write(string, encoding)
+  } else if (length === undefined && typeof offset === 'string') {
+    encoding = offset
+    length = this.length
+    offset = 0
+  // Buffer#write(string, offset[, length][, encoding])
+  } else if (isFinite(offset)) {
+    offset = offset >>> 0
+    if (isFinite(length)) {
+      length = length >>> 0
+      if (encoding === undefined) encoding = 'utf8'
+    } else {
+      encoding = length
+      length = undefined
+    }
+  } else {
+    throw new Error(
+      'Buffer.write(string, encoding, offset[, length]) is no longer supported'
+    )
+  }
+
+  var remaining = this.length - offset
+  if (length === undefined || length > remaining) length = remaining
+
+  if ((string.length > 0 && (length < 0 || offset < 0)) || offset > this.length) {
+    throw new RangeError('Attempt to write outside buffer bounds')
+  }
+
+  if (!encoding) encoding = 'utf8'
+
+  var loweredCase = false
+  for (;;) {
+    switch (encoding) {
+      case 'hex':
+        return hexWrite(this, string, offset, length)
+
+      case 'utf8':
+      case 'utf-8':
+        return utf8Write(this, string, offset, length)
+
+      case 'ascii':
+      case 'latin1':
+      case 'binary':
+        return asciiWrite(this, string, offset, length)
+
+      case 'base64':
+        // Warning: maxLength not taken into account in base64Write
+        return base64Write(this, string, offset, length)
+
+      case 'ucs2':
+      case 'ucs-2':
+      case 'utf16le':
+      case 'utf-16le':
+        return ucs2Write(this, string, offset, length)
+
+      default:
+        if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding)
+        encoding = ('' + encoding).toLowerCase()
+        loweredCase = true
+    }
+  }
+}
+
+Buffer.prototype.toJSON = function toJSON () {
+  return {
+    type: 'Buffer',
+    data: Array.prototype.slice.call(this._arr || this, 0)
+  }
+}
+
+function base64Slice (buf, start, end) {
+  if (start === 0 && end === buf.length) {
+    return base64.fromByteArray(buf)
+  } else {
+    return base64.fromByteArray(buf.slice(start, end))
+  }
+}
+
+function utf8Slice (buf, start, end) {
+  end = Math.min(buf.length, end)
+  var res = []
+
+  var i = start
+  while (i < end) {
+    var firstByte = buf[i]
+    var codePoint = null
+    var bytesPerSequence = (firstByte > 0xEF)
+      ? 4
+      : (firstByte > 0xDF)
+          ? 3
+          : (firstByte > 0xBF)
+              ? 2
+              : 1
+
+    if (i + bytesPerSequence <= end) {
+      var secondByte, thirdByte, fourthByte, tempCodePoint
+
+      switch (bytesPerSequence) {
+        case 1:
+          if (firstByte < 0x80) {
+            codePoint = firstByte
+          }
+          break
+        case 2:
+          secondByte = buf[i + 1]
+          if ((secondByte & 0xC0) === 0x80) {
+            tempCodePoint = (firstByte & 0x1F) << 0x6 | (secondByte & 0x3F)
+            if (tempCodePoint > 0x7F) {
+              codePoint = tempCodePoint
+            }
+          }
+          break
+        case 3:
+          secondByte = buf[i + 1]
+          thirdByte = buf[i + 2]
+          if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80) {
+            tempCodePoint = (firstByte & 0xF) << 0xC | (secondByte & 0x3F) << 0x6 | (thirdByte & 0x3F)
+            if (tempCodePoint > 0x7FF && (tempCodePoint < 0xD800 || tempCodePoint > 0xDFFF)) {
+              codePoint = tempCodePoint
+            }
+          }
+          break
+        case 4:
+          secondByte = buf[i + 1]
+          thirdByte = buf[i + 2]
+          fourthByte = buf[i + 3]
+          if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80 && (fourthByte & 0xC0) === 0x80) {
+            tempCodePoint = (firstByte & 0xF) << 0x12 | (secondByte & 0x3F) << 0xC | (thirdByte & 0x3F) << 0x6 | (fourthByte & 0x3F)
+            if (tempCodePoint > 0xFFFF && tempCodePoint < 0x110000) {
+              codePoint = tempCodePoint
+            }
+          }
+      }
+    }
+
+    if (codePoint === null) {
+      // we did not generate a valid codePoint so insert a
+      // replacement char (U+FFFD) and advance only 1 byte
+      codePoint = 0xFFFD
+      bytesPerSequence = 1
+    } else if (codePoint > 0xFFFF) {
+      // encode to utf16 (surrogate pair dance)
+      codePoint -= 0x10000
+      res.push(codePoint >>> 10 & 0x3FF | 0xD800)
+      codePoint = 0xDC00 | codePoint & 0x3FF
+    }
+
+    res.push(codePoint)
+    i += bytesPerSequence
+  }
+
+  return decodeCodePointsArray(res)
+}
+
+// Based on http://stackoverflow.com/a/22747272/680742, the browser with
+// the lowest limit is Chrome, with 0x10000 args.
+// We go 1 magnitude less, for safety
+var MAX_ARGUMENTS_LENGTH = 0x1000
+
+function decodeCodePointsArray (codePoints) {
+  var len = codePoints.length
+  if (len <= MAX_ARGUMENTS_LENGTH) {
+    return String.fromCharCode.apply(String, codePoints) // avoid extra slice()
+  }
+
+  // Decode in chunks to avoid "call stack size exceeded".
+  var res = ''
+  var i = 0
+  while (i < len) {
+    res += String.fromCharCode.apply(
+      String,
+      codePoints.slice(i, i += MAX_ARGUMENTS_LENGTH)
+    )
+  }
+  return res
+}
+
+function asciiSlice (buf, start, end) {
+  var ret = ''
+  end = Math.min(buf.length, end)
+
+  for (var i = start; i < end; ++i) {
+    ret += String.fromCharCode(buf[i] & 0x7F)
+  }
+  return ret
+}
+
+function latin1Slice (buf, start, end) {
+  var ret = ''
+  end = Math.min(buf.length, end)
+
+  for (var i = start; i < end; ++i) {
+    ret += String.fromCharCode(buf[i])
+  }
+  return ret
+}
+
+function hexSlice (buf, start, end) {
+  var len = buf.length
+
+  if (!start || start < 0) start = 0
+  if (!end || end < 0 || end > len) end = len
+
+  var out = ''
+  for (var i = start; i < end; ++i) {
+    out += hexSliceLookupTable[buf[i]]
+  }
+  return out
+}
+
+function utf16leSlice (buf, start, end) {
+  var bytes = buf.slice(start, end)
+  var res = ''
+  // If bytes.length is odd, the last 8 bits must be ignored (same as node.js)
+  for (var i = 0; i < bytes.length - 1; i += 2) {
+    res += String.fromCharCode(bytes[i] + (bytes[i + 1] * 256))
+  }
+  return res
+}
+
+Buffer.prototype.slice = function slice (start, end) {
+  var len = this.length
+  start = ~~start
+  end = end === undefined ? len : ~~end
+
+  if (start < 0) {
+    start += len
+    if (start < 0) start = 0
+  } else if (start > len) {
+    start = len
+  }
+
+  if (end < 0) {
+    end += len
+    if (end < 0) end = 0
+  } else if (end > len) {
+    end = len
+  }
+
+  if (end < start) end = start
+
+  var newBuf = this.subarray(start, end)
+  // Return an augmented `Uint8Array` instance
+  Object.setPrototypeOf(newBuf, Buffer.prototype)
+
+  return newBuf
+}
+
+/*
+ * Need to make sure that buffer isn't trying to write out of bounds.
+ */
+function checkOffset (offset, ext, length) {
+  if ((offset % 1) !== 0 || offset < 0) throw new RangeError('offset is not uint')
+  if (offset + ext > length) throw new RangeError('Trying to access beyond buffer length')
+}
+
+Buffer.prototype.readUintLE =
+Buffer.prototype.readUIntLE = function readUIntLE (offset, byteLength, noAssert) {
+  offset = offset >>> 0
+  byteLength = byteLength >>> 0
+  if (!noAssert) checkOffset(offset, byteLength, this.length)
+
+  var val = this[offset]
+  var mul = 1
+  var i = 0
+  while (++i < byteLength && (mul *= 0x100)) {
+    val += this[offset + i] * mul
+  }
+
+  return val
+}
+
+Buffer.prototype.readUintBE =
+Buffer.prototype.readUIntBE = function readUIntBE (offset, byteLength, noAssert) {
+  offset = offset >>> 0
+  byteLength = byteLength >>> 0
+  if (!noAssert) {
+    checkOffset(offset, byteLength, this.length)
+  }
+
+  var val = this[offset + --byteLength]
+  var mul = 1
+  while (byteLength > 0 && (mul *= 0x100)) {
+    val += this[offset + --byteLength] * mul
+  }
+
+  return val
+}
+
+Buffer.prototype.readUint8 =
+Buffer.prototype.readUInt8 = function readUInt8 (offset, noAssert) {
+  offset = offset >>> 0
+  if (!noAssert) checkOffset(offset, 1, this.length)
+  return this[offset]
+}
+
+Buffer.prototype.readUint16LE =
+Buffer.prototype.readUInt16LE = function readUInt16LE (offset, noAssert) {
+  offset = offset >>> 0
+  if (!noAssert) checkOffset(offset, 2, this.length)
+  return this[offset] | (this[offset + 1] << 8)
+}
+
+Buffer.prototype.readUint16BE =
+Buffer.prototype.readUInt16BE = function readUInt16BE (offset, noAssert) {
+  offset = offset >>> 0
+  if (!noAssert) checkOffset(offset, 2, this.length)
+  return (this[offset] << 8) | this[offset + 1]
+}
+
+Buffer.prototype.readUint32LE =
+Buffer.prototype.readUInt32LE = function readUInt32LE (offset, noAssert) {
+  offset = offset >>> 0
+  if (!noAssert) checkOffset(offset, 4, this.length)
+
+  return ((this[offset]) |
+      (this[offset + 1] << 8) |
+      (this[offset + 2] << 16)) +
+      (this[offset + 3] * 0x1000000)
+}
+
+Buffer.prototype.readUint32BE =
+Buffer.prototype.readUInt32BE = function readUInt32BE (offset, noAssert) {
+  offset = offset >>> 0
+  if (!noAssert) checkOffset(offset, 4, this.length)
+
+  return (this[offset] * 0x1000000) +
+    ((this[offset + 1] << 16) |
+    (this[offset + 2] << 8) |
+    this[offset + 3])
+}
+
+Buffer.prototype.readIntLE = function readIntLE (offset, byteLength, noAssert) {
+  offset = offset >>> 0
+  byteLength = byteLength >>> 0
+  if (!noAssert) checkOffset(offset, byteLength, this.length)
+
+  var val = this[offset]
+  var mul = 1
+  var i = 0
+  while (++i < byteLength && (mul *= 0x100)) {
+    val += this[offset + i] * mul
+  }
+  mul *= 0x80
+
+  if (val >= mul) val -= Math.pow(2, 8 * byteLength)
+
+  return val
+}
+
+Buffer.prototype.readIntBE = function readIntBE (offset, byteLength, noAssert) {
+  offset = offset >>> 0
+  byteLength = byteLength >>> 0
+  if (!noAssert) checkOffset(offset, byteLength, this.length)
+
+  var i = byteLength
+  var mul = 1
+  var val = this[offset + --i]
+  while (i > 0 && (mul *= 0x100)) {
+    val += this[offset + --i] * mul
+  }
+  mul *= 0x80
+
+  if (val >= mul) val -= Math.pow(2, 8 * byteLength)
+
+  return val
+}
+
+Buffer.prototype.readInt8 = function readInt8 (offset, noAssert) {
+  offset = offset >>> 0
+  if (!noAssert) checkOffset(offset, 1, this.length)
+  if (!(this[offset] & 0x80)) return (this[offset])
+  return ((0xff - this[offset] + 1) * -1)
+}
+
+Buffer.prototype.readInt16LE = function readInt16LE (offset, noAssert) {
+  offset = offset >>> 0
+  if (!noAssert) checkOffset(offset, 2, this.length)
+  var val = this[offset] | (this[offset + 1] << 8)
+  return (val & 0x8000) ? val | 0xFFFF0000 : val
+}
+
+Buffer.prototype.readInt16BE = function readInt16BE (offset, noAssert) {
+  offset = offset >>> 0
+  if (!noAssert) checkOffset(offset, 2, this.length)
+  var val = this[offset + 1] | (this[offset] << 8)
+  return (val & 0x8000) ? val | 0xFFFF0000 : val
+}
+
+Buffer.prototype.readInt32LE = function readInt32LE (offset, noAssert) {
+  offset = offset >>> 0
+  if (!noAssert) checkOffset(offset, 4, this.length)
+
+  return (this[offset]) |
+    (this[offset + 1] << 8) |
+    (this[offset + 2] << 16) |
+    (this[offset + 3] << 24)
+}
+
+Buffer.prototype.readInt32BE = function readInt32BE (offset, noAssert) {
+  offset = offset >>> 0
+  if (!noAssert) checkOffset(offset, 4, this.length)
+
+  return (this[offset] << 24) |
+    (this[offset + 1] << 16) |
+    (this[offset + 2] << 8) |
+    (this[offset + 3])
+}
+
+Buffer.prototype.readFloatLE = function readFloatLE (offset, noAssert) {
+  offset = offset >>> 0
+  if (!noAssert) checkOffset(offset, 4, this.length)
+  return ieee754.read(this, offset, true, 23, 4)
+}
+
+Buffer.prototype.readFloatBE = function readFloatBE (offset, noAssert) {
+  offset = offset >>> 0
+  if (!noAssert) checkOffset(offset, 4, this.length)
+  return ieee754.read(this, offset, false, 23, 4)
+}
+
+Buffer.prototype.readDoubleLE = function readDoubleLE (offset, noAssert) {
+  offset = offset >>> 0
+  if (!noAssert) checkOffset(offset, 8, this.length)
+  return ieee754.read(this, offset, true, 52, 8)
+}
+
+Buffer.prototype.readDoubleBE = function readDoubleBE (offset, noAssert) {
+  offset = offset >>> 0
+  if (!noAssert) checkOffset(offset, 8, this.length)
+  return ieee754.read(this, offset, false, 52, 8)
+}
+
+function checkInt (buf, value, offset, ext, max, min) {
+  if (!Buffer.isBuffer(buf)) throw new TypeError('"buffer" argument must be a Buffer instance')
+  if (value > max || value < min) throw new RangeError('"value" argument is out of bounds')
+  if (offset + ext > buf.length) throw new RangeError('Index out of range')
+}
+
+Buffer.prototype.writeUintLE =
+Buffer.prototype.writeUIntLE = function writeUIntLE (value, offset, byteLength, noAssert) {
+  value = +value
+  offset = offset >>> 0
+  byteLength = byteLength >>> 0
+  if (!noAssert) {
+    var maxBytes = Math.pow(2, 8 * byteLength) - 1
+    checkInt(this, value, offset, byteLength, maxBytes, 0)
+  }
+
+  var mul = 1
+  var i = 0
+  this[offset] = value & 0xFF
+  while (++i < byteLength && (mul *= 0x100)) {
+    this[offset + i] = (value / mul) & 0xFF
+  }
+
+  return offset + byteLength
+}
+
+Buffer.prototype.writeUintBE =
+Buffer.prototype.writeUIntBE = function writeUIntBE (value, offset, byteLength, noAssert) {
+  value = +value
+  offset = offset >>> 0
+  byteLength = byteLength >>> 0
+  if (!noAssert) {
+    var maxBytes = Math.pow(2, 8 * byteLength) - 1
+    checkInt(this, value, offset, byteLength, maxBytes, 0)
+  }
+
+  var i = byteLength - 1
+  var mul = 1
+  this[offset + i] = value & 0xFF
+  while (--i >= 0 && (mul *= 0x100)) {
+    this[offset + i] = (value / mul) & 0xFF
+  }
+
+  return offset + byteLength
+}
+
+Buffer.prototype.writeUint8 =
+Buffer.prototype.writeUInt8 = function writeUInt8 (value, offset, noAssert) {
+  value = +value
+  offset = offset >>> 0
+  if (!noAssert) checkInt(this, value, offset, 1, 0xff, 0)
+  this[offset] = (value & 0xff)
+  return offset + 1
+}
+
+Buffer.prototype.writeUint16LE =
+Buffer.prototype.writeUInt16LE = function writeUInt16LE (value, offset, noAssert) {
+  value = +value
+  offset = offset >>> 0
+  if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0)
+  this[offset] = (value & 0xff)
+  this[offset + 1] = (value >>> 8)
+  return offset + 2
+}
+
+Buffer.prototype.writeUint16BE =
+Buffer.prototype.writeUInt16BE = function writeUInt16BE (value, offset, noAssert) {
+  value = +value
+  offset = offset >>> 0
+  if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0)
+  this[offset] = (value >>> 8)
+  this[offset + 1] = (value & 0xff)
+  return offset + 2
+}
+
+Buffer.prototype.writeUint32LE =
+Buffer.prototype.writeUInt32LE = function writeUInt32LE (value, offset, noAssert) {
+  value = +value
+  offset = offset >>> 0
+  if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0)
+  this[offset + 3] = (value >>> 24)
+  this[offset + 2] = (value >>> 16)
+  this[offset + 1] = (value >>> 8)
+  this[offset] = (value & 0xff)
+  return offset + 4
+}
+
+Buffer.prototype.writeUint32BE =
+Buffer.prototype.writeUInt32BE = function writeUInt32BE (value, offset, noAssert) {
+  value = +value
+  offset = offset >>> 0
+  if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0)
+  this[offset] = (value >>> 24)
+  this[offset + 1] = (value >>> 16)
+  this[offset + 2] = (value >>> 8)
+  this[offset + 3] = (value & 0xff)
+  return offset + 4
+}
+
+Buffer.prototype.writeIntLE = function writeIntLE (value, offset, byteLength, noAssert) {
+  value = +value
+  offset = offset >>> 0
+  if (!noAssert) {
+    var limit = Math.pow(2, (8 * byteLength) - 1)
+
+    checkInt(this, value, offset, byteLength, limit - 1, -limit)
+  }
+
+  var i = 0
+  var mul = 1
+  var sub = 0
+  this[offset] = value & 0xFF
+  while (++i < byteLength && (mul *= 0x100)) {
+    if (value < 0 && sub === 0 && this[offset + i - 1] !== 0) {
+      sub = 1
+    }
+    this[offset + i] = ((value / mul) >> 0) - sub & 0xFF
+  }
+
+  return offset + byteLength
+}
+
+Buffer.prototype.writeIntBE = function writeIntBE (value, offset, byteLength, noAssert) {
+  value = +value
+  offset = offset >>> 0
+  if (!noAssert) {
+    var limit = Math.pow(2, (8 * byteLength) - 1)
+
+    checkInt(this, value, offset, byteLength, limit - 1, -limit)
+  }
+
+  var i = byteLength - 1
+  var mul = 1
+  var sub = 0
+  this[offset + i] = value & 0xFF
+  while (--i >= 0 && (mul *= 0x100)) {
+    if (value < 0 && sub === 0 && this[offset + i + 1] !== 0) {
+      sub = 1
+    }
+    this[offset + i] = ((value / mul) >> 0) - sub & 0xFF
+  }
+
+  return offset + byteLength
+}
+
+Buffer.prototype.writeInt8 = function writeInt8 (value, offset, noAssert) {
+  value = +value
+  offset = offset >>> 0
+  if (!noAssert) checkInt(this, value, offset, 1, 0x7f, -0x80)
+  if (value < 0) value = 0xff + value + 1
+  this[offset] = (value & 0xff)
+  return offset + 1
+}
+
+Buffer.prototype.writeInt16LE = function writeInt16LE (value, offset, noAssert) {
+  value = +value
+  offset = offset >>> 0
+  if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000)
+  this[offset] = (value & 0xff)
+  this[offset + 1] = (value >>> 8)
+  return offset + 2
+}
+
+Buffer.prototype.writeInt16BE = function writeInt16BE (value, offset, noAssert) {
+  value = +value
+  offset = offset >>> 0
+  if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000)
+  this[offset] = (value >>> 8)
+  this[offset + 1] = (value & 0xff)
+  return offset + 2
+}
+
+Buffer.prototype.writeInt32LE = function writeInt32LE (value, offset, noAssert) {
+  value = +value
+  offset = offset >>> 0
+  if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000)
+  this[offset] = (value & 0xff)
+  this[offset + 1] = (value >>> 8)
+  this[offset + 2] = (value >>> 16)
+  this[offset + 3] = (value >>> 24)
+  return offset + 4
+}
+
+Buffer.prototype.writeInt32BE = function writeInt32BE (value, offset, noAssert) {
+  value = +value
+  offset = offset >>> 0
+  if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000)
+  if (value < 0) value = 0xffffffff + value + 1
+  this[offset] = (value >>> 24)
+  this[offset + 1] = (value >>> 16)
+  this[offset + 2] = (value >>> 8)
+  this[offset + 3] = (value & 0xff)
+  return offset + 4
+}
+
+function checkIEEE754 (buf, value, offset, ext, max, min) {
+  if (offset + ext > buf.length) throw new RangeError('Index out of range')
+  if (offset < 0) throw new RangeError('Index out of range')
+}
+
+function writeFloat (buf, value, offset, littleEndian, noAssert) {
+  value = +value
+  offset = offset >>> 0
+  if (!noAssert) {
+    checkIEEE754(buf, value, offset, 4, 3.4028234663852886e+38, -3.4028234663852886e+38)
+  }
+  ieee754.write(buf, value, offset, littleEndian, 23, 4)
+  return offset + 4
+}
+
+Buffer.prototype.writeFloatLE = function writeFloatLE (value, offset, noAssert) {
+  return writeFloat(this, value, offset, true, noAssert)
+}
+
+Buffer.prototype.writeFloatBE = function writeFloatBE (value, offset, noAssert) {
+  return writeFloat(this, value, offset, false, noAssert)
+}
+
+function writeDouble (buf, value, offset, littleEndian, noAssert) {
+  value = +value
+  offset = offset >>> 0
+  if (!noAssert) {
+    checkIEEE754(buf, value, offset, 8, 1.7976931348623157E+308, -1.7976931348623157E+308)
+  }
+  ieee754.write(buf, value, offset, littleEndian, 52, 8)
+  return offset + 8
+}
+
+Buffer.prototype.writeDoubleLE = function writeDoubleLE (value, offset, noAssert) {
+  return writeDouble(this, value, offset, true, noAssert)
+}
+
+Buffer.prototype.writeDoubleBE = function writeDoubleBE (value, offset, noAssert) {
+  return writeDouble(this, value, offset, false, noAssert)
+}
+
+// copy(targetBuffer, targetStart=0, sourceStart=0, sourceEnd=buffer.length)
+Buffer.prototype.copy = function copy (target, targetStart, start, end) {
+  if (!Buffer.isBuffer(target)) throw new TypeError('argument should be a Buffer')
+  if (!start) start = 0
+  if (!end && end !== 0) end = this.length
+  if (targetStart >= target.length) targetStart = target.length
+  if (!targetStart) targetStart = 0
+  if (end > 0 && end < start) end = start
+
+  // Copy 0 bytes; we're done
+  if (end === start) return 0
+  if (target.length === 0 || this.length === 0) return 0
+
+  // Fatal error conditions
+  if (targetStart < 0) {
+    throw new RangeError('targetStart out of bounds')
+  }
+  if (start < 0 || start >= this.length) throw new RangeError('Index out of range')
+  if (end < 0) throw new RangeError('sourceEnd out of bounds')
+
+  // Are we oob?
+  if (end > this.length) end = this.length
+  if (target.length - targetStart < end - start) {
+    end = target.length - targetStart + start
+  }
+
+  var len = end - start
+
+  if (this === target && typeof Uint8Array.prototype.copyWithin === 'function') {
+    // Use built-in when available, missing from IE11
+    this.copyWithin(targetStart, start, end)
+  } else {
+    Uint8Array.prototype.set.call(
+      target,
+      this.subarray(start, end),
+      targetStart
+    )
+  }
+
+  return len
+}
+
+// Usage:
+//    buffer.fill(number[, offset[, end]])
+//    buffer.fill(buffer[, offset[, end]])
+//    buffer.fill(string[, offset[, end]][, encoding])
+Buffer.prototype.fill = function fill (val, start, end, encoding) {
+  // Handle string cases:
+  if (typeof val === 'string') {
+    if (typeof start === 'string') {
+      encoding = start
+      start = 0
+      end = this.length
+    } else if (typeof end === 'string') {
+      encoding = end
+      end = this.length
+    }
+    if (encoding !== undefined && typeof encoding !== 'string') {
+      throw new TypeError('encoding must be a string')
+    }
+    if (typeof encoding === 'string' && !Buffer.isEncoding(encoding)) {
+      throw new TypeError('Unknown encoding: ' + encoding)
+    }
+    if (val.length === 1) {
+      var code = val.charCodeAt(0)
+      if ((encoding === 'utf8' && code < 128) ||
+          encoding === 'latin1') {
+        // Fast path: If `val` fits into a single byte, use that numeric value.
+        val = code
+      }
+    }
+  } else if (typeof val === 'number') {
+    val = val & 255
+  } else if (typeof val === 'boolean') {
+    val = Number(val)
+  }
+
+  // Invalid ranges are not set to a default, so can range check early.
+  if (start < 0 || this.length < start || this.length < end) {
+    throw new RangeError('Out of range index')
+  }
+
+  if (end <= start) {
+    return this
+  }
+
+  start = start >>> 0
+  end = end === undefined ? this.length : end >>> 0
+
+  if (!val) val = 0
+
+  var i
+  if (typeof val === 'number') {
+    for (i = start; i < end; ++i) {
+      this[i] = val
+    }
+  } else {
+    var bytes = Buffer.isBuffer(val)
+      ? val
+      : Buffer.from(val, encoding)
+    var len = bytes.length
+    if (len === 0) {
+      throw new TypeError('The value "' + val +
+        '" is invalid for argument "value"')
+    }
+    for (i = 0; i < end - start; ++i) {
+      this[i + start] = bytes[i % len]
+    }
+  }
+
+  return this
+}
+
+// HELPER FUNCTIONS
+// ================
+
+var INVALID_BASE64_RE = /[^+/0-9A-Za-z-_]/g
+
+function base64clean (str) {
+  // Node takes equal signs as end of the Base64 encoding
+  str = str.split('=')[0]
+  // Node strips out invalid characters like \n and \t from the string, base64-js does not
+  str = str.trim().replace(INVALID_BASE64_RE, '')
+  // Node converts strings with length < 2 to ''
+  if (str.length < 2) return ''
+  // Node allows for non-padded base64 strings (missing trailing ===), base64-js does not
+  while (str.length % 4 !== 0) {
+    str = str + '='
+  }
+  return str
+}
+
+function utf8ToBytes (string, units) {
+  units = units || Infinity
+  var codePoint
+  var length = string.length
+  var leadSurrogate = null
+  var bytes = []
+
+  for (var i = 0; i < length; ++i) {
+    codePoint = string.charCodeAt(i)
+
+    // is surrogate component
+    if (codePoint > 0xD7FF && codePoint < 0xE000) {
+      // last char was a lead
+      if (!leadSurrogate) {
+        // no lead yet
+        if (codePoint > 0xDBFF) {
+          // unexpected trail
+          if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)
+          continue
+        } else if (i + 1 === length) {
+          // unpaired lead
+          if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)
+          continue
+        }
+
+        // valid lead
+        leadSurrogate = codePoint
+
+        continue
+      }
+
+      // 2 leads in a row
+      if (codePoint < 0xDC00) {
+        if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)
+        leadSurrogate = codePoint
+        continue
+      }
+
+      // valid surrogate pair
+      codePoint = (leadSurrogate - 0xD800 << 10 | codePoint - 0xDC00) + 0x10000
+    } else if (leadSurrogate) {
+      // valid bmp char, but last char was a lead
+      if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)
+    }
+
+    leadSurrogate = null
+
+    // encode utf8
+    if (codePoint < 0x80) {
+      if ((units -= 1) < 0) break
+      bytes.push(codePoint)
+    } else if (codePoint < 0x800) {
+      if ((units -= 2) < 0) break
+      bytes.push(
+        codePoint >> 0x6 | 0xC0,
+        codePoint & 0x3F | 0x80
+      )
+    } else if (codePoint < 0x10000) {
+      if ((units -= 3) < 0) break
+      bytes.push(
+        codePoint >> 0xC | 0xE0,
+        codePoint >> 0x6 & 0x3F | 0x80,
+        codePoint & 0x3F | 0x80
+      )
+    } else if (codePoint < 0x110000) {
+      if ((units -= 4) < 0) break
+      bytes.push(
+        codePoint >> 0x12 | 0xF0,
+        codePoint >> 0xC & 0x3F | 0x80,
+        codePoint >> 0x6 & 0x3F | 0x80,
+        codePoint & 0x3F | 0x80
+      )
+    } else {
+      throw new Error('Invalid code point')
+    }
+  }
+
+  return bytes
+}
+
+function asciiToBytes (str) {
+  var byteArray = []
+  for (var i = 0; i < str.length; ++i) {
+    // Node's code seems to be doing this and not & 0x7F..
+    byteArray.push(str.charCodeAt(i) & 0xFF)
+  }
+  return byteArray
+}
+
+function utf16leToBytes (str, units) {
+  var c, hi, lo
+  var byteArray = []
+  for (var i = 0; i < str.length; ++i) {
+    if ((units -= 2) < 0) break
+
+    c = str.charCodeAt(i)
+    hi = c >> 8
+    lo = c % 256
+    byteArray.push(lo)
+    byteArray.push(hi)
+  }
+
+  return byteArray
+}
+
+function base64ToBytes (str) {
+  return base64.toByteArray(base64clean(str))
+}
+
+function blitBuffer (src, dst, offset, length) {
+  for (var i = 0; i < length; ++i) {
+    if ((i + offset >= dst.length) || (i >= src.length)) break
+    dst[i + offset] = src[i]
+  }
+  return i
+}
+
+// ArrayBuffer or Uint8Array objects from other contexts (i.e. iframes) do not pass
+// the `instanceof` check but they should be treated as of that type.
+// See: https://github.com/feross/buffer/issues/166
+function isInstance (obj, type) {
+  return obj instanceof type ||
+    (obj != null && obj.constructor != null && obj.constructor.name != null &&
+      obj.constructor.name === type.name)
+}
+function numberIsNaN (obj) {
+  // For IE11 support
+  return obj !== obj // eslint-disable-line no-self-compare
+}
+
+// Create lookup table for `toString('hex')`
+// See: https://github.com/feross/buffer/issues/219
+var hexSliceLookupTable = (function () {
+  var alphabet = '0123456789abcdef'
+  var table = new Array(256)
+  for (var i = 0; i < 16; ++i) {
+    var i16 = i * 16
+    for (var j = 0; j < 16; ++j) {
+      table[i16 + j] = alphabet[i] + alphabet[j]
+    }
+  }
+  return table
+})()
+
+
+/***/ }),
+
+/***/ 526:
+/***/ ((__unused_webpack_module, exports) => {
+
+"use strict";
+
+
+exports.byteLength = byteLength
+exports.toByteArray = toByteArray
+exports.fromByteArray = fromByteArray
+
+var lookup = []
+var revLookup = []
+var Arr = typeof Uint8Array !== 'undefined' ? Uint8Array : Array
+
+var code = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'
+for (var i = 0, len = code.length; i < len; ++i) {
+  lookup[i] = code[i]
+  revLookup[code.charCodeAt(i)] = i
+}
+
+// Support decoding URL-safe base64 strings, as Node.js does.
+// See: https://en.wikipedia.org/wiki/Base64#URL_applications
+revLookup['-'.charCodeAt(0)] = 62
+revLookup['_'.charCodeAt(0)] = 63
+
+function getLens (b64) {
+  var len = b64.length
+
+  if (len % 4 > 0) {
+    throw new Error('Invalid string. Length must be a multiple of 4')
+  }
+
+  // Trim off extra bytes after placeholder bytes are found
+  // See: https://github.com/beatgammit/base64-js/issues/42
+  var validLen = b64.indexOf('=')
+  if (validLen === -1) validLen = len
+
+  var placeHoldersLen = validLen === len
+    ? 0
+    : 4 - (validLen % 4)
+
+  return [validLen, placeHoldersLen]
+}
+
+// base64 is 4/3 + up to two characters of the original data
+function byteLength (b64) {
+  var lens = getLens(b64)
+  var validLen = lens[0]
+  var placeHoldersLen = lens[1]
+  return ((validLen + placeHoldersLen) * 3 / 4) - placeHoldersLen
+}
+
+function _byteLength (b64, validLen, placeHoldersLen) {
+  return ((validLen + placeHoldersLen) * 3 / 4) - placeHoldersLen
+}
+
+function toByteArray (b64) {
+  var tmp
+  var lens = getLens(b64)
+  var validLen = lens[0]
+  var placeHoldersLen = lens[1]
+
+  var arr = new Arr(_byteLength(b64, validLen, placeHoldersLen))
+
+  var curByte = 0
+
+  // if there are placeholders, only get up to the last complete 4 chars
+  var len = placeHoldersLen > 0
+    ? validLen - 4
+    : validLen
+
+  var i
+  for (i = 0; i < len; i += 4) {
+    tmp =
+      (revLookup[b64.charCodeAt(i)] << 18) |
+      (revLookup[b64.charCodeAt(i + 1)] << 12) |
+      (revLookup[b64.charCodeAt(i + 2)] << 6) |
+      revLookup[b64.charCodeAt(i + 3)]
+    arr[curByte++] = (tmp >> 16) & 0xFF
+    arr[curByte++] = (tmp >> 8) & 0xFF
+    arr[curByte++] = tmp & 0xFF
+  }
+
+  if (placeHoldersLen === 2) {
+    tmp =
+      (revLookup[b64.charCodeAt(i)] << 2) |
+      (revLookup[b64.charCodeAt(i + 1)] >> 4)
+    arr[curByte++] = tmp & 0xFF
+  }
+
+  if (placeHoldersLen === 1) {
+    tmp =
+      (revLookup[b64.charCodeAt(i)] << 10) |
+      (revLookup[b64.charCodeAt(i + 1)] << 4) |
+      (revLookup[b64.charCodeAt(i + 2)] >> 2)
+    arr[curByte++] = (tmp >> 8) & 0xFF
+    arr[curByte++] = tmp & 0xFF
+  }
+
+  return arr
+}
+
+function tripletToBase64 (num) {
+  return lookup[num >> 18 & 0x3F] +
+    lookup[num >> 12 & 0x3F] +
+    lookup[num >> 6 & 0x3F] +
+    lookup[num & 0x3F]
+}
+
+function encodeChunk (uint8, start, end) {
+  var tmp
+  var output = []
+  for (var i = start; i < end; i += 3) {
+    tmp =
+      ((uint8[i] << 16) & 0xFF0000) +
+      ((uint8[i + 1] << 8) & 0xFF00) +
+      (uint8[i + 2] & 0xFF)
+    output.push(tripletToBase64(tmp))
+  }
+  return output.join('')
+}
+
+function fromByteArray (uint8) {
+  var tmp
+  var len = uint8.length
+  var extraBytes = len % 3 // if we have 1 byte left, pad 2 bytes
+  var parts = []
+  var maxChunkLength = 16383 // must be multiple of 3
+
+  // go through the array every three bytes, we'll deal with trailing stuff later
+  for (var i = 0, len2 = len - extraBytes; i < len2; i += maxChunkLength) {
+    parts.push(encodeChunk(uint8, i, (i + maxChunkLength) > len2 ? len2 : (i + maxChunkLength)))
+  }
+
+  // pad the end with zeros, but make sure to not forget the extra bytes
+  if (extraBytes === 1) {
+    tmp = uint8[len - 1]
+    parts.push(
+      lookup[tmp >> 2] +
+      lookup[(tmp << 4) & 0x3F] +
+      '=='
+    )
+  } else if (extraBytes === 2) {
+    tmp = (uint8[len - 2] << 8) + uint8[len - 1]
+    parts.push(
+      lookup[tmp >> 10] +
+      lookup[(tmp >> 4) & 0x3F] +
+      lookup[(tmp << 2) & 0x3F] +
+      '='
+    )
+  }
+
+  return parts.join('')
+}
+
+
+/***/ })
+
+/******/ 	});
+/************************************************************************/
+/******/ 	// The module cache
+/******/ 	var __webpack_module_cache__ = {};
+/******/ 	
+/******/ 	// The require function
+/******/ 	function __webpack_require__(moduleId) {
+/******/ 		// Check if module is in cache
+/******/ 		var cachedModule = __webpack_module_cache__[moduleId];
+/******/ 		if (cachedModule !== undefined) {
+/******/ 			return cachedModule.exports;
+/******/ 		}
+/******/ 		// Create a new module (and put it into the cache)
+/******/ 		var module = __webpack_module_cache__[moduleId] = {
+/******/ 			// no module.id needed
+/******/ 			// no module.loaded needed
+/******/ 			exports: {}
+/******/ 		};
+/******/ 	
+/******/ 		// Execute the module function
+/******/ 		__webpack_modules__[moduleId](module, module.exports, __webpack_require__);
+/******/ 	
+/******/ 		// Return the exports of the module
+/******/ 		return module.exports;
+/******/ 	}
+/******/ 	
+/************************************************************************/
+/******/ 	/* webpack/runtime/define property getters */
+/******/ 	(() => {
+/******/ 		// define getter functions for harmony exports
+/******/ 		__webpack_require__.d = (exports, definition) => {
+/******/ 			for(var key in definition) {
+/******/ 				if(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {
+/******/ 					Object.defineProperty(exports, key, { enumerable: true, get: definition[key] });
+/******/ 				}
+/******/ 			}
+/******/ 		};
+/******/ 	})();
+/******/ 	
+/******/ 	/* webpack/runtime/hasOwnProperty shorthand */
+/******/ 	(() => {
+/******/ 		__webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))
+/******/ 	})();
+/******/ 	
+/************************************************************************/
+var __webpack_exports__ = {};
+// This entry needs to be wrapped in an IIFE because it needs to be in strict mode.
+(() => {
+"use strict";
+
+// EXPORTS
+__webpack_require__.d(__webpack_exports__, {
+  TinyDragger: () => (/* reexport */ libs_TinyDragger)
+});
+
+// EXTERNAL MODULE: ./node_modules/buffer/index.js
+var buffer = __webpack_require__(287);
+;// ./src/v1/basics/objFilter.mjs
+
+
+const isBrowser = typeof window !== 'undefined' && typeof window.document !== 'undefined';
+
+/**
+ * An object containing type validation functions and their evaluation order.
+ *
+ * Each item in `typeValidator.items` is a function that receives any value
+ * and returns a boolean indicating whether the value matches the corresponding type.
+ *
+ * The `order` array defines the priority in which types should be checked,
+ * which can be useful for functions that infer types in a consistent manner.
+ *
+ */
+const typeValidator = {
+  items: {},
+  /**
+   * Evaluation order of the type checkers.
+   * @type {string[]}
+   * */
+  order: [],
+};
+
+/** @typedef {Object.<string, (val: any) => *>} ExtendObjType */
+/** @typedef {Array<[string, (val: any) => *]>} ExtendObjTypeArray */
+
+/**
+ * Adds new type checkers to the typeValidator without overwriting existing ones.
+ *
+ * Accepts either an object with named functions or an array of [key, fn] arrays.
+ * If no index is provided, the type is inserted just before 'object' (if it exists), or at the end.
+ *
+ * @param {ExtendObjType|ExtendObjTypeArray} newItems
+ *        - New type validators to be added.
+ * @param {number} [index] - Optional. Position at which to insert each new type. Ignored if the type already exists.
+ * @returns {string[]} - A list of successfully added type names.
+ *
+ * @example
+ * extendObjType({
+ *   htmlElement2: val => typeof HTMLElement !== 'undefined' && val instanceof HTMLElement
+ * });
+ *
+ * @example
+ * extendObjType([
+ *   ['alpha', val => typeof val === 'string'],
+ *   ['beta', val => Array.isArray(val)]
+ * ]);
+ */
+function extendObjType(newItems, index) {
+  const added = [];
+
+  const entries = Array.isArray(newItems) ? newItems : Object.entries(newItems);
+  for (const [key, fn] of entries) {
+    if (!typeValidator.items.hasOwnProperty(key)) {
+      // @ts-ignore
+      typeValidator.items[key] = fn;
+
+      let insertAt = typeof index === 'number' ? index : -1; // Default to -1 if index isn't provided
+
+      // Default to before 'object', or to the end
+      if (insertAt === -1) {
+        const objectIndex = typeValidator.order.indexOf('object');
+        insertAt = objectIndex > -1 ? objectIndex : typeValidator.order.length;
+      }
+
+      // Ensure insertAt is a valid number and not out of bounds
+      insertAt = Math.min(Math.max(0, insertAt), typeValidator.order.length);
+
+      typeValidator.order.splice(insertAt, 0, key);
+      added.push(key);
+    }
+  }
+
+  return added;
+}
+
+/**
+ * Reorders the typeValidator.order array according to a custom new order.
+ * All values in the new order must already exist in the current order.
+ * The function does not mutate the original array structure directly.
+ *
+ * @param {string[]} newOrder - The new order of type names.
+ * @returns {boolean} - Returns true if the reorder was successful, false if invalid keys were found.
+ *
+ * @example
+ * reorderObjTypeOrder([
+ *   'string', 'number', 'array', 'object'
+ * ]);
+ */
+function reorderObjTypeOrder(newOrder) {
+  const currentOrder = [...typeValidator.order]; // shallow clone
+
+  // All keys in newOrder must exist in currentOrder
+  const isValid = newOrder.every((type) => currentOrder.includes(type));
+
+  if (!isValid) return false;
+
+  // Reassign only if valid
+  typeValidator.order = newOrder.slice(); // assign shallow copy
+  return true;
+}
+
+/**
+ * Returns a cloned version of the `typeValidator.order` array.
+ * The cloned array will not be affected by future changes to the original `order`.
+ *
+ * @returns {string[]} - A new array with the same values as `typeValidator.order`.
+ */
+function cloneObjTypeOrder() {
+  return [...typeValidator.order]; // Creates a shallow copy of the array
+}
+
+/**
+ * Returns the detected type name of a given value based on predefined type validators.
+ *
+ * This function uses `getType` with a predefined `typeValidator` to determine or compare types safely.
+ * in the specified `typeValidator.order`. The first matching type is returned.
+ *
+ * If `val` is `null`, it immediately returns `'null'`.
+ * If no match is found, it returns `'unknown'`.
+ *
+ * @param {any} val - The value whose type should be determined.
+ * @returns {string} - The type name of the value (e.g., "array", "date", "map"), or "unknown" if no match is found.
+ *
+ * @example
+ * getType([]); // "array"
+ * getType(null); // "null"
+ * getType(new Set()); // "set"
+ * getType(() => {}); // "unknown"
+ */
+const getType = (val) => {
+  if (val === null) return 'null';
+  // @ts-ignore
+  for (const name of typeValidator.order) {
+    // @ts-ignore
+    if (typeof typeValidator.items[name] !== 'function' || typeValidator.items[name](val))
+      return name;
+  }
+  return 'unknown';
+};
+
+/**
+ * Checks the type of a given object or returns its type as a string.
+ *
+ * @param {*} obj - The object to check or identify.
+ * @param {string} [type] - Optional. If provided, checks whether the object matches this type (e.g., "object", "array", "string").
+ * @returns {boolean|string|null} - Returns `true` if the type matches, `false` if not,
+ *                                   the type string if no type is provided, or `null` if the object is `undefined`.
+ *
+ * @example
+ * objType([], 'array'); // true
+ * objType({}, 'object'); // true
+ * objType('hello'); // "string"
+ * objType(undefined); // null
+ */
+function objType(obj, type) {
+  if (typeof obj === 'undefined') return null;
+  const result = getType(obj);
+  if (typeof type === 'string') return result === type.toLowerCase();
+  return result;
+}
+
+/**
+ * Checks the type of a given object and returns the validation value if a known type is detected.
+ *
+ * @param {*} obj - The object to check or identify.
+ * @returns {{ valid:*; type: string | null }} - Returns the type result.
+ */
+function checkObj(obj) {
+  /** @type {{ valid:*; type: string | null }} */
+  const data = { valid: null, type: null };
+  for (const name of typeValidator.order) {
+    // @ts-ignore
+    if (typeof typeValidator.items[name] === 'function') {
+      // @ts-ignore
+      const result = typeValidator.items[name](obj);
+      if (result) {
+        data.valid = result;
+        data.type = name;
+        break;
+      }
+    }
+  }
+  return data;
+}
+
+/**
+ * Creates a clone of the functions from the `typeValidator` object.
+ * It returns a new object where the keys are the same and the values are the cloned functions.
+ */
+function getCheckObj() {
+  return Object.fromEntries(Object.entries(typeValidator.items).map(([key, fn]) => [key, fn]));
+}
+
+/**
+ * Counts the number of elements in an array or the number of properties in an object.
+ *
+ * @param {Array<*>|Record<string|number, any>} obj - The array or object to count.
+ * @returns {number} - The count of items (array elements or object keys), or `0` if the input is neither an array nor an object.
+ *
+ * @example
+ * countObj([1, 2, 3]); // 3
+ * countObj({ a: 1, b: 2 }); // 2
+ * countObj('not an object'); // 0
+ */
+function countObj(obj) {
+  // Is Array
+  if (Array.isArray(obj)) return obj.length;
+  // Object
+  if (objType(obj, 'object')) return Object.keys(obj).length;
+  // Nothing
+  return 0;
+}
+
+/**
+ * Determines whether a given value is a pure JSON object (plain object).
+ *
+ * A pure object satisfies the following:
+ * - It is not null.
+ * - Its type is "object".
+ * - Its internal [[Class]] is "[object Object]".
+ * - It is not an instance of built-in types like Array, Date, Map, Set, etc.
+ *
+ * This function is useful for strict data validation when you want to ensure
+ * a value is a clean JSON-compatible object, free of class instances or special types.
+ *
+ * @param {unknown} value - The value to test.
+ * @returns {value is Record<string | number | symbol, unknown>} Returns true if the value is a pure object.
+ */
+function objFilter_isJsonObject(value) {
+  if (value === null || typeof value !== 'object') return false;
+  if (Array.isArray(value)) return false;
+  if (Object.prototype.toString.call(value) !== '[object Object]') return false;
+  return true;
+}
+
+// Insert obj types
+
+extendObjType([
+  [
+    'undefined',
+    /** @param {*} val @returns {val is undefined} */
+    (val) => typeof val === 'undefined',
+  ],
+  [
+    'null',
+    /** @param {*} val @returns {val is null} */
+    (val) => val === null,
+  ],
+  [
+    'boolean',
+    /** @param {*} val @returns {val is boolean} */
+    (val) => typeof val === 'boolean',
+  ],
+  [
+    'number',
+    /** @param {*} val @returns {val is number} */
+    (val) => typeof val === 'number' && !Number.isNaN(val),
+  ],
+  [
+    'bigint',
+    /** @param {*} val @returns {val is bigint} */
+    (val) => typeof val === 'bigint',
+  ],
+  [
+    'string',
+    /** @param {*} val @returns {val is string} */
+    (val) => typeof val === 'string',
+  ],
+  [
+    'symbol',
+    /** @param {*} val @returns {val is symbol} */
+    (val) => typeof val === 'symbol',
+  ],
+  [
+    'function',
+    /** @param {*} val @returns {val is Function} */
+    (val) => typeof val === 'function',
+  ],
+  [
+    'array',
+    /** @param {*} val @returns {val is any[]} */
+    (val) => Array.isArray(val),
+  ],
+]);
+
+if (!isBrowser) {
+  extendObjType([
+    [
+      'buffer',
+      /** @param {*} val @returns {val is Buffer} */
+      (val) => typeof buffer/* Buffer */.hp !== 'undefined' && buffer/* Buffer */.hp.isBuffer(val),
+    ],
+  ]);
+}
+
+if (isBrowser) {
+  extendObjType([
+    [
+      'file',
+      /** @param {*} val @returns {val is File} */
+      (val) => typeof File !== 'undefined' && val instanceof File,
+    ],
+  ]);
+}
+
+extendObjType([
+  [
+    'date',
+    /** @param {*} val @returns {val is Date} */
+    (val) => val instanceof Date,
+  ],
+  [
+    'regexp',
+    /** @param {*} val @returns {val is RegExp} */
+    (val) => val instanceof RegExp,
+  ],
+  [
+    'map',
+    /** @param {*} val @returns {val is Map<unknown, unknown>} */
+    (val) => val instanceof Map,
+  ],
+  [
+    'set',
+    /** @param {*} val @returns {val is Set<unknown>} */
+    (val) => val instanceof Set,
+  ],
+  [
+    'weakmap',
+    /** @param {*} val @returns {val is WeakMap<unknown, unknown>} */
+    (val) => val instanceof WeakMap,
+  ],
+  [
+    'weakset',
+    /** @param {*} val @returns {val is WeakSet<unknown>} */
+    (val) => val instanceof WeakSet,
+  ],
+  [
+    'promise',
+    /** @param {*} val @returns {val is Promise<unknown>} */
+    (val) => val instanceof Promise,
+  ],
+]);
+
+if (isBrowser) {
+  extendObjType([
+    [
+      'htmlelement',
+      /** @param {*} val @returns {val is HTMLElement} */
+      (val) => typeof HTMLElement !== 'undefined' && val instanceof HTMLElement,
+    ],
+  ]);
+}
+
+extendObjType([
+  [
+    'object',
+    /** @param {*} val @returns {val is Record<string | number | symbol, unknown>} */
+    (val) => objFilter_isJsonObject(val),
+  ],
+]);
+
+;// ./src/v1/basics/html.mjs
+
+
+/**
+ * Checks if two DOM elements are colliding on the screen.
+ *
+ * @param {Element} elem1 - First DOM element.
+ * @param {Element} elem2 - Second DOM element.
+ * @returns {boolean} - Returns true if the elements are colliding.
+ */
+function areHtmlElsColliding(elem1, elem2) {
+  const rect1 = elem1.getBoundingClientRect();
+  const rect2 = elem2.getBoundingClientRect();
+
+  return !(
+    rect1.right < rect2.left ||
+    rect1.left > rect2.right ||
+    rect1.bottom < rect2.top ||
+    rect1.top > rect2.bottom
+  );
+}
+
+/**
+ * Reads and parses a JSON data using FileReader.
+ * Throws an error if the content is not valid JSON.
+ * @param {File} file
+ * @returns {Promise<any>}
+ */
+function readJsonBlob(file) {
+  return new Promise((resolve, reject) => {
+    const reader = new FileReader();
+
+    reader.onload = () => {
+      try {
+        // @ts-ignore
+        const result = JSON.parse(reader.result);
+        resolve(result);
+      } catch (error) {
+        // @ts-ignore
+        reject(new Error(`Invalid JSON in file: ${file.name}\n${error.message}`));
+      }
+    };
+
+    reader.onerror = () => {
+      reject(new Error(`Error reading file: ${file.name}`));
+    };
+
+    reader.readAsText(file);
+  });
+}
+
+/**
+ * Saves a JSON object as a downloadable file.
+ * @param {string} filename
+ * @param {any} data
+ * @param {number} [spaces=2]
+ */
+function saveJsonFile(filename, data, spaces = 2) {
+  const json = JSON.stringify(data, null, spaces);
+  const blob = new Blob([json], { type: 'application/json' });
+  const url = URL.createObjectURL(blob);
+
+  const link = document.createElement('a');
+  link.href = url;
+  link.download = filename;
+
+  document.body.appendChild(link);
+  link.click();
+  document.body.removeChild(link);
+
+  URL.revokeObjectURL(url);
+}
+
+/**
+ * Loads and parses a JSON from a remote URL using Fetch API.
+ *
+ * @param {string} url - The full URL to fetch JSON from.
+ * @param {Object} [options] - Optional settings.
+ * @param {string} [options.method="GET"] - HTTP method to use (GET, POST, etc.).
+ * @param {any} [options.body] - Request body (only for methods like POST, PUT).
+ * @param {number} [options.timeout=0] - Timeout in milliseconds (ignored if signal is provided).
+ * @param {number} [options.retries=0] - Number of retry attempts (ignored if signal is provided).
+ * @param {Headers|Record<string, *>} [options.headers={}] - Additional headers.
+ * @param {AbortSignal|null} [options.signal] - External AbortSignal; disables timeout and retries.
+ * @returns {Promise<*>} Parsed JSON object.
+ * @throws {Error} Throws if fetch fails, times out, or returns invalid JSON.
+ */
+async function fetchJson(
+  url,
+  { method = 'GET', body, timeout = 0, retries = 0, headers = {}, signal = null } = {},
+) {
+  if (
+    typeof url !== 'string' ||
+    (!url.startsWith('../') &&
+      !url.startsWith('./') &&
+      !url.startsWith('/') &&
+      !url.startsWith('https://') &&
+      !url.startsWith('http://'))
+  )
+    throw new Error('Invalid URL: must be a valid http or https address.');
+
+  if (typeof method !== 'string' || !method.trim())
+    throw new Error('Invalid method: must be a non-empty string.');
+
+  if (!signal) {
+    if (
+      typeof timeout !== 'number' ||
+      !Number.isFinite(timeout) ||
+      Number.isNaN(timeout) ||
+      timeout < 0
+    )
+      throw new Error('Invalid timeout: must be a positive number.');
+
+    if (
+      typeof retries !== 'number' ||
+      !Number.isFinite(retries) ||
+      Number.isNaN(retries) ||
+      retries < 0
+    )
+      throw new Error('Invalid retries: must be a positive number.');
+  }
+
+  const attempts = signal ? 1 : retries + 1;
+  /** @type {Error|null} */
+  let lastError = null;
+
+  for (let attempt = 0; attempt < attempts; attempt++) {
+    const controller = signal ? null : new AbortController();
+    const localSignal = signal || (controller?.signal ?? null);
+    const timer =
+      !signal && timeout && controller ? setTimeout(() => controller.abort(), timeout) : null;
+
+    try {
+      const response = await fetch(url, {
+        method: method.toUpperCase(),
+        headers: {
+          Accept: 'application/json',
+          ...headers,
+        },
+        body: body !== undefined ? (isJsonObject(body) ? JSON.stringify(body) : body) : undefined,
+        signal: localSignal,
+      });
+
+      if (timer) clearTimeout(timer);
+
+      if (!response.ok) throw new Error(`HTTP error: ${response.status} ${response.statusText}`);
+
+      const contentType = response.headers.get('content-type') || '';
+      if (!contentType.includes('application/json'))
+        throw new Error(`Unexpected content-type: ${contentType}`);
+
+      const data = await response.json();
+
+      if (!isJsonObject(data)) throw new Error('Received invalid data instead of valid JSON.');
+
+      return data;
+    } catch (err) {
+      lastError = /** @type {Error} */ (err);
+      if (signal) break; // if an external signal came, it does not retry
+      if (attempt < retries)
+        await new Promise((resolve) => setTimeout(resolve, 300 * (attempt + 1)));
+    }
+  }
+
+  throw new Error(
+    `Failed to fetch JSON from "${url}"${lastError ? `: ${lastError.message}` : '.'}`,
+  );
+}
+
+/**
+ * @typedef {Object} HtmlElBoxSides
+ * @property {number} x - Total horizontal size (left + right)
+ * @property {number} y - Total vertical size (top + bottom)
+ * @property {number} left
+ * @property {number} right
+ * @property {number} top
+ * @property {number} bottom
+ */
+
+/**
+ * Returns the total border width and individual sides from `border{Side}Width` CSS properties.
+ *
+ * @param {Element} el - The target DOM element.
+ * @returns {HtmlElBoxSides} - Total horizontal (x) and vertical (y) border widths, and each side individually.
+ */
+const getHtmlElBordersWidth = (el) => {
+  const styles = getComputedStyle(el);
+  const left = parseFloat(styles.borderLeftWidth) || 0;
+  const right = parseFloat(styles.borderRightWidth) || 0;
+  const top = parseFloat(styles.borderTopWidth) || 0;
+  const bottom = parseFloat(styles.borderBottomWidth) || 0;
+  const x = left + right;
+  const y = top + bottom;
+
+  return { x, y, left, right, top, bottom };
+};
+
+/**
+ * Returns the total border size and individual sides from `border{Side}` CSS properties.
+ *
+ * @param {Element} el - The target DOM element.
+ * @returns {HtmlElBoxSides} - Total horizontal (x) and vertical (y) border sizes, and each side individually.
+ */
+const getHtmlElBorders = (el) => {
+  const styles = getComputedStyle(el);
+  const left = parseFloat(styles.borderLeft) || 0;
+  const right = parseFloat(styles.borderRight) || 0;
+  const top = parseFloat(styles.borderTop) || 0;
+  const bottom = parseFloat(styles.borderBottom) || 0;
+  const x = left + right;
+  const y = top + bottom;
+
+  return { x, y, left, right, top, bottom };
+};
+
+/**
+ * Returns the total margin and individual sides from `margin{Side}` CSS properties.
+ *
+ * @param {Element} el - The target DOM element.
+ * @returns {HtmlElBoxSides} - Total horizontal (x) and vertical (y) margins, and each side individually.
+ */
+const getHtmlElMargin = (el) => {
+  const styles = getComputedStyle(el);
+  const left = parseFloat(styles.marginLeft) || 0;
+  const right = parseFloat(styles.marginRight) || 0;
+  const top = parseFloat(styles.marginTop) || 0;
+  const bottom = parseFloat(styles.marginBottom) || 0;
+
+  const x = left + right;
+  const y = top + bottom;
+
+  return { x, y, left, right, top, bottom };
+};
+
+/**
+ * Returns the total padding and individual sides from `padding{Side}` CSS properties.
+ *
+ * @param {Element} el - The target DOM element.
+ * @returns {HtmlElBoxSides} - Total horizontal (x) and vertical (y) paddings, and each side individually.
+ */
+const getHtmlElPadding = (el) => {
+  const styles = getComputedStyle(el);
+  const left = parseFloat(styles.paddingLeft) || 0;
+  const right = parseFloat(styles.paddingRight) || 0;
+  const top = parseFloat(styles.paddingTop) || 0;
+  const bottom = parseFloat(styles.paddingBottom) || 0;
+
+  const x = left + right;
+  const y = top + bottom;
+
+  return { x, y, left, right, top, bottom };
+};
+
+;// ./src/v1/libs/TinyDragger.mjs
+
+
+
+/**
+ * @typedef {Object} VibrationPatterns
+ * @property {number[]|false} start - Pattern to vibrate on start
+ * @property {number[]|false} end - Pattern to vibrate on end
+ * @property {number[]|false} collide - Pattern to vibrate on collision
+ * @property {number[]|false} move - Pattern to vibrate while moving
+ */
+
+/**
+ * TinyDragger enables drag-and-drop functionality for a DOM element.
+ * It supports jail boundaries, optional collision detection, vibration feedback,
+ * automatic reverting, proxy dragging, and event dispatching.
+ */
+class TinyDragger {
+  #enabled = true;
+  #destroyed = false;
+
+  #offsetY = 0;
+  #offsetX = 0;
+
+  #multiCollision = false;
+  #lockInsideJail = false;
+  #revertOnDrop = false;
+  #dragging = false;
+  #collisionByMouse = false;
+  #dropInJailOnly = false;
+
+  /** @type {HTMLElement|null} */
+  #lastCollision = null;
+
+  /** @type {HTMLElement[]} */
+  #collidables = [];
+
+  /** @type {HTMLElement|null} */
+  #dragProxy = null;
+
+  /** @type {VibrationPatterns} */
+  #vibration = { start: false, end: false, collide: false, move: false };
+
+  /** @type {HTMLElement|null} */
+  #jail = null;
+
+  #target;
+
+  #dragHiddenClass = 'drag-hidden';
+  #classDragging = 'dragging';
+  #classBodyDragging = 'drag-active';
+  #classJailDragging = 'jail-drag-active';
+  #classJailDragDisabled = 'jail-drag-disabled';
+  #classDragCollision = 'dragging-collision';
+
+  /** @typedef {(event: TouchEvent) => void} TouchDragEvent */
+
+  /**
+   * @param {HTMLElement} targetElement - The element to make draggable.
+   * @param {Object} [options={}] - Configuration options.
+   * @param {HTMLElement} [options.jail] - Optional container to restrict dragging within.
+   * @param {boolean} [options.collisionByMouse=false] - Use mouse position for collision instead of element rect.
+   * @param {string} [options.classDragging='dragging'] - CSS class applied to the clone during dragging.
+   * @param {string} [options.classBodyDragging='drag-active'] - CSS class applied to <body> during dragging.
+   * @param {string} [options.classJailDragging='jail-drag-active'] - CSS class applied to jail element during drag.
+   * @param {string} [options.classJailDragDisabled='jail-drag-disabled'] - CSS class applied to jail element disabled.
+   * @param {string} [options.classDragCollision='dragging-collision'] - CSS class applied to collision element.
+   * @param {boolean} [options.lockInsideJail=false] - Restrict movement within the jail container.
+   * @param {boolean} [options.dropInJailOnly=false] - Restrict drop within the jail container.
+   * @param {boolean} [options.multiCollision=false] - Enables returning multiple collided elements.
+   * @param {VibrationPatterns|false} [options.vibration=false] - Vibration feedback configuration.
+   * @param {boolean} [options.revertOnDrop=false] - Whether to return to original position on drop.
+   * @param {string} [options.classHidden='drag-hidden'] - CSS class to hide original element during dragging.
+   * @throws {Error} If any option has an invalid type.
+   */
+  constructor(targetElement, options = {}) {
+    if (!(targetElement instanceof HTMLElement))
+      throw new Error('TinyDragger requires a valid target HTMLElement to initialize.');
+
+    this.#target = targetElement;
+
+    // === Validations ===
+    if (options.jail !== undefined && !(options.jail instanceof HTMLElement))
+      throw new Error('The "jail" option must be an HTMLElement if provided.');
+
+    if (
+      options.vibration !== undefined &&
+      options.vibration !== false &&
+      !objFilter_isJsonObject(options.vibration)
+    )
+      throw new Error('The "vibration" option must be an object or false.');
+
+    /**
+     * @param {any} val
+     * @param {string} name
+     */
+    const validateBoolean = (val, name) => {
+      if (val !== undefined && typeof val !== 'boolean') {
+        throw new Error(`The "${name}" option must be a boolean.`);
+      }
+    };
+
+    /**
+     * @param {any} val
+     * @param {string} name
+     */
+    const validateString = (val, name) => {
+      if (val !== undefined && typeof val !== 'string') {
+        throw new Error(`The "${name}" option must be a string.`);
+      }
+    };
+
+    validateBoolean(options.collisionByMouse, 'collisionByMouse');
+    validateBoolean(options.lockInsideJail, 'lockInsideJail');
+    validateBoolean(options.dropInJailOnly, 'dropInJailOnly');
+    validateBoolean(options.revertOnDrop, 'revertOnDrop');
+    validateBoolean(options.multiCollision, 'multiCollision');
+
+    validateString(options.classDragging, 'classDragging');
+    validateString(options.classBodyDragging, 'classBodyDragging');
+    validateString(options.classJailDragging, 'classJailDragging');
+    validateString(options.classJailDragDisabled, 'classJailDragDisabled');
+    validateString(options.classDragCollision, 'classDragCollision');
+    validateString(options.classHidden, 'classHidden');
+
+    if (options.jail instanceof HTMLElement) this.#jail = options.jail;
+
+    /** @type {VibrationPatterns} */
+    const vibrationTemplate = { start: false, end: false, collide: false, move: false };
+    this.#vibration = Object.assign(
+      vibrationTemplate,
+      objFilter_isJsonObject(options.vibration) ? options.vibration : {},
+    );
+
+    if (typeof options.classDragging === 'string') this.#classDragging = options.classDragging;
+    if (typeof options.classBodyDragging === 'string')
+      this.#classBodyDragging = options.classBodyDragging;
+    if (typeof options.classJailDragging === 'string')
+      this.#classJailDragging = options.classJailDragging;
+    if (typeof options.classJailDragDisabled === 'string')
+      this.#classJailDragDisabled = options.classJailDragDisabled;
+    if (typeof options.classHidden === 'string') this.#dragHiddenClass = options.classHidden;
+    if (typeof options.classDragCollision === 'string')
+      this.#classDragCollision = options.classDragCollision;
+
+    if (typeof options.collisionByMouse === 'boolean')
+      this.#collisionByMouse = options.collisionByMouse;
+    if (typeof options.revertOnDrop === 'boolean') this.#revertOnDrop = options.revertOnDrop;
+    if (typeof options.lockInsideJail === 'boolean') this.#lockInsideJail = options.lockInsideJail;
+    if (typeof options.dropInJailOnly === 'boolean') this.#dropInJailOnly = options.dropInJailOnly;
+    if (typeof options.multiCollision === 'boolean') this.#multiCollision = options.multiCollision;
+
+    /** @private */
+    this._onMouseDown = this.#startDrag.bind(this);
+    /** @private */
+    this._onMouseMove = this.#drag.bind(this);
+    /** @private */
+    this._onMouseUp = this.#endDrag.bind(this);
+
+    /**
+     * @type {TouchDragEvent}
+     * @private
+     */
+    this._onTouchStart = (e) => this.#startDrag(e.touches[0]);
+
+    /**
+     * @type {TouchDragEvent}
+     * @private
+     */
+    this._onTouchMove = (e) => this.#drag(e.touches[0]);
+
+    /**
+     * @type {TouchDragEvent}
+     * @private
+     */
+    this._onTouchEnd = (e) => this.#endDrag(e.changedTouches[0]);
+
+    this.#target.addEventListener('mousedown', this._onMouseDown);
+    this.#target.addEventListener('touchstart', this._onTouchStart, { passive: false });
+  }
+
+  /**
+   * Enables the drag functionality.
+   */
+  enable() {
+    this.#checkDestroy();
+    if (this.#jail) this.#jail.classList.add(this.#classJailDragDisabled);
+    this.#enabled = true;
+  }
+
+  /**
+   * Disables the drag functionality.
+   */
+  disable() {
+    if (this.#jail) this.#jail.classList.remove(this.#classJailDragDisabled);
+    this.#enabled = false;
+  }
+
+  /**
+   * Adds an element to be considered for collision detection.
+   * @param {HTMLElement} element - The element to track collisions with.
+   * @throws {Error} If the element is not a valid HTMLElement.
+   */
+  addCollidable(element) {
+    this.#checkDestroy();
+    if (!(element instanceof HTMLElement))
+      throw new Error('addCollidable expects an HTMLElement as argument.');
+    if (!this.#collidables.includes(element)) this.#collidables.push(element);
+  }
+
+  /**
+   * Removes a collidable element from the tracking list.
+   * @param {HTMLElement} element - The element to remove.
+   * @throws {Error} If the element is not a valid HTMLElement.
+   */
+  removeCollidable(element) {
+    this.#checkDestroy();
+    if (!(element instanceof HTMLElement))
+      throw new Error('removeCollidable expects an HTMLElement as argument.');
+    this.#collidables = this.#collidables.filter((el) => el !== element);
+  }
+
+  /**
+   * Sets vibration patterns for drag events.
+   * @param {Object} [param0={}] - Vibration pattern configuration.
+   * @param {number[]|false} [param0.startPattern=false] - Vibration on drag start.
+   * @param {number[]|false} [param0.endPattern=false] - Vibration on drag end.
+   * @param {number[]|false} [param0.collidePattern=false] - Vibration on collision.
+   * @param {number[]|false} [param0.movePattern=false] - Vibration during movement.
+   * @throws {Error} If any pattern is not false or an array of numbers.
+   */
+  setVibrationPattern({
+    startPattern = false,
+    endPattern = false,
+    collidePattern = false,
+    movePattern = false,
+  } = {}) {
+    this.#checkDestroy();
+
+    /** @param {any} value */
+    const isValidPattern = (value) =>
+      value === false || (Array.isArray(value) && value.every((n) => typeof n === 'number'));
+
+    if (!isValidPattern(startPattern))
+      throw new Error('Invalid "startPattern": must be false or an array of numbers.');
+    if (!isValidPattern(endPattern))
+      throw new Error('Invalid "endPattern": must be false or an array of numbers.');
+    if (!isValidPattern(collidePattern))
+      throw new Error('Invalid "collidePattern": must be false or an array of numbers.');
+    if (!isValidPattern(movePattern))
+      throw new Error('Invalid "movePattern": must be false or an array of numbers.');
+
+    this.#vibration = {
+      start: startPattern,
+      end: endPattern,
+      collide: collidePattern,
+      move: movePattern,
+    };
+  }
+
+  /**
+   * Disables all vibration feedback.
+   */
+  disableVibration() {
+    this.#checkDestroy();
+    this.#vibration = { start: false, end: false, collide: false, move: false };
+  }
+
+  /**
+   * Calculates the cursor offset relative to the top-left of the target element.
+   * @param {MouseEvent|Touch} event - The mouse or touch event.
+   * @returns {{x: number, y: number}} The offset in pixels.
+   * @throws {Error} If event is not a MouseEvent or Touch with clientX/clientY.
+   */
+  getOffset(event) {
+    this.#checkDestroy();
+    if (
+      (!(event instanceof MouseEvent) && !(event instanceof Touch)) ||
+      typeof event.clientX !== 'number' ||
+      typeof event.clientY !== 'number'
+    )
+      throw new Error('getOffset expects an event with valid clientX and clientY coordinates.');
+
+    const targetRect = this.#target.getBoundingClientRect();
+    const { left: borderLeft, top: borderTop } = getHtmlElBordersWidth(this.#target);
+    return {
+      x: event.clientX - targetRect.left + borderLeft,
+      y: event.clientY - targetRect.top + borderTop,
+    };
+  }
+
+  /**
+   * Handles the start of a drag event.
+   * @param {MouseEvent|Touch} event - The initiating event.
+   */
+  #startDrag(event) {
+    if (event instanceof MouseEvent) event.preventDefault();
+    if (this.#destroyed || !this.#enabled || !this.#target.parentElement) return;
+
+    const dragProxy = this.#target.cloneNode(true);
+    if (!(dragProxy instanceof HTMLElement)) return;
+    this.#dragProxy = dragProxy;
+
+    this.#dragging = true;
+
+    const rect = this.#target.getBoundingClientRect();
+
+    Object.assign(this.#dragProxy.style, {
+      position: 'absolute',
+      pointerEvents: 'none',
+      left: `${this.#target.offsetLeft}px`,
+      top: `${this.#target.offsetTop}px`,
+      width: `${rect.width}px`,
+      height: `${rect.height}px`,
+      zIndex: 9999,
+    });
+
+    this.#target.classList.add(this.#dragHiddenClass);
+    this.#target.parentElement.appendChild(this.#dragProxy);
+
+    const { x: offsetX, y: offsetY } = this.getOffset(event);
+    this.#offsetX = offsetX;
+    this.#offsetY = offsetY;
+
+    this.#dragProxy.classList.add(this.#classDragging);
+    document.body.classList.add(this.#classBodyDragging);
+    if (this.#jail) this.#jail.classList.add(this.#classJailDragging);
+
+    document.addEventListener('mousemove', this._onMouseMove);
+    document.addEventListener('mouseup', this._onMouseUp);
+
+    document.addEventListener('touchmove', this._onTouchMove, { passive: false });
+    document.addEventListener('touchend', this._onTouchEnd);
+
+    if (navigator.vibrate && Array.isArray(this.#vibration.start)) {
+      navigator.vibrate(this.#vibration.start);
+    }
+
+    this.checkDragCollision(event);
+    this.#dispatchEvent('drag');
+  }
+
+  /** @type {HTMLElement[]} */
+  #collisionsMarked = [];
+
+  /**
+   * Marks an element as currently collided by adding the collision CSS class.
+   * The element is stored in an internal list for easy removal later.
+   *
+   * @param {HTMLElement|null} el - The element to mark as collided.
+   */
+  #addCollision(el) {
+    if (!el) return;
+    el.classList.add(this.#classDragCollision);
+    this.#collisionsMarked.push(el);
+  }
+
+  /**
+   * Removes the collision CSS class from all previously marked elements.
+   * Also clears the last single collision element, if set.
+   *
+   */
+  #removeCollision() {
+    while (this.#collisionsMarked.length > 0) {
+      const el = this.#collisionsMarked.shift();
+      if (el) el.classList.remove(this.#classDragCollision);
+    }
+    if (!this.#lastCollision) return;
+    this.#lastCollision.classList.remove(this.#classDragCollision);
+  }
+
+  /**
+   * Handles dragging collision.
+   * @param {MouseEvent|Touch} event - The drag event.
+   */
+  checkDragCollision(event) {
+    const { collidedElements } = this.execCollision(event);
+    const first = collidedElements[0] || null;
+
+    // Removes old marking if necessary
+    if (this.#lastCollision && !collidedElements.includes(this.#lastCollision)) {
+      this.#removeCollision();
+    }
+
+    // Adds Marking for All Colluded
+    collidedElements.forEach((el) => this.#addCollision(el));
+
+    // Removes markings from who no longer collided
+    this.#collidables.forEach((el) => {
+      if (!collidedElements.includes(el)) {
+        el.classList.remove(this.#classDragCollision);
+      }
+    });
+
+    if (
+      navigator.vibrate &&
+      Array.isArray(this.#vibration.collide) &&
+      collidedElements.length > 0
+    ) {
+      navigator.vibrate(this.#vibration.collide);
+    }
+
+    this.#lastCollision = first;
+  }
+
+  /**
+   * Handles dragging movement.
+   * @param {MouseEvent|Touch} event - The drag event.
+   */
+  #drag(event) {
+    if (event instanceof MouseEvent) event.preventDefault();
+    if (this.#destroyed || !this.#dragging || !this.#enabled || !this.#dragProxy) return;
+
+    const parent = this.#dragProxy.offsetParent || document.body;
+    const parentRect = parent.getBoundingClientRect();
+
+    let x = event.clientX - parentRect.left - this.#offsetX;
+    let y = event.clientY - parentRect.top - this.#offsetY;
+
+    if (this.#lockInsideJail && this.#jail) {
+      const jailRect = this.#jail.getBoundingClientRect();
+      const targetRect = this.#dragProxy.getBoundingClientRect();
+
+      const jailLeft = jailRect.left - parentRect.left;
+      const jailTop = jailRect.top - parentRect.top;
+
+      const { x: borderX, y: borderY } = getHtmlElBordersWidth(this.#jail);
+      const maxX = jailLeft + jailRect.width - targetRect.width - borderY;
+      const maxY = jailTop + jailRect.height - targetRect.height - borderX;
+
+      x = Math.max(jailLeft, Math.min(x, maxX));
+      y = Math.max(jailTop, Math.min(y, maxY));
+    }
+
+    this.#dragProxy.style.position = 'absolute';
+    this.#dragProxy.style.left = `${x}px`;
+    this.#dragProxy.style.top = `${y}px`;
+
+    if (navigator.vibrate && Array.isArray(this.#vibration.move)) {
+      navigator.vibrate(this.#vibration.move);
+    }
+
+    this.checkDragCollision(event);
+    this.#dispatchEvent('dragging');
+  }
+
+  /**
+   * Handles the collision of a drag.
+   * @param {MouseEvent|Touch} event - The release event.
+   * @returns {{ inJail: boolean; collidedElements: (HTMLElement | null)[] }}
+   */
+  execCollision(event) {
+    if (this.#destroyed || !this.#dragProxy) return { inJail: false, collidedElements: [] };
+
+    let collidedElements = [];
+    let inJail = true;
+    const jailRect = this.#jail?.getBoundingClientRect();
+
+    if (this.#collisionByMouse) {
+      const x = event.clientX;
+      const y = event.clientY;
+
+      if (this.#dropInJailOnly && this.#jail && jailRect) {
+        inJail =
+          x >= jailRect.left && x <= jailRect.right && y >= jailRect.top && y <= jailRect.bottom;
+      }
+
+      collidedElements = inJail
+        ? this.#multiCollision
+          ? this.getAllCollidedElements(x, y)
+          : [this.getCollidedElement(x, y)].filter(Boolean)
+        : [];
+    } else {
+      const rect = this.#dragProxy.getBoundingClientRect();
+
+      if (this.#dropInJailOnly && this.#jail && jailRect) {
+        inJail =
+          rect.left >= jailRect.left &&
+          rect.right <= jailRect.right &&
+          rect.top >= jailRect.top &&
+          rect.bottom <= jailRect.bottom;
+      }
+
+      collidedElements = inJail
+        ? this.#multiCollision
+          ? this.getAllCollidedElementsByRect(rect)
+          : [this.getCollidedElementByRect(rect)].filter(Boolean)
+        : [];
+    }
+
+    return { inJail, collidedElements };
+  }
+
+  /**
+   * Handles the end of a drag.
+   * @param {MouseEvent|Touch} event - The release event.
+   */
+  #endDrag(event) {
+    if (event instanceof MouseEvent) event.preventDefault();
+    if (this.#destroyed || !this.#dragging) return;
+
+    this.#dragging = false;
+    if (!this.#dragProxy) return;
+
+    this.#target.classList.remove(this.#classDragging);
+    document.body.classList.remove(this.#classBodyDragging);
+    if (this.#jail) this.#jail.classList.remove(this.#classJailDragging);
+
+    document.removeEventListener('mousemove', this._onMouseMove);
+    document.removeEventListener('mouseup', this._onMouseUp);
+
+    document.removeEventListener('touchmove', this._onTouchMove);
+    document.removeEventListener('touchend', this._onTouchEnd);
+    const { collidedElements } = this.execCollision(event);
+
+    if (navigator.vibrate && Array.isArray(this.#vibration.end)) {
+      navigator.vibrate(this.#vibration.end);
+    }
+
+    const newX = this.#dragProxy.style.left;
+    const newY = this.#dragProxy.style.top;
+    if (this.#dragProxy) {
+      this.#dragProxy.remove();
+      this.#dragProxy = null;
+    }
+
+    if (this.#lastCollision) this.#removeCollision();
+    this.#lastCollision = null;
+
+    this.#target.classList.remove(this.#dragHiddenClass);
+    if (!this.#revertOnDrop) {
+      this.#target.style.left = newX;
+      this.#target.style.top = newY;
+    }
+
+    const dropEvent = new CustomEvent('drop', {
+      detail: {
+        targets: collidedElements,
+        first: collidedElements[0] || null,
+      },
+    });
+    this.#target.dispatchEvent(dropEvent);
+  }
+
+  /**
+   * Checks if the provided element intersects with the given bounding rectangle.
+   *
+   * @param {HTMLElement} el - The element to test for collision.
+   * @param {DOMRect} rect - The bounding rectangle to check against.
+   * @returns {boolean} True if the element intersects with the rectangle.
+   */
+  #getCollidedElementByRect(el, rect) {
+    const elRect = el.getBoundingClientRect();
+    return !(
+      rect.right < elRect.left ||
+      rect.left > elRect.right ||
+      rect.bottom < elRect.top ||
+      rect.top > elRect.bottom
+    );
+  }
+
+  /**
+   * Returns all elements currently colliding with the given rectangle.
+   *
+   * @param {DOMRect} rect - Bounding rectangle of the dragged proxy.
+   * @returns {HTMLElement[]} A list of all collided elements.
+   * @throws {Error} If the input is not a valid DOMRect with numeric bounds.
+   */
+  getAllCollidedElementsByRect(rect) {
+    this.#checkDestroy();
+    if (
+      !(rect instanceof DOMRect) ||
+      typeof rect.left !== 'number' ||
+      typeof rect.right !== 'number' ||
+      typeof rect.top !== 'number' ||
+      typeof rect.bottom !== 'number'
+    )
+      throw new Error('getCollidedElementByRect expects a valid DOMRect object.');
+    return this.#collidables.filter((el) => this.#getCollidedElementByRect(el, rect));
+  }
+
+  /**
+   * Detects collision based on rectangle intersection.
+   * @param {DOMRect} rect - Bounding rectangle of the dragged proxy.
+   * @returns {HTMLElement|null} The collided element or null.
+   * @throws {Error} If rect is not a DOMRect with valid numeric properties.
+   */
+  getCollidedElementByRect(rect) {
+    this.#checkDestroy();
+    if (
+      !(rect instanceof DOMRect) ||
+      typeof rect.left !== 'number' ||
+      typeof rect.right !== 'number' ||
+      typeof rect.top !== 'number' ||
+      typeof rect.bottom !== 'number'
+    )
+      throw new Error('getCollidedElementByRect expects a valid DOMRect object.');
+    return this.#collidables.find((el) => this.#getCollidedElementByRect(el, rect)) || null;
+  }
+
+  /**
+   * Checks whether a given (x, y) coordinate is inside the bounding rectangle of an element.
+   *
+   * @param {HTMLElement} el - The element to test for collision.
+   * @param {number} x - Horizontal screen coordinate.
+   * @param {number} y - Vertical screen coordinate.
+   * @returns {boolean} True if the point is within the element's bounds.
+   */
+  #getCollidedElement(el, x, y) {
+    const rect = el.getBoundingClientRect();
+    return x >= rect.left && x <= rect.right && y >= rect.top && y <= rect.bottom;
+  }
+
+  /**
+   * @param {number} x - Horizontal screen coordinate.
+   * @param {number} y - Vertical screen coordinate.
+   * @returns {HTMLElement[]} The collided element or null.
+   */
+  getAllCollidedElements(x, y) {
+    this.#checkDestroy();
+    if (typeof x !== 'number' || typeof y !== 'number')
+      throw new Error('getCollidedElement expects numeric x and y coordinates.');
+    return this.#collidables.filter((el) => this.#getCollidedElement(el, x, y));
+  }
+
+  /**
+   * Detects collision with a point using element bounding rectangles.
+   * @param {number} x - Horizontal screen coordinate.
+   * @param {number} y - Vertical screen coordinate.
+   * @returns {HTMLElement|null} The collided element or null.
+   */
+  getCollidedElement(x, y) {
+    this.#checkDestroy();
+    if (typeof x !== 'number' || typeof y !== 'number')
+      throw new Error('getCollidedElement expects numeric x and y coordinates.');
+    return this.#collidables.find((el) => this.#getCollidedElement(el, x, y)) || null;
+  }
+
+  /**
+   * Dispatches a custom event from the target element.
+   * @param {string} type - The event name.
+   */
+  #dispatchEvent(type) {
+    const event = new CustomEvent(type);
+    this.#target.dispatchEvent(event);
+  }
+
+  /**
+   * Gets whether dragging is currently active.
+   * @returns {boolean}
+   */
+  getDragging() {
+    return this.#dragging;
+  }
+
+  /**
+   * Gets whether movement is restricted inside the jail container.
+   * @returns {boolean}
+   */
+  getLockInsideJail() {
+    return this.#lockInsideJail;
+  }
+
+  /**
+   * Sets whether movement is restricted inside the jail container.
+   * @param {boolean} value
+   */
+  setLockInsideJail(value) {
+    if (typeof value !== 'boolean') throw new Error('lockInsideJail must be a boolean.');
+    this.#lockInsideJail = value;
+  }
+
+  /**
+   * Gets whether the element should revert to original position on drop.
+   * @returns {boolean}
+   */
+  getRevertOnDrop() {
+    return this.#revertOnDrop;
+  }
+
+  /**
+   * Sets whether the element should revert to original position on drop.
+   * @param {boolean} value
+   */
+  setRevertOnDrop(value) {
+    if (typeof value !== 'boolean') throw new Error('revertOnDrop must be a boolean.');
+    this.#revertOnDrop = value;
+  }
+
+  /**
+   * Gets whether collision detection uses mouse position.
+   * @returns {boolean}
+   */
+  getCollisionByMouse() {
+    return this.#collisionByMouse;
+  }
+
+  /**
+   * Sets whether collision detection uses mouse position.
+   * @param {boolean} value
+   */
+  setCollisionByMouse(value) {
+    if (typeof value !== 'boolean') throw new Error('collisionByMouse must be a boolean.');
+    this.#collisionByMouse = value;
+  }
+
+  /**
+   * Gets whether dropping is restricted inside the jail container.
+   * @returns {boolean}
+   */
+  getDropInJailOnly() {
+    return this.#dropInJailOnly;
+  }
+
+  /**
+   * Sets whether dropping is restricted inside the jail container.
+   * @param {boolean} value
+   */
+  setDropInJailOnly(value) {
+    if (typeof value !== 'boolean') throw new Error('dropInJailOnly must be a boolean.');
+    this.#dropInJailOnly = value;
+  }
+
+  /**
+   * Returns the original target element being dragged.
+   * @returns {HTMLElement}
+   */
+  getTarget() {
+    return this.#target;
+  }
+
+  /**
+   * Returns the current jail container (if any).
+   * @returns {HTMLElement|null}
+   */
+  getJail() {
+    return this.#jail;
+  }
+
+  /**
+   * Returns the current proxy element being dragged (if any).
+   * @returns {HTMLElement|null}
+   */
+  getDragProxy() {
+    return this.#dragProxy;
+  }
+
+  /**
+   * Returns the last collided element (if any).
+   * @returns {HTMLElement|null}
+   */
+  getLastCollision() {
+    return this.#lastCollision;
+  }
+
+  /**
+   * Returns all registered collidable elements.
+   * @returns {HTMLElement[]}
+   */
+  getCollidables() {
+    return [...this.#collidables];
+  }
+
+  /**
+   * Returns the CSS class used to hide the target during drag.
+   * @returns {string}
+   */
+  getDragHiddenClass() {
+    return this.#dragHiddenClass;
+  }
+
+  /**
+   * Returns the CSS class applied to the clone during dragging.
+   * @returns {string}
+   */
+  getClassDragging() {
+    return this.#classDragging;
+  }
+
+  /**
+   * Returns the CSS class applied to <body> during dragging.
+   * @returns {string}
+   */
+  getClassBodyDragging() {
+    return this.#classBodyDragging;
+  }
+
+  /**
+   * Returns the CSS class applied to the jail during dragging.
+   * @returns {string}
+   */
+  getClassJailDragging() {
+    return this.#classJailDragging;
+  }
+
+  /**
+   * Returns the CSS class applied to the jail when dragging is disabled.
+   * @returns {string}
+   */
+  getClassJailDragDisabled() {
+    return this.#classJailDragDisabled;
+  }
+
+  /**
+   * Returns the CSS class applied to a collided element.
+   * @returns {string}
+   */
+  getClassDragCollision() {
+    return this.#classDragCollision;
+  }
+
+  /**
+   * Returns the full vibration configuration.
+   * @returns {VibrationPatterns}
+   */
+  getVibrations() {
+    return { ...this.#vibration };
+  }
+
+  /**
+   * Returns the vibration pattern for drag start.
+   * @returns {number[]|boolean}
+   */
+  getStartVibration() {
+    return this.#vibration.start;
+  }
+
+  /**
+   * Returns the vibration pattern for drag end.
+   * @returns {number[]|boolean}
+   */
+  getEndVibration() {
+    return this.#vibration.end;
+  }
+
+  /**
+   * Returns the vibration pattern for collisions.
+   * @returns {number[]|boolean}
+   */
+  getCollideVibration() {
+    return this.#vibration.collide;
+  }
+
+  /**
+   * Returns the vibration pattern during movement.
+   * @returns {number[]|boolean}
+   */
+  getMoveVibration() {
+    return this.#vibration.move;
+  }
+
+  /**
+   * Returns whether the dragger is currently enabled.
+   * @returns {boolean}
+   */
+  isEnabled() {
+    return this.#enabled;
+  }
+
+  /**
+   * Internal method to verify if the instance has been destroyed.
+   * Throws an error if any operation is attempted after destruction.
+   */
+  #checkDestroy() {
+    if (this.#destroyed)
+      throw new Error('This TinyDragger instance has been destroyed and can no longer be used.');
+  }
+
+  /**
+   * Completely disables drag-and-drop and cleans up all event listeners.
+   * Does NOT remove the original HTML element.
+   */
+  destroy() {
+    if (this.#destroyed) return;
+    this.disable();
+
+    this.#target.removeEventListener('mousedown', this._onMouseDown);
+    this.#target.removeEventListener('touchstart', this._onTouchStart);
+
+    document.removeEventListener('mousemove', this._onMouseMove);
+    document.removeEventListener('mouseup', this._onMouseUp);
+
+    document.removeEventListener('touchmove', this._onTouchMove);
+    document.removeEventListener('touchend', this._onTouchEnd);
+
+    if (this.#lastCollision) this.#removeCollision();
+    if (this.#dragProxy) {
+      this.#dragProxy.remove();
+      this.#dragProxy = null;
+    }
+
+    this.#collidables = [];
+    this.#dragging = false;
+    this.#lastCollision = null;
+
+    this.#target.classList.remove(this.#dragHiddenClass, this.#classDragging);
+    document.body.classList.remove(this.#classBodyDragging);
+    if (this.#jail)
+      this.#jail.classList.remove(this.#classJailDragging, this.#classJailDragDisabled);
+
+    this.#destroyed = true;
+  }
+}
+
+/* harmony default export */ const libs_TinyDragger = (TinyDragger);
+
+;// ./src/v1/build/TinyDragger.mjs
+
+
+
+
+})();
+
+window.TinyDragger = __webpack_exports__.TinyDragger;
+/******/ })()
+;