@teselagen/range-utils 0.3.8 → 0.3.10

package/index.cjs

@@ -0,0 +1,2619 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+function splitRangeIntoTwoPartsIfItIsCircular(range, sequenceLength) {
+  if (sequenceLength !== 0) {
+    sequenceLength = sequenceLength || Infinity;
+  }
+  const ranges = [];
+  if (range.start > range.end) {
+    ranges.push({
+      start: 0,
+      end: range.end,
+      type: "end"
+    });
+    ranges.push({
+      start: range.start,
+      end: sequenceLength - 1,
+      type: "beginning"
+    });
+  } else {
+    ranges.push({
+      start: range.start,
+      end: range.end,
+      type: "beginningAndEnd"
+    });
+  }
+  return ranges;
+}
+__name(splitRangeIntoTwoPartsIfItIsCircular, "splitRangeIntoTwoPartsIfItIsCircular");
+var freeGlobal = typeof global == "object" && global && global.Object === Object && global;
+var freeSelf = typeof self == "object" && self && self.Object === Object && self;
+var root = freeGlobal || freeSelf || Function("return this")();
+var Symbol$1 = root.Symbol;
+var objectProto$f = Object.prototype;
+var hasOwnProperty$c = objectProto$f.hasOwnProperty;
+var nativeObjectToString$1 = objectProto$f.toString;
+var symToStringTag$1 = Symbol$1 ? Symbol$1.toStringTag : void 0;
+function getRawTag(value) {
+  var isOwn = hasOwnProperty$c.call(value, symToStringTag$1), tag = value[symToStringTag$1];
+  try {
+    value[symToStringTag$1] = void 0;
+    var unmasked = true;
+  } catch (e) {
+  }
+  var result = nativeObjectToString$1.call(value);
+  if (unmasked) {
+    if (isOwn) {
+      value[symToStringTag$1] = tag;
+    } else {
+      delete value[symToStringTag$1];
+    }
+  }
+  return result;
+}
+__name(getRawTag, "getRawTag");
+var objectProto$e = Object.prototype;
+var nativeObjectToString = objectProto$e.toString;
+function objectToString(value) {
+  return nativeObjectToString.call(value);
+}
+__name(objectToString, "objectToString");
+var nullTag = "[object Null]", undefinedTag = "[object Undefined]";
+var symToStringTag = Symbol$1 ? Symbol$1.toStringTag : void 0;
+function baseGetTag(value) {
+  if (value == null) {
+    return value === void 0 ? undefinedTag : nullTag;
+  }
+  return symToStringTag && symToStringTag in Object(value) ? getRawTag(value) : objectToString(value);
+}
+__name(baseGetTag, "baseGetTag");
+function isObjectLike(value) {
+  return value != null && typeof value == "object";
+}
+__name(isObjectLike, "isObjectLike");
+var symbolTag$3 = "[object Symbol]";
+function isSymbol(value) {
+  return typeof value == "symbol" || isObjectLike(value) && baseGetTag(value) == symbolTag$3;
+}
+__name(isSymbol, "isSymbol");
+function arrayMap(array, iteratee) {
+  var index = -1, length = array == null ? 0 : array.length, result = Array(length);
+  while (++index < length) {
+    result[index] = iteratee(array[index], index, array);
+  }
+  return result;
+}
+__name(arrayMap, "arrayMap");
+var isArray = Array.isArray;
+var INFINITY$1 = 1 / 0;
+var symbolProto$2 = Symbol$1 ? Symbol$1.prototype : void 0, symbolToString = symbolProto$2 ? symbolProto$2.toString : void 0;
+function baseToString(value) {
+  if (typeof value == "string") {
+    return value;
+  }
+  if (isArray(value)) {
+    return arrayMap(value, baseToString) + "";
+  }
+  if (isSymbol(value)) {
+    return symbolToString ? symbolToString.call(value) : "";
+  }
+  var result = value + "";
+  return result == "0" && 1 / value == -INFINITY$1 ? "-0" : result;
+}
+__name(baseToString, "baseToString");
+function isObject(value) {
+  var type = typeof value;
+  return value != null && (type == "object" || type == "function");
+}
+__name(isObject, "isObject");
+function identity(value) {
+  return value;
+}
+__name(identity, "identity");
+var asyncTag = "[object AsyncFunction]", funcTag$2 = "[object Function]", genTag$1 = "[object GeneratorFunction]", proxyTag = "[object Proxy]";
+function isFunction(value) {
+  if (!isObject(value)) {
+    return false;
+  }
+  var tag = baseGetTag(value);
+  return tag == funcTag$2 || tag == genTag$1 || tag == asyncTag || tag == proxyTag;
+}
+__name(isFunction, "isFunction");
+var coreJsData = root["__core-js_shared__"];
+var maskSrcKey = function() {
+  var uid = /[^.]+$/.exec(coreJsData && coreJsData.keys && coreJsData.keys.IE_PROTO || "");
+  return uid ? "Symbol(src)_1." + uid : "";
+}();
+function isMasked(func) {
+  return !!maskSrcKey && maskSrcKey in func;
+}
+__name(isMasked, "isMasked");
+var funcProto$1 = Function.prototype;
+var funcToString$1 = funcProto$1.toString;
+function toSource(func) {
+  if (func != null) {
+    try {
+      return funcToString$1.call(func);
+    } catch (e) {
+    }
+    try {
+      return func + "";
+    } catch (e) {
+    }
+  }
+  return "";
+}
+__name(toSource, "toSource");
+var reRegExpChar = /[\\^$.*+?()[\]{}|]/g;
+var reIsHostCtor = /^\[object .+?Constructor\]$/;
+var funcProto = Function.prototype, objectProto$d = Object.prototype;
+var funcToString = funcProto.toString;
+var hasOwnProperty$b = objectProto$d.hasOwnProperty;
+var reIsNative = RegExp(
+  "^" + funcToString.call(hasOwnProperty$b).replace(reRegExpChar, "\\$&").replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g, "$1.*?") + "$"
+);
+function baseIsNative(value) {
+  if (!isObject(value) || isMasked(value)) {
+    return false;
+  }
+  var pattern = isFunction(value) ? reIsNative : reIsHostCtor;
+  return pattern.test(toSource(value));
+}
+__name(baseIsNative, "baseIsNative");
+function getValue(object, key) {
+  return object == null ? void 0 : object[key];
+}
+__name(getValue, "getValue");
+function getNative(object, key) {
+  var value = getValue(object, key);
+  return baseIsNative(value) ? value : void 0;
+}
+__name(getNative, "getNative");
+var WeakMap = getNative(root, "WeakMap");
+var objectCreate = Object.create;
+var baseCreate = /* @__PURE__ */ function() {
+  function object() {
+  }
+  __name(object, "object");
+  return function(proto) {
+    if (!isObject(proto)) {
+      return {};
+    }
+    if (objectCreate) {
+      return objectCreate(proto);
+    }
+    object.prototype = proto;
+    var result = new object();
+    object.prototype = void 0;
+    return result;
+  };
+}();
+function apply(func, thisArg, args) {
+  switch (args.length) {
+    case 0:
+      return func.call(thisArg);
+    case 1:
+      return func.call(thisArg, args[0]);
+    case 2:
+      return func.call(thisArg, args[0], args[1]);
+    case 3:
+      return func.call(thisArg, args[0], args[1], args[2]);
+  }
+  return func.apply(thisArg, args);
+}
+__name(apply, "apply");
+function copyArray(source, array) {
+  var index = -1, length = source.length;
+  array || (array = Array(length));
+  while (++index < length) {
+    array[index] = source[index];
+  }
+  return array;
+}
+__name(copyArray, "copyArray");
+var HOT_COUNT = 800, HOT_SPAN = 16;
+var nativeNow = Date.now;
+function shortOut(func) {
+  var count = 0, lastCalled = 0;
+  return function() {
+    var stamp = nativeNow(), remaining = HOT_SPAN - (stamp - lastCalled);
+    lastCalled = stamp;
+    if (remaining > 0) {
+      if (++count >= HOT_COUNT) {
+        return arguments[0];
+      }
+    } else {
+      count = 0;
+    }
+    return func.apply(void 0, arguments);
+  };
+}
+__name(shortOut, "shortOut");
+function constant(value) {
+  return function() {
+    return value;
+  };
+}
+__name(constant, "constant");
+var defineProperty = function() {
+  try {
+    var func = getNative(Object, "defineProperty");
+    func({}, "", {});
+    return func;
+  } catch (e) {
+  }
+}();
+var baseSetToString = !defineProperty ? identity : function(func, string) {
+  return defineProperty(func, "toString", {
+    "configurable": true,
+    "enumerable": false,
+    "value": constant(string),
+    "writable": true
+  });
+};
+var setToString = shortOut(baseSetToString);
+function arrayEach(array, iteratee) {
+  var index = -1, length = array == null ? 0 : array.length;
+  while (++index < length) {
+    if (iteratee(array[index], index, array) === false) {
+      break;
+    }
+  }
+  return array;
+}
+__name(arrayEach, "arrayEach");
+var MAX_SAFE_INTEGER$1 = 9007199254740991;
+var reIsUint = /^(?:0|[1-9]\d*)$/;
+function isIndex(value, length) {
+  var type = typeof value;
+  length = length == null ? MAX_SAFE_INTEGER$1 : length;
+  return !!length && (type == "number" || type != "symbol" && reIsUint.test(value)) && (value > -1 && value % 1 == 0 && value < length);
+}
+__name(isIndex, "isIndex");
+function baseAssignValue(object, key, value) {
+  if (key == "__proto__" && defineProperty) {
+    defineProperty(object, key, {
+      "configurable": true,
+      "enumerable": true,
+      "value": value,
+      "writable": true
+    });
+  } else {
+    object[key] = value;
+  }
+}
+__name(baseAssignValue, "baseAssignValue");
+function eq(value, other) {
+  return value === other || value !== value && other !== other;
+}
+__name(eq, "eq");
+var objectProto$c = Object.prototype;
+var hasOwnProperty$a = objectProto$c.hasOwnProperty;
+function assignValue(object, key, value) {
+  var objValue = object[key];
+  if (!(hasOwnProperty$a.call(object, key) && eq(objValue, value)) || value === void 0 && !(key in object)) {
+    baseAssignValue(object, key, value);
+  }
+}
+__name(assignValue, "assignValue");
+function copyObject(source, props, object, customizer) {
+  var isNew = !object;
+  object || (object = {});
+  var index = -1, length = props.length;
+  while (++index < length) {
+    var key = props[index];
+    var newValue = void 0;
+    if (newValue === void 0) {
+      newValue = source[key];
+    }
+    if (isNew) {
+      baseAssignValue(object, key, newValue);
+    } else {
+      assignValue(object, key, newValue);
+    }
+  }
+  return object;
+}
+__name(copyObject, "copyObject");
+var nativeMax = Math.max;
+function overRest(func, start, transform) {
+  start = nativeMax(start === void 0 ? func.length - 1 : start, 0);
+  return function() {
+    var args = arguments, index = -1, length = nativeMax(args.length - start, 0), array = Array(length);
+    while (++index < length) {
+      array[index] = args[start + index];
+    }
+    index = -1;
+    var otherArgs = Array(start + 1);
+    while (++index < start) {
+      otherArgs[index] = args[index];
+    }
+    otherArgs[start] = transform(array);
+    return apply(func, this, otherArgs);
+  };
+}
+__name(overRest, "overRest");
+function baseRest(func, start) {
+  return setToString(overRest(func, start, identity), func + "");
+}
+__name(baseRest, "baseRest");
+var MAX_SAFE_INTEGER = 9007199254740991;
+function isLength(value) {
+  return typeof value == "number" && value > -1 && value % 1 == 0 && value <= MAX_SAFE_INTEGER;
+}
+__name(isLength, "isLength");
+function isArrayLike(value) {
+  return value != null && isLength(value.length) && !isFunction(value);
+}
+__name(isArrayLike, "isArrayLike");
+function isIterateeCall(value, index, object) {
+  if (!isObject(object)) {
+    return false;
+  }
+  var type = typeof index;
+  if (type == "number" ? isArrayLike(object) && isIndex(index, object.length) : type == "string" && index in object) {
+    return eq(object[index], value);
+  }
+  return false;
+}
+__name(isIterateeCall, "isIterateeCall");
+function createAssigner(assigner) {
+  return baseRest(function(object, sources) {
+    var index = -1, length = sources.length, customizer = length > 1 ? sources[length - 1] : void 0, guard = length > 2 ? sources[2] : void 0;
+    customizer = assigner.length > 3 && typeof customizer == "function" ? (length--, customizer) : void 0;
+    if (guard && isIterateeCall(sources[0], sources[1], guard)) {
+      customizer = length < 3 ? void 0 : customizer;
+      length = 1;
+    }
+    object = Object(object);
+    while (++index < length) {
+      var source = sources[index];
+      if (source) {
+        assigner(object, source, index, customizer);
+      }
+    }
+    return object;
+  });
+}
+__name(createAssigner, "createAssigner");
+var objectProto$b = Object.prototype;
+function isPrototype(value) {
+  var Ctor = value && value.constructor, proto = typeof Ctor == "function" && Ctor.prototype || objectProto$b;
+  return value === proto;
+}
+__name(isPrototype, "isPrototype");
+function baseTimes(n, iteratee) {
+  var index = -1, result = Array(n);
+  while (++index < n) {
+    result[index] = iteratee(index);
+  }
+  return result;
+}
+__name(baseTimes, "baseTimes");
+var argsTag$3 = "[object Arguments]";
+function baseIsArguments(value) {
+  return isObjectLike(value) && baseGetTag(value) == argsTag$3;
+}
+__name(baseIsArguments, "baseIsArguments");
+var objectProto$a = Object.prototype;
+var hasOwnProperty$9 = objectProto$a.hasOwnProperty;
+var propertyIsEnumerable$1 = objectProto$a.propertyIsEnumerable;
+var isArguments = baseIsArguments(/* @__PURE__ */ function() {
+  return arguments;
+}()) ? baseIsArguments : function(value) {
+  return isObjectLike(value) && hasOwnProperty$9.call(value, "callee") && !propertyIsEnumerable$1.call(value, "callee");
+};
+function stubFalse() {
+  return false;
+}
+__name(stubFalse, "stubFalse");
+var freeExports$2 = typeof exports == "object" && exports && !exports.nodeType && exports;
+var freeModule$2 = freeExports$2 && typeof module == "object" && module && !module.nodeType && module;
+var moduleExports$2 = freeModule$2 && freeModule$2.exports === freeExports$2;
+var Buffer$1 = moduleExports$2 ? root.Buffer : void 0;
+var nativeIsBuffer = Buffer$1 ? Buffer$1.isBuffer : void 0;
+var isBuffer = nativeIsBuffer || stubFalse;
+var argsTag$2 = "[object Arguments]", arrayTag$2 = "[object Array]", boolTag$3 = "[object Boolean]", dateTag$3 = "[object Date]", errorTag$2 = "[object Error]", funcTag$1 = "[object Function]", mapTag$5 = "[object Map]", numberTag$3 = "[object Number]", objectTag$3 = "[object Object]", regexpTag$3 = "[object RegExp]", setTag$5 = "[object Set]", stringTag$3 = "[object String]", weakMapTag$2 = "[object WeakMap]";
+var arrayBufferTag$3 = "[object ArrayBuffer]", dataViewTag$4 = "[object DataView]", float32Tag$2 = "[object Float32Array]", float64Tag$2 = "[object Float64Array]", int8Tag$2 = "[object Int8Array]", int16Tag$2 = "[object Int16Array]", int32Tag$2 = "[object Int32Array]", uint8Tag$2 = "[object Uint8Array]", uint8ClampedTag$2 = "[object Uint8ClampedArray]", uint16Tag$2 = "[object Uint16Array]", uint32Tag$2 = "[object Uint32Array]";
+var typedArrayTags = {};
+typedArrayTags[float32Tag$2] = typedArrayTags[float64Tag$2] = typedArrayTags[int8Tag$2] = typedArrayTags[int16Tag$2] = typedArrayTags[int32Tag$2] = typedArrayTags[uint8Tag$2] = typedArrayTags[uint8ClampedTag$2] = typedArrayTags[uint16Tag$2] = typedArrayTags[uint32Tag$2] = true;
+typedArrayTags[argsTag$2] = typedArrayTags[arrayTag$2] = typedArrayTags[arrayBufferTag$3] = typedArrayTags[boolTag$3] = typedArrayTags[dataViewTag$4] = typedArrayTags[dateTag$3] = typedArrayTags[errorTag$2] = typedArrayTags[funcTag$1] = typedArrayTags[mapTag$5] = typedArrayTags[numberTag$3] = typedArrayTags[objectTag$3] = typedArrayTags[regexpTag$3] = typedArrayTags[setTag$5] = typedArrayTags[stringTag$3] = typedArrayTags[weakMapTag$2] = false;
+function baseIsTypedArray(value) {
+  return isObjectLike(value) && isLength(value.length) && !!typedArrayTags[baseGetTag(value)];
+}
+__name(baseIsTypedArray, "baseIsTypedArray");
+function baseUnary(func) {
+  return function(value) {
+    return func(value);
+  };
+}
+__name(baseUnary, "baseUnary");
+var freeExports$1 = typeof exports == "object" && exports && !exports.nodeType && exports;
+var freeModule$1 = freeExports$1 && typeof module == "object" && module && !module.nodeType && module;
+var moduleExports$1 = freeModule$1 && freeModule$1.exports === freeExports$1;
+var freeProcess = moduleExports$1 && freeGlobal.process;
+var nodeUtil = function() {
+  try {
+    var types = freeModule$1 && freeModule$1.require && freeModule$1.require("util").types;
+    if (types) {
+      return types;
+    }
+    return freeProcess && freeProcess.binding && freeProcess.binding("util");
+  } catch (e) {
+  }
+}();
+var nodeIsTypedArray = nodeUtil && nodeUtil.isTypedArray;
+var isTypedArray = nodeIsTypedArray ? baseUnary(nodeIsTypedArray) : baseIsTypedArray;
+var objectProto$9 = Object.prototype;
+var hasOwnProperty$8 = objectProto$9.hasOwnProperty;
+function arrayLikeKeys(value, inherited) {
+  var isArr = isArray(value), isArg = !isArr && isArguments(value), isBuff = !isArr && !isArg && isBuffer(value), isType = !isArr && !isArg && !isBuff && isTypedArray(value), skipIndexes = isArr || isArg || isBuff || isType, result = skipIndexes ? baseTimes(value.length, String) : [], length = result.length;
+  for (var key in value) {
+    if ((inherited || hasOwnProperty$8.call(value, key)) && !(skipIndexes && // Safari 9 has enumerable `arguments.length` in strict mode.
+    (key == "length" || // Node.js 0.10 has enumerable non-index properties on buffers.
+    isBuff && (key == "offset" || key == "parent") || // PhantomJS 2 has enumerable non-index properties on typed arrays.
+    isType && (key == "buffer" || key == "byteLength" || key == "byteOffset") || // Skip index properties.
+    isIndex(key, length)))) {
+      result.push(key);
+    }
+  }
+  return result;
+}
+__name(arrayLikeKeys, "arrayLikeKeys");
+function overArg(func, transform) {
+  return function(arg) {
+    return func(transform(arg));
+  };
+}
+__name(overArg, "overArg");
+var nativeKeys = overArg(Object.keys, Object);
+var objectProto$8 = Object.prototype;
+var hasOwnProperty$7 = objectProto$8.hasOwnProperty;
+function baseKeys(object) {
+  if (!isPrototype(object)) {
+    return nativeKeys(object);
+  }
+  var result = [];
+  for (var key in Object(object)) {
+    if (hasOwnProperty$7.call(object, key) && key != "constructor") {
+      result.push(key);
+    }
+  }
+  return result;
+}
+__name(baseKeys, "baseKeys");
+function keys(object) {
+  return isArrayLike(object) ? arrayLikeKeys(object) : baseKeys(object);
+}
+__name(keys, "keys");
+var objectProto$7 = Object.prototype;
+var hasOwnProperty$6 = objectProto$7.hasOwnProperty;
+var assign = createAssigner(function(object, source) {
+  if (isPrototype(source) || isArrayLike(source)) {
+    copyObject(source, keys(source), object);
+    return;
+  }
+  for (var key in source) {
+    if (hasOwnProperty$6.call(source, key)) {
+      assignValue(object, key, source[key]);
+    }
+  }
+});
+function nativeKeysIn(object) {
+  var result = [];
+  if (object != null) {
+    for (var key in Object(object)) {
+      result.push(key);
+    }
+  }
+  return result;
+}
+__name(nativeKeysIn, "nativeKeysIn");
+var objectProto$6 = Object.prototype;
+var hasOwnProperty$5 = objectProto$6.hasOwnProperty;
+function baseKeysIn(object) {
+  if (!isObject(object)) {
+    return nativeKeysIn(object);
+  }
+  var isProto = isPrototype(object), result = [];
+  for (var key in object) {
+    if (!(key == "constructor" && (isProto || !hasOwnProperty$5.call(object, key)))) {
+      result.push(key);
+    }
+  }
+  return result;
+}
+__name(baseKeysIn, "baseKeysIn");
+function keysIn(object) {
+  return isArrayLike(object) ? arrayLikeKeys(object, true) : baseKeysIn(object);
+}
+__name(keysIn, "keysIn");
+var assignIn = createAssigner(function(object, source) {
+  copyObject(source, keysIn(source), object);
+});
+var reIsDeepProp = /\.|\[(?:[^[\]]*|(["'])(?:(?!\1)[^\\]|\\.)*?\1)\]/, reIsPlainProp = /^\w*$/;
+function isKey(value, object) {
+  if (isArray(value)) {
+    return false;
+  }
+  var type = typeof value;
+  if (type == "number" || type == "symbol" || type == "boolean" || value == null || isSymbol(value)) {
+    return true;
+  }
+  return reIsPlainProp.test(value) || !reIsDeepProp.test(value) || object != null && value in Object(object);
+}
+__name(isKey, "isKey");
+var nativeCreate = getNative(Object, "create");
+function hashClear() {
+  this.__data__ = nativeCreate ? nativeCreate(null) : {};
+  this.size = 0;
+}
+__name(hashClear, "hashClear");
+function hashDelete(key) {
+  var result = this.has(key) && delete this.__data__[key];
+  this.size -= result ? 1 : 0;
+  return result;
+}
+__name(hashDelete, "hashDelete");
+var HASH_UNDEFINED$2 = "__lodash_hash_undefined__";
+var objectProto$5 = Object.prototype;
+var hasOwnProperty$4 = objectProto$5.hasOwnProperty;
+function hashGet(key) {
+  var data = this.__data__;
+  if (nativeCreate) {
+    var result = data[key];
+    return result === HASH_UNDEFINED$2 ? void 0 : result;
+  }
+  return hasOwnProperty$4.call(data, key) ? data[key] : void 0;
+}
+__name(hashGet, "hashGet");
+var objectProto$4 = Object.prototype;
+var hasOwnProperty$3 = objectProto$4.hasOwnProperty;
+function hashHas(key) {
+  var data = this.__data__;
+  return nativeCreate ? data[key] !== void 0 : hasOwnProperty$3.call(data, key);
+}
+__name(hashHas, "hashHas");
+var HASH_UNDEFINED$1 = "__lodash_hash_undefined__";
+function hashSet(key, value) {
+  var data = this.__data__;
+  this.size += this.has(key) ? 0 : 1;
+  data[key] = nativeCreate && value === void 0 ? HASH_UNDEFINED$1 : value;
+  return this;
+}
+__name(hashSet, "hashSet");
+function Hash(entries) {
+  var index = -1, length = entries == null ? 0 : entries.length;
+  this.clear();
+  while (++index < length) {
+    var entry = entries[index];
+    this.set(entry[0], entry[1]);
+  }
+}
+__name(Hash, "Hash");
+Hash.prototype.clear = hashClear;
+Hash.prototype["delete"] = hashDelete;
+Hash.prototype.get = hashGet;
+Hash.prototype.has = hashHas;
+Hash.prototype.set = hashSet;
+function listCacheClear() {
+  this.__data__ = [];
+  this.size = 0;
+}
+__name(listCacheClear, "listCacheClear");
+function assocIndexOf(array, key) {
+  var length = array.length;
+  while (length--) {
+    if (eq(array[length][0], key)) {
+      return length;
+    }
+  }
+  return -1;
+}
+__name(assocIndexOf, "assocIndexOf");
+var arrayProto = Array.prototype;
+var splice = arrayProto.splice;
+function listCacheDelete(key) {
+  var data = this.__data__, index = assocIndexOf(data, key);
+  if (index < 0) {
+    return false;
+  }
+  var lastIndex = data.length - 1;
+  if (index == lastIndex) {
+    data.pop();
+  } else {
+    splice.call(data, index, 1);
+  }
+  --this.size;
+  return true;
+}
+__name(listCacheDelete, "listCacheDelete");
+function listCacheGet(key) {
+  var data = this.__data__, index = assocIndexOf(data, key);
+  return index < 0 ? void 0 : data[index][1];
+}
+__name(listCacheGet, "listCacheGet");
+function listCacheHas(key) {
+  return assocIndexOf(this.__data__, key) > -1;
+}
+__name(listCacheHas, "listCacheHas");
+function listCacheSet(key, value) {
+  var data = this.__data__, index = assocIndexOf(data, key);
+  if (index < 0) {
+    ++this.size;
+    data.push([key, value]);
+  } else {
+    data[index][1] = value;
+  }
+  return this;
+}
+__name(listCacheSet, "listCacheSet");
+function ListCache(entries) {
+  var index = -1, length = entries == null ? 0 : entries.length;
+  this.clear();
+  while (++index < length) {
+    var entry = entries[index];
+    this.set(entry[0], entry[1]);
+  }
+}
+__name(ListCache, "ListCache");
+ListCache.prototype.clear = listCacheClear;
+ListCache.prototype["delete"] = listCacheDelete;
+ListCache.prototype.get = listCacheGet;
+ListCache.prototype.has = listCacheHas;
+ListCache.prototype.set = listCacheSet;
+var Map = getNative(root, "Map");
+function mapCacheClear() {
+  this.size = 0;
+  this.__data__ = {
+    "hash": new Hash(),
+    "map": new (Map || ListCache)(),
+    "string": new Hash()
+  };
+}
+__name(mapCacheClear, "mapCacheClear");
+function isKeyable(value) {
+  var type = typeof value;
+  return type == "string" || type == "number" || type == "symbol" || type == "boolean" ? value !== "__proto__" : value === null;
+}
+__name(isKeyable, "isKeyable");
+function getMapData(map2, key) {
+  var data = map2.__data__;
+  return isKeyable(key) ? data[typeof key == "string" ? "string" : "hash"] : data.map;
+}
+__name(getMapData, "getMapData");
+function mapCacheDelete(key) {
+  var result = getMapData(this, key)["delete"](key);
+  this.size -= result ? 1 : 0;
+  return result;
+}
+__name(mapCacheDelete, "mapCacheDelete");
+function mapCacheGet(key) {
+  return getMapData(this, key).get(key);
+}
+__name(mapCacheGet, "mapCacheGet");
+function mapCacheHas(key) {
+  return getMapData(this, key).has(key);
+}
+__name(mapCacheHas, "mapCacheHas");
+function mapCacheSet(key, value) {
+  var data = getMapData(this, key), size = data.size;
+  data.set(key, value);
+  this.size += data.size == size ? 0 : 1;
+  return this;
+}
+__name(mapCacheSet, "mapCacheSet");
+function MapCache(entries) {
+  var index = -1, length = entries == null ? 0 : entries.length;
+  this.clear();
+  while (++index < length) {
+    var entry = entries[index];
+    this.set(entry[0], entry[1]);
+  }
+}
+__name(MapCache, "MapCache");
+MapCache.prototype.clear = mapCacheClear;
+MapCache.prototype["delete"] = mapCacheDelete;
+MapCache.prototype.get = mapCacheGet;
+MapCache.prototype.has = mapCacheHas;
+MapCache.prototype.set = mapCacheSet;
+var FUNC_ERROR_TEXT = "Expected a function";
+function memoize(func, resolver) {
+  if (typeof func != "function" || resolver != null && typeof resolver != "function") {
+    throw new TypeError(FUNC_ERROR_TEXT);
+  }
+  var memoized = /* @__PURE__ */ __name(function() {
+    var args = arguments, key = resolver ? resolver.apply(this, args) : args[0], cache = memoized.cache;
+    if (cache.has(key)) {
+      return cache.get(key);
+    }
+    var result = func.apply(this, args);
+    memoized.cache = cache.set(key, result) || cache;
+    return result;
+  }, "memoized");
+  memoized.cache = new (memoize.Cache || MapCache)();
+  return memoized;
+}
+__name(memoize, "memoize");
+memoize.Cache = MapCache;
+var MAX_MEMOIZE_SIZE = 500;
+function memoizeCapped(func) {
+  var result = memoize(func, function(key) {
+    if (cache.size === MAX_MEMOIZE_SIZE) {
+      cache.clear();
+    }
+    return key;
+  });
+  var cache = result.cache;
+  return result;
+}
+__name(memoizeCapped, "memoizeCapped");
+var rePropName = /[^.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|(["'])((?:(?!\2)[^\\]|\\.)*?)\2)\]|(?=(?:\.|\[\])(?:\.|\[\]|$))/g;
+var reEscapeChar = /\\(\\)?/g;
+var stringToPath = memoizeCapped(function(string) {
+  var result = [];
+  if (string.charCodeAt(0) === 46) {
+    result.push("");
+  }
+  string.replace(rePropName, function(match, number, quote, subString) {
+    result.push(quote ? subString.replace(reEscapeChar, "$1") : number || match);
+  });
+  return result;
+});
+function toString(value) {
+  return value == null ? "" : baseToString(value);
+}
+__name(toString, "toString");
+function castPath(value, object) {
+  if (isArray(value)) {
+    return value;
+  }
+  return isKey(value, object) ? [value] : stringToPath(toString(value));
+}
+__name(castPath, "castPath");
+var INFINITY = 1 / 0;
+function toKey(value) {
+  if (typeof value == "string" || isSymbol(value)) {
+    return value;
+  }
+  var result = value + "";
+  return result == "0" && 1 / value == -INFINITY ? "-0" : result;
+}
+__name(toKey, "toKey");
+function baseGet(object, path) {
+  path = castPath(path, object);
+  var index = 0, length = path.length;
+  while (object != null && index < length) {
+    object = object[toKey(path[index++])];
+  }
+  return index && index == length ? object : void 0;
+}
+__name(baseGet, "baseGet");
+function get(object, path, defaultValue) {
+  var result = object == null ? void 0 : baseGet(object, path);
+  return result === void 0 ? defaultValue : result;
+}
+__name(get, "get");
+function arrayPush(array, values) {
+  var index = -1, length = values.length, offset = array.length;
+  while (++index < length) {
+    array[offset + index] = values[index];
+  }
+  return array;
+}
+__name(arrayPush, "arrayPush");
+var spreadableSymbol = Symbol$1 ? Symbol$1.isConcatSpreadable : void 0;
+function isFlattenable(value) {
+  return isArray(value) || isArguments(value) || !!(spreadableSymbol && value && value[spreadableSymbol]);
+}
+__name(isFlattenable, "isFlattenable");
+function baseFlatten(array, depth, predicate, isStrict, result) {
+  var index = -1, length = array.length;
+  predicate || (predicate = isFlattenable);
+  result || (result = []);
+  while (++index < length) {
+    var value = array[index];
+    if (predicate(value)) {
+      {
+        arrayPush(result, value);
+      }
+    } else {
+      result[result.length] = value;
+    }
+  }
+  return result;
+}
+__name(baseFlatten, "baseFlatten");
+var getPrototype = overArg(Object.getPrototypeOf, Object);
+function stackClear() {
+  this.__data__ = new ListCache();
+  this.size = 0;
+}
+__name(stackClear, "stackClear");
+function stackDelete(key) {
+  var data = this.__data__, result = data["delete"](key);
+  this.size = data.size;
+  return result;
+}
+__name(stackDelete, "stackDelete");
+function stackGet(key) {
+  return this.__data__.get(key);
+}
+__name(stackGet, "stackGet");
+function stackHas(key) {
+  return this.__data__.has(key);
+}
+__name(stackHas, "stackHas");
+var LARGE_ARRAY_SIZE = 200;
+function stackSet(key, value) {
+  var data = this.__data__;
+  if (data instanceof ListCache) {
+    var pairs = data.__data__;
+    if (!Map || pairs.length < LARGE_ARRAY_SIZE - 1) {
+      pairs.push([key, value]);
+      this.size = ++data.size;
+      return this;
+    }
+    data = this.__data__ = new MapCache(pairs);
+  }
+  data.set(key, value);
+  this.size = data.size;
+  return this;
+}
+__name(stackSet, "stackSet");
+function Stack(entries) {
+  var data = this.__data__ = new ListCache(entries);
+  this.size = data.size;
+}
+__name(Stack, "Stack");
+Stack.prototype.clear = stackClear;
+Stack.prototype["delete"] = stackDelete;
+Stack.prototype.get = stackGet;
+Stack.prototype.has = stackHas;
+Stack.prototype.set = stackSet;
+function baseAssign(object, source) {
+  return object && copyObject(source, keys(source), object);
+}
+__name(baseAssign, "baseAssign");
+var freeExports = typeof exports == "object" && exports && !exports.nodeType && exports;
+var freeModule = freeExports && typeof module == "object" && module && !module.nodeType && module;
+var moduleExports = freeModule && freeModule.exports === freeExports;
+var Buffer2 = moduleExports ? root.Buffer : void 0, allocUnsafe = Buffer2 ? Buffer2.allocUnsafe : void 0;
+function cloneBuffer(buffer, isDeep) {
+  var length = buffer.length, result = allocUnsafe ? allocUnsafe(length) : new buffer.constructor(length);
+  buffer.copy(result);
+  return result;
+}
+__name(cloneBuffer, "cloneBuffer");
+function arrayFilter(array, predicate) {
+  var index = -1, length = array == null ? 0 : array.length, resIndex = 0, result = [];
+  while (++index < length) {
+    var value = array[index];
+    if (predicate(value, index, array)) {
+      result[resIndex++] = value;
+    }
+  }
+  return result;
+}
+__name(arrayFilter, "arrayFilter");
+function stubArray() {
+  return [];
+}
+__name(stubArray, "stubArray");
+var objectProto$3 = Object.prototype;
+var propertyIsEnumerable = objectProto$3.propertyIsEnumerable;
+var nativeGetSymbols = Object.getOwnPropertySymbols;
+var getSymbols = !nativeGetSymbols ? stubArray : function(object) {
+  if (object == null) {
+    return [];
+  }
+  object = Object(object);
+  return arrayFilter(nativeGetSymbols(object), function(symbol) {
+    return propertyIsEnumerable.call(object, symbol);
+  });
+};
+function copySymbols(source, object) {
+  return copyObject(source, getSymbols(source), object);
+}
+__name(copySymbols, "copySymbols");
+function baseGetAllKeys(object, keysFunc, symbolsFunc) {
+  var result = keysFunc(object);
+  return isArray(object) ? result : arrayPush(result, symbolsFunc(object));
+}
+__name(baseGetAllKeys, "baseGetAllKeys");
+function getAllKeys(object) {
+  return baseGetAllKeys(object, keys, getSymbols);
+}
+__name(getAllKeys, "getAllKeys");
+var DataView = getNative(root, "DataView");
+var Promise$1 = getNative(root, "Promise");
+var Set = getNative(root, "Set");
+var mapTag$4 = "[object Map]", objectTag$2 = "[object Object]", promiseTag = "[object Promise]", setTag$4 = "[object Set]", weakMapTag$1 = "[object WeakMap]";
+var dataViewTag$3 = "[object DataView]";
+var dataViewCtorString = toSource(DataView), mapCtorString = toSource(Map), promiseCtorString = toSource(Promise$1), setCtorString = toSource(Set), weakMapCtorString = toSource(WeakMap);
+var getTag = baseGetTag;
+if (DataView && getTag(new DataView(new ArrayBuffer(1))) != dataViewTag$3 || Map && getTag(new Map()) != mapTag$4 || Promise$1 && getTag(Promise$1.resolve()) != promiseTag || Set && getTag(new Set()) != setTag$4 || WeakMap && getTag(new WeakMap()) != weakMapTag$1) {
+  getTag = /* @__PURE__ */ __name(function(value) {
+    var result = baseGetTag(value), Ctor = result == objectTag$2 ? value.constructor : void 0, ctorString = Ctor ? toSource(Ctor) : "";
+    if (ctorString) {
+      switch (ctorString) {
+        case dataViewCtorString:
+          return dataViewTag$3;
+        case mapCtorString:
+          return mapTag$4;
+        case promiseCtorString:
+          return promiseTag;
+        case setCtorString:
+          return setTag$4;
+        case weakMapCtorString:
+          return weakMapTag$1;
+      }
+    }
+    return result;
+  }, "getTag");
+}
+var objectProto$2 = Object.prototype;
+var hasOwnProperty$2 = objectProto$2.hasOwnProperty;
+function initCloneArray(array) {
+  var length = array.length, result = new array.constructor(length);
+  if (length && typeof array[0] == "string" && hasOwnProperty$2.call(array, "index")) {
+    result.index = array.index;
+    result.input = array.input;
+  }
+  return result;
+}
+__name(initCloneArray, "initCloneArray");
+var Uint8Array2 = root.Uint8Array;
+function cloneArrayBuffer(arrayBuffer) {
+  var result = new arrayBuffer.constructor(arrayBuffer.byteLength);
+  new Uint8Array2(result).set(new Uint8Array2(arrayBuffer));
+  return result;
+}
+__name(cloneArrayBuffer, "cloneArrayBuffer");
+function cloneDataView(dataView, isDeep) {
+  var buffer = dataView.buffer;
+  return new dataView.constructor(buffer, dataView.byteOffset, dataView.byteLength);
+}
+__name(cloneDataView, "cloneDataView");
+var reFlags = /\w*$/;
+function cloneRegExp(regexp) {
+  var result = new regexp.constructor(regexp.source, reFlags.exec(regexp));
+  result.lastIndex = regexp.lastIndex;
+  return result;
+}
+__name(cloneRegExp, "cloneRegExp");
+var symbolProto$1 = Symbol$1 ? Symbol$1.prototype : void 0, symbolValueOf$1 = symbolProto$1 ? symbolProto$1.valueOf : void 0;
+function cloneSymbol(symbol) {
+  return symbolValueOf$1 ? Object(symbolValueOf$1.call(symbol)) : {};
+}
+__name(cloneSymbol, "cloneSymbol");
+function cloneTypedArray(typedArray, isDeep) {
+  var buffer = typedArray.buffer;
+  return new typedArray.constructor(buffer, typedArray.byteOffset, typedArray.length);
+}
+__name(cloneTypedArray, "cloneTypedArray");
+var boolTag$2 = "[object Boolean]", dateTag$2 = "[object Date]", mapTag$3 = "[object Map]", numberTag$2 = "[object Number]", regexpTag$2 = "[object RegExp]", setTag$3 = "[object Set]", stringTag$2 = "[object String]", symbolTag$2 = "[object Symbol]";
+var arrayBufferTag$2 = "[object ArrayBuffer]", dataViewTag$2 = "[object DataView]", float32Tag$1 = "[object Float32Array]", float64Tag$1 = "[object Float64Array]", int8Tag$1 = "[object Int8Array]", int16Tag$1 = "[object Int16Array]", int32Tag$1 = "[object Int32Array]", uint8Tag$1 = "[object Uint8Array]", uint8ClampedTag$1 = "[object Uint8ClampedArray]", uint16Tag$1 = "[object Uint16Array]", uint32Tag$1 = "[object Uint32Array]";
+function initCloneByTag(object, tag, isDeep) {
+  var Ctor = object.constructor;
+  switch (tag) {
+    case arrayBufferTag$2:
+      return cloneArrayBuffer(object);
+    case boolTag$2:
+    case dateTag$2:
+      return new Ctor(+object);
+    case dataViewTag$2:
+      return cloneDataView(object);
+    case float32Tag$1:
+    case float64Tag$1:
+    case int8Tag$1:
+    case int16Tag$1:
+    case int32Tag$1:
+    case uint8Tag$1:
+    case uint8ClampedTag$1:
+    case uint16Tag$1:
+    case uint32Tag$1:
+      return cloneTypedArray(object);
+    case mapTag$3:
+      return new Ctor();
+    case numberTag$2:
+    case stringTag$2:
+      return new Ctor(object);
+    case regexpTag$2:
+      return cloneRegExp(object);
+    case setTag$3:
+      return new Ctor();
+    case symbolTag$2:
+      return cloneSymbol(object);
+  }
+}
+__name(initCloneByTag, "initCloneByTag");
+function initCloneObject(object) {
+  return typeof object.constructor == "function" && !isPrototype(object) ? baseCreate(getPrototype(object)) : {};
+}
+__name(initCloneObject, "initCloneObject");
+var mapTag$2 = "[object Map]";
+function baseIsMap(value) {
+  return isObjectLike(value) && getTag(value) == mapTag$2;
+}
+__name(baseIsMap, "baseIsMap");
+var nodeIsMap = nodeUtil && nodeUtil.isMap;
+var isMap = nodeIsMap ? baseUnary(nodeIsMap) : baseIsMap;
+var setTag$2 = "[object Set]";
+function baseIsSet(value) {
+  return isObjectLike(value) && getTag(value) == setTag$2;
+}
+__name(baseIsSet, "baseIsSet");
+var nodeIsSet = nodeUtil && nodeUtil.isSet;
+var isSet = nodeIsSet ? baseUnary(nodeIsSet) : baseIsSet;
+var argsTag$1 = "[object Arguments]", arrayTag$1 = "[object Array]", boolTag$1 = "[object Boolean]", dateTag$1 = "[object Date]", errorTag$1 = "[object Error]", funcTag = "[object Function]", genTag = "[object GeneratorFunction]", mapTag$1 = "[object Map]", numberTag$1 = "[object Number]", objectTag$1 = "[object Object]", regexpTag$1 = "[object RegExp]", setTag$1 = "[object Set]", stringTag$1 = "[object String]", symbolTag$1 = "[object Symbol]", weakMapTag = "[object WeakMap]";
+var arrayBufferTag$1 = "[object ArrayBuffer]", dataViewTag$1 = "[object DataView]", float32Tag = "[object Float32Array]", float64Tag = "[object Float64Array]", int8Tag = "[object Int8Array]", int16Tag = "[object Int16Array]", int32Tag = "[object Int32Array]", uint8Tag = "[object Uint8Array]", uint8ClampedTag = "[object Uint8ClampedArray]", uint16Tag = "[object Uint16Array]", uint32Tag = "[object Uint32Array]";
+var cloneableTags = {};
+cloneableTags[argsTag$1] = cloneableTags[arrayTag$1] = cloneableTags[arrayBufferTag$1] = cloneableTags[dataViewTag$1] = cloneableTags[boolTag$1] = cloneableTags[dateTag$1] = cloneableTags[float32Tag] = cloneableTags[float64Tag] = cloneableTags[int8Tag] = cloneableTags[int16Tag] = cloneableTags[int32Tag] = cloneableTags[mapTag$1] = cloneableTags[numberTag$1] = cloneableTags[objectTag$1] = cloneableTags[regexpTag$1] = cloneableTags[setTag$1] = cloneableTags[stringTag$1] = cloneableTags[symbolTag$1] = cloneableTags[uint8Tag] = cloneableTags[uint8ClampedTag] = cloneableTags[uint16Tag] = cloneableTags[uint32Tag] = true;
+cloneableTags[errorTag$1] = cloneableTags[funcTag] = cloneableTags[weakMapTag] = false;
+function baseClone(value, bitmask, customizer, key, object, stack) {
+  var result;
+  if (result !== void 0) {
+    return result;
+  }
+  if (!isObject(value)) {
+    return value;
+  }
+  var isArr = isArray(value);
+  if (isArr) {
+    result = initCloneArray(value);
+    {
+      return copyArray(value, result);
+    }
+  } else {
+    var tag = getTag(value), isFunc = tag == funcTag || tag == genTag;
+    if (isBuffer(value)) {
+      return cloneBuffer(value);
+    }
+    if (tag == objectTag$1 || tag == argsTag$1 || isFunc && !object) {
+      result = isFunc ? {} : initCloneObject(value);
+      {
+        return copySymbols(value, baseAssign(result, value));
+      }
+    } else {
+      if (!cloneableTags[tag]) {
+        return object ? value : {};
+      }
+      result = initCloneByTag(value, tag);
+    }
+  }
+  stack || (stack = new Stack());
+  var stacked = stack.get(value);
+  if (stacked) {
+    return stacked;
+  }
+  stack.set(value, result);
+  if (isSet(value)) {
+    value.forEach(function(subValue) {
+      result.add(baseClone(subValue, bitmask, customizer, subValue, value, stack));
+    });
+  } else if (isMap(value)) {
+    value.forEach(function(subValue, key2) {
+      result.set(key2, baseClone(subValue, bitmask, customizer, key2, value, stack));
+    });
+  }
+  var keysFunc = getAllKeys;
+  var props = isArr ? void 0 : keysFunc(value);
+  arrayEach(props || value, function(subValue, key2) {
+    if (props) {
+      key2 = subValue;
+      subValue = value[key2];
+    }
+    assignValue(result, key2, baseClone(subValue, bitmask, customizer, key2, value, stack));
+  });
+  return result;
+}
+__name(baseClone, "baseClone");
+var CLONE_SYMBOLS_FLAG = 4;
+function clone(value) {
+  return baseClone(value, CLONE_SYMBOLS_FLAG);
+}
+__name(clone, "clone");
+var HASH_UNDEFINED = "__lodash_hash_undefined__";
+function setCacheAdd(value) {
+  this.__data__.set(value, HASH_UNDEFINED);
+  return this;
+}
+__name(setCacheAdd, "setCacheAdd");
+function setCacheHas(value) {
+  return this.__data__.has(value);
+}
+__name(setCacheHas, "setCacheHas");
+function SetCache(values) {
+  var index = -1, length = values == null ? 0 : values.length;
+  this.__data__ = new MapCache();
+  while (++index < length) {
+    this.add(values[index]);
+  }
+}
+__name(SetCache, "SetCache");
+SetCache.prototype.add = SetCache.prototype.push = setCacheAdd;
+SetCache.prototype.has = setCacheHas;
+function arraySome(array, predicate) {
+  var index = -1, length = array == null ? 0 : array.length;
+  while (++index < length) {
+    if (predicate(array[index], index, array)) {
+      return true;
+    }
+  }
+  return false;
+}
+__name(arraySome, "arraySome");
+function cacheHas(cache, key) {
+  return cache.has(key);
+}
+__name(cacheHas, "cacheHas");
+var COMPARE_PARTIAL_FLAG$5 = 1, COMPARE_UNORDERED_FLAG$3 = 2;
+function equalArrays(array, other, bitmask, customizer, equalFunc, stack) {
+  var isPartial = bitmask & COMPARE_PARTIAL_FLAG$5, arrLength = array.length, othLength = other.length;
+  if (arrLength != othLength && !(isPartial && othLength > arrLength)) {
+    return false;
+  }
+  var arrStacked = stack.get(array);
+  var othStacked = stack.get(other);
+  if (arrStacked && othStacked) {
+    return arrStacked == other && othStacked == array;
+  }
+  var index = -1, result = true, seen = bitmask & COMPARE_UNORDERED_FLAG$3 ? new SetCache() : void 0;
+  stack.set(array, other);
+  stack.set(other, array);
+  while (++index < arrLength) {
+    var arrValue = array[index], othValue = other[index];
+    if (customizer) {
+      var compared = isPartial ? customizer(othValue, arrValue, index, other, array, stack) : customizer(arrValue, othValue, index, array, other, stack);
+    }
+    if (compared !== void 0) {
+      if (compared) {
+        continue;
+      }
+      result = false;
+      break;
+    }
+    if (seen) {
+      if (!arraySome(other, function(othValue2, othIndex) {
+        if (!cacheHas(seen, othIndex) && (arrValue === othValue2 || equalFunc(arrValue, othValue2, bitmask, customizer, stack))) {
+          return seen.push(othIndex);
+        }
+      })) {
+        result = false;
+        break;
+      }
+    } else if (!(arrValue === othValue || equalFunc(arrValue, othValue, bitmask, customizer, stack))) {
+      result = false;
+      break;
+    }
+  }
+  stack["delete"](array);
+  stack["delete"](other);
+  return result;
+}
+__name(equalArrays, "equalArrays");
+function mapToArray(map2) {
+  var index = -1, result = Array(map2.size);
+  map2.forEach(function(value, key) {
+    result[++index] = [key, value];
+  });
+  return result;
+}
+__name(mapToArray, "mapToArray");
+function setToArray(set) {
+  var index = -1, result = Array(set.size);
+  set.forEach(function(value) {
+    result[++index] = value;
+  });
+  return result;
+}
+__name(setToArray, "setToArray");
+var COMPARE_PARTIAL_FLAG$4 = 1, COMPARE_UNORDERED_FLAG$2 = 2;
+var boolTag = "[object Boolean]", dateTag = "[object Date]", errorTag = "[object Error]", mapTag = "[object Map]", numberTag = "[object Number]", regexpTag = "[object RegExp]", setTag = "[object Set]", stringTag = "[object String]", symbolTag = "[object Symbol]";
+var arrayBufferTag = "[object ArrayBuffer]", dataViewTag = "[object DataView]";
+var symbolProto = Symbol$1 ? Symbol$1.prototype : void 0, symbolValueOf = symbolProto ? symbolProto.valueOf : void 0;
+function equalByTag(object, other, tag, bitmask, customizer, equalFunc, stack) {
+  switch (tag) {
+    case dataViewTag:
+      if (object.byteLength != other.byteLength || object.byteOffset != other.byteOffset) {
+        return false;
+      }
+      object = object.buffer;
+      other = other.buffer;
+    case arrayBufferTag:
+      if (object.byteLength != other.byteLength || !equalFunc(new Uint8Array2(object), new Uint8Array2(other))) {
+        return false;
+      }
+      return true;
+    case boolTag:
+    case dateTag:
+    case numberTag:
+      return eq(+object, +other);
+    case errorTag:
+      return object.name == other.name && object.message == other.message;
+    case regexpTag:
+    case stringTag:
+      return object == other + "";
+    case mapTag:
+      var convert = mapToArray;
+    case setTag:
+      var isPartial = bitmask & COMPARE_PARTIAL_FLAG$4;
+      convert || (convert = setToArray);
+      if (object.size != other.size && !isPartial) {
+        return false;
+      }
+      var stacked = stack.get(object);
+      if (stacked) {
+        return stacked == other;
+      }
+      bitmask |= COMPARE_UNORDERED_FLAG$2;
+      stack.set(object, other);
+      var result = equalArrays(convert(object), convert(other), bitmask, customizer, equalFunc, stack);
+      stack["delete"](object);
+      return result;
+    case symbolTag:
+      if (symbolValueOf) {
+        return symbolValueOf.call(object) == symbolValueOf.call(other);
+      }
+  }
+  return false;
+}
+__name(equalByTag, "equalByTag");
+var COMPARE_PARTIAL_FLAG$3 = 1;
+var objectProto$1 = Object.prototype;
+var hasOwnProperty$1 = objectProto$1.hasOwnProperty;
+function equalObjects(object, other, bitmask, customizer, equalFunc, stack) {
+  var isPartial = bitmask & COMPARE_PARTIAL_FLAG$3, objProps = getAllKeys(object), objLength = objProps.length, othProps = getAllKeys(other), othLength = othProps.length;
+  if (objLength != othLength && !isPartial) {
+    return false;
+  }
+  var index = objLength;
+  while (index--) {
+    var key = objProps[index];
+    if (!(isPartial ? key in other : hasOwnProperty$1.call(other, key))) {
+      return false;
+    }
+  }
+  var objStacked = stack.get(object);
+  var othStacked = stack.get(other);
+  if (objStacked && othStacked) {
+    return objStacked == other && othStacked == object;
+  }
+  var result = true;
+  stack.set(object, other);
+  stack.set(other, object);
+  var skipCtor = isPartial;
+  while (++index < objLength) {
+    key = objProps[index];
+    var objValue = object[key], othValue = other[key];
+    if (customizer) {
+      var compared = isPartial ? customizer(othValue, objValue, key, other, object, stack) : customizer(objValue, othValue, key, object, other, stack);
+    }
+    if (!(compared === void 0 ? objValue === othValue || equalFunc(objValue, othValue, bitmask, customizer, stack) : compared)) {
+      result = false;
+      break;
+    }
+    skipCtor || (skipCtor = key == "constructor");
+  }
+  if (result && !skipCtor) {
+    var objCtor = object.constructor, othCtor = other.constructor;
+    if (objCtor != othCtor && ("constructor" in object && "constructor" in other) && !(typeof objCtor == "function" && objCtor instanceof objCtor && typeof othCtor == "function" && othCtor instanceof othCtor)) {
+      result = false;
+    }
+  }
+  stack["delete"](object);
+  stack["delete"](other);
+  return result;
+}
+__name(equalObjects, "equalObjects");
+var COMPARE_PARTIAL_FLAG$2 = 1;
+var argsTag = "[object Arguments]", arrayTag = "[object Array]", objectTag = "[object Object]";
+var objectProto = Object.prototype;
+var hasOwnProperty = objectProto.hasOwnProperty;
+function baseIsEqualDeep(object, other, bitmask, customizer, equalFunc, stack) {
+  var objIsArr = isArray(object), othIsArr = isArray(other), objTag = objIsArr ? arrayTag : getTag(object), othTag = othIsArr ? arrayTag : getTag(other);
+  objTag = objTag == argsTag ? objectTag : objTag;
+  othTag = othTag == argsTag ? objectTag : othTag;
+  var objIsObj = objTag == objectTag, othIsObj = othTag == objectTag, isSameTag = objTag == othTag;
+  if (isSameTag && isBuffer(object)) {
+    if (!isBuffer(other)) {
+      return false;
+    }
+    objIsArr = true;
+    objIsObj = false;
+  }
+  if (isSameTag && !objIsObj) {
+    stack || (stack = new Stack());
+    return objIsArr || isTypedArray(object) ? equalArrays(object, other, bitmask, customizer, equalFunc, stack) : equalByTag(object, other, objTag, bitmask, customizer, equalFunc, stack);
+  }
+  if (!(bitmask & COMPARE_PARTIAL_FLAG$2)) {
+    var objIsWrapped = objIsObj && hasOwnProperty.call(object, "__wrapped__"), othIsWrapped = othIsObj && hasOwnProperty.call(other, "__wrapped__");
+    if (objIsWrapped || othIsWrapped) {
+      var objUnwrapped = objIsWrapped ? object.value() : object, othUnwrapped = othIsWrapped ? other.value() : other;
+      stack || (stack = new Stack());
+      return equalFunc(objUnwrapped, othUnwrapped, bitmask, customizer, stack);
+    }
+  }
+  if (!isSameTag) {
+    return false;
+  }
+  stack || (stack = new Stack());
+  return equalObjects(object, other, bitmask, customizer, equalFunc, stack);
+}
+__name(baseIsEqualDeep, "baseIsEqualDeep");
+function baseIsEqual(value, other, bitmask, customizer, stack) {
+  if (value === other) {
+    return true;
+  }
+  if (value == null || other == null || !isObjectLike(value) && !isObjectLike(other)) {
+    return value !== value && other !== other;
+  }
+  return baseIsEqualDeep(value, other, bitmask, customizer, baseIsEqual, stack);
+}
+__name(baseIsEqual, "baseIsEqual");
+var COMPARE_PARTIAL_FLAG$1 = 1, COMPARE_UNORDERED_FLAG$1 = 2;
+function baseIsMatch(object, source, matchData, customizer) {
+  var index = matchData.length, length = index;
+  if (object == null) {
+    return !length;
+  }
+  object = Object(object);
+  while (index--) {
+    var data = matchData[index];
+    if (data[2] ? data[1] !== object[data[0]] : !(data[0] in object)) {
+      return false;
+    }
+  }
+  while (++index < length) {
+    data = matchData[index];
+    var key = data[0], objValue = object[key], srcValue = data[1];
+    if (data[2]) {
+      if (objValue === void 0 && !(key in object)) {
+        return false;
+      }
+    } else {
+      var stack = new Stack();
+      var result;
+      if (!(result === void 0 ? baseIsEqual(srcValue, objValue, COMPARE_PARTIAL_FLAG$1 | COMPARE_UNORDERED_FLAG$1, customizer, stack) : result)) {
+        return false;
+      }
+    }
+  }
+  return true;
+}
+__name(baseIsMatch, "baseIsMatch");
+function isStrictComparable(value) {
+  return value === value && !isObject(value);
+}
+__name(isStrictComparable, "isStrictComparable");
+function getMatchData(object) {
+  var result = keys(object), length = result.length;
+  while (length--) {
+    var key = result[length], value = object[key];
+    result[length] = [key, value, isStrictComparable(value)];
+  }
+  return result;
+}
+__name(getMatchData, "getMatchData");
+function matchesStrictComparable(key, srcValue) {
+  return function(object) {
+    if (object == null) {
+      return false;
+    }
+    return object[key] === srcValue && (srcValue !== void 0 || key in Object(object));
+  };
+}
+__name(matchesStrictComparable, "matchesStrictComparable");
+function baseMatches(source) {
+  var matchData = getMatchData(source);
+  if (matchData.length == 1 && matchData[0][2]) {
+    return matchesStrictComparable(matchData[0][0], matchData[0][1]);
+  }
+  return function(object) {
+    return object === source || baseIsMatch(object, source, matchData);
+  };
+}
+__name(baseMatches, "baseMatches");
+function baseHasIn(object, key) {
+  return object != null && key in Object(object);
+}
+__name(baseHasIn, "baseHasIn");
+function hasPath(object, path, hasFunc) {
+  path = castPath(path, object);
+  var index = -1, length = path.length, result = false;
+  while (++index < length) {
+    var key = toKey(path[index]);
+    if (!(result = object != null && hasFunc(object, key))) {
+      break;
+    }
+    object = object[key];
+  }
+  if (result || ++index != length) {
+    return result;
+  }
+  length = object == null ? 0 : object.length;
+  return !!length && isLength(length) && isIndex(key, length) && (isArray(object) || isArguments(object));
+}
+__name(hasPath, "hasPath");
+function hasIn(object, path) {
+  return object != null && hasPath(object, path, baseHasIn);
+}
+__name(hasIn, "hasIn");
+var COMPARE_PARTIAL_FLAG = 1, COMPARE_UNORDERED_FLAG = 2;
+function baseMatchesProperty(path, srcValue) {
+  if (isKey(path) && isStrictComparable(srcValue)) {
+    return matchesStrictComparable(toKey(path), srcValue);
+  }
+  return function(object) {
+    var objValue = get(object, path);
+    return objValue === void 0 && objValue === srcValue ? hasIn(object, path) : baseIsEqual(srcValue, objValue, COMPARE_PARTIAL_FLAG | COMPARE_UNORDERED_FLAG);
+  };
+}
+__name(baseMatchesProperty, "baseMatchesProperty");
+function baseProperty(key) {
+  return function(object) {
+    return object == null ? void 0 : object[key];
+  };
+}
+__name(baseProperty, "baseProperty");
+function basePropertyDeep(path) {
+  return function(object) {
+    return baseGet(object, path);
+  };
+}
+__name(basePropertyDeep, "basePropertyDeep");
+function property(path) {
+  return isKey(path) ? baseProperty(toKey(path)) : basePropertyDeep(path);
+}
+__name(property, "property");
+function baseIteratee(value) {
+  if (typeof value == "function") {
+    return value;
+  }
+  if (value == null) {
+    return identity;
+  }
+  if (typeof value == "object") {
+    return isArray(value) ? baseMatchesProperty(value[0], value[1]) : baseMatches(value);
+  }
+  return property(value);
+}
+__name(baseIteratee, "baseIteratee");
+function createBaseFor(fromRight) {
+  return function(object, iteratee, keysFunc) {
+    var index = -1, iterable = Object(object), props = keysFunc(object), length = props.length;
+    while (length--) {
+      var key = props[++index];
+      if (iteratee(iterable[key], key, iterable) === false) {
+        break;
+      }
+    }
+    return object;
+  };
+}
+__name(createBaseFor, "createBaseFor");
+var baseFor = createBaseFor();
+function baseForOwn(object, iteratee) {
+  return object && baseFor(object, iteratee, keys);
+}
+__name(baseForOwn, "baseForOwn");
+function createBaseEach(eachFunc, fromRight) {
+  return function(collection, iteratee) {
+    if (collection == null) {
+      return collection;
+    }
+    if (!isArrayLike(collection)) {
+      return eachFunc(collection, iteratee);
+    }
+    var length = collection.length, index = -1, iterable = Object(collection);
+    while (++index < length) {
+      if (iteratee(iterable[index], index, iterable) === false) {
+        break;
+      }
+    }
+    return collection;
+  };
+}
+__name(createBaseEach, "createBaseEach");
+var baseEach = createBaseEach(baseForOwn);
+function baseMap(collection, iteratee) {
+  var index = -1, result = isArrayLike(collection) ? Array(collection.length) : [];
+  baseEach(collection, function(value, key, collection2) {
+    result[++index] = iteratee(value, key, collection2);
+  });
+  return result;
+}
+__name(baseMap, "baseMap");
+function map(collection, iteratee) {
+  var func = isArray(collection) ? arrayMap : baseMap;
+  return func(collection, baseIteratee(iteratee));
+}
+__name(map, "map");
+function flatMap(collection, iteratee) {
+  return baseFlatten(map(collection, iteratee));
+}
+__name(flatMap, "flatMap");
+function getOverlapOfNonCircularRanges(rangeA, rangeB) {
+  if (rangeA.start < rangeB.start) {
+    if (rangeA.end < rangeB.start)
+      ;
+    else {
+      if (rangeA.end < rangeB.end) {
+        return {
+          start: rangeB.start,
+          end: rangeA.end
+        };
+      } else {
+        return {
+          start: rangeB.start,
+          end: rangeB.end
+        };
+      }
+    }
+  } else {
+    if (rangeA.start > rangeB.end)
+      ;
+    else {
+      if (rangeA.end < rangeB.end) {
+        return {
+          start: rangeA.start,
+          end: rangeA.end
+        };
+      } else {
+        return {
+          start: rangeA.start,
+          end: rangeB.end
+        };
+      }
+    }
+  }
+}
+__name(getOverlapOfNonCircularRanges, "getOverlapOfNonCircularRanges");
+function getOverlapsOfPotentiallyCircularRanges(rangeA, rangeB, maxRangeLength, joinIfPossible) {
+  const normalizedRangeA = splitRangeIntoTwoPartsIfItIsCircular(
+    rangeA,
+    maxRangeLength
+  );
+  const normalizedRangeB = splitRangeIntoTwoPartsIfItIsCircular(
+    rangeB,
+    maxRangeLength
+  );
+  let overlaps = [];
+  normalizedRangeA.forEach(function(nonCircularRangeA) {
+    normalizedRangeB.forEach(function(nonCircularRangeB) {
+      const overlap = getOverlapOfNonCircularRanges(
+        nonCircularRangeA,
+        nonCircularRangeB
+      );
+      if (overlap) {
+        overlaps.push(overlap);
+      }
+    });
+  });
+  if (joinIfPossible && normalizedRangeA.length === 2 && normalizedRangeB.length === 2 && maxRangeLength) {
+    const joinedOverlap = {};
+    overlaps = flatMap(overlaps, (o) => {
+      if (o.start === 0) {
+        joinedOverlap.end = o.end;
+        return [];
+      } else if (o.end === maxRangeLength - 1) {
+        joinedOverlap.start = o.start;
+        return [];
+      }
+    });
+    overlaps.push(joinedOverlap);
+  }
+  return overlaps;
+}
+__name(getOverlapsOfPotentiallyCircularRanges, "getOverlapsOfPotentiallyCircularRanges");
+function trimNonCicularRangeByAnotherNonCircularRange(rangeToBeTrimmed, trimmingRange) {
+  let outputTrimmedRange;
+  if (!rangeToBeTrimmed) {
+    return outputTrimmedRange;
+  }
+  if (rangeToBeTrimmed.start < trimmingRange.start) {
+    if (rangeToBeTrimmed.end < trimmingRange.start) {
+      outputTrimmedRange = {
+        start: rangeToBeTrimmed.start,
+        end: rangeToBeTrimmed.end
+      };
+    } else {
+      if (rangeToBeTrimmed.end > trimmingRange.end) {
+        outputTrimmedRange = {
+          start: rangeToBeTrimmed.start,
+          end: rangeToBeTrimmed.end
+        };
+      } else {
+        outputTrimmedRange = {
+          start: rangeToBeTrimmed.start,
+          end: trimmingRange.start - 1
+        };
+      }
+    }
+  } else {
+    if (rangeToBeTrimmed.end <= trimmingRange.end)
+      ;
+    else {
+      if (rangeToBeTrimmed.start > trimmingRange.end) {
+        outputTrimmedRange = {
+          end: rangeToBeTrimmed.end,
+          start: rangeToBeTrimmed.start
+        };
+      } else {
+        outputTrimmedRange = {
+          end: rangeToBeTrimmed.end,
+          start: trimmingRange.end + 1
+        };
+      }
+    }
+  }
+  return outputTrimmedRange;
+}
+__name(trimNonCicularRangeByAnotherNonCircularRange, "trimNonCicularRangeByAnotherNonCircularRange");
+function trimRangeByAnotherRange(rangeToBeTrimmed, trimmingRange, sequenceLength) {
+  if (!rangeToBeTrimmed || !trimmingRange) {
+    console.warn("invalid range input");
+    return null;
+  }
+  let position;
+  for (position of [
+    rangeToBeTrimmed.start,
+    rangeToBeTrimmed.end,
+    trimmingRange.start,
+    trimmingRange.end
+  ]) {
+    if (position < 0 || !position && position !== 0) {
+      console.warn("invalid range input");
+      return null;
+    }
+  }
+  const overlaps = getOverlapsOfPotentiallyCircularRanges(
+    rangeToBeTrimmed,
+    trimmingRange,
+    sequenceLength
+  );
+  if (!overlaps.length) {
+    return rangeToBeTrimmed;
+  }
+  const splitRangesToBeTrimmed = splitRangeIntoTwoPartsIfItIsCircular(
+    rangeToBeTrimmed,
+    sequenceLength
+  );
+  splitRangesToBeTrimmed.forEach(function(nonCircularRangeToBeTrimmed, index) {
+    overlaps.forEach(function(overlap) {
+      if (nonCircularRangeToBeTrimmed) {
+        nonCircularRangeToBeTrimmed = trimNonCicularRangeByAnotherNonCircularRange(
+          nonCircularRangeToBeTrimmed,
+          overlap
+        );
+      }
+    });
+    splitRangesToBeTrimmed[index] = nonCircularRangeToBeTrimmed;
+  });
+  const outputSplitRanges = splitRangesToBeTrimmed.filter(
+    function(trimmedRange) {
+      if (trimmedRange) {
+        return true;
+      }
+      return false;
+    }
+  );
+  let outputTrimmedRange;
+  if (outputSplitRanges.length < 0)
+    ;
+  else if (outputSplitRanges.length === 1) {
+    outputTrimmedRange = outputSplitRanges[0];
+  } else if (outputSplitRanges.length === 2) {
+    if (outputSplitRanges[0].start < outputSplitRanges[1].start) {
+      outputTrimmedRange = {
+        start: outputSplitRanges[1].start,
+        end: outputSplitRanges[0].end
+      };
+    } else {
+      outputTrimmedRange = {
+        start: outputSplitRanges[0].start,
+        end: outputSplitRanges[1].end
+      };
+    }
+  }
+  if (outputTrimmedRange) {
+    return assignIn({}, rangeToBeTrimmed, {
+      start: outputTrimmedRange.start,
+      end: outputTrimmedRange.end
+    });
+  }
+}
+__name(trimRangeByAnotherRange, "trimRangeByAnotherRange");
+function adjustRangeToDeletionOfAnotherRange(rangeToBeAdjusted, anotherRange, maxLength) {
+  const trimmedRange = trimRangeByAnotherRange(
+    rangeToBeAdjusted,
+    anotherRange,
+    maxLength
+  );
+  if (trimmedRange) {
+    const nonCircularDeletionRanges = splitRangeIntoTwoPartsIfItIsCircular(
+      anotherRange,
+      maxLength
+    );
+    nonCircularDeletionRanges.forEach(function(nonCircularDeletionRange) {
+      const deletionLength = nonCircularDeletionRange.end - nonCircularDeletionRange.start + 1;
+      if (trimmedRange.start > trimmedRange.end) {
+        if (nonCircularDeletionRange.start < trimmedRange.end) {
+          trimmedRange.start -= deletionLength;
+          trimmedRange.end -= deletionLength;
+        } else if (nonCircularDeletionRange.start < trimmedRange.start) {
+          trimmedRange.start -= deletionLength;
+        } else
+          ;
+      } else {
+        if (nonCircularDeletionRange.start < trimmedRange.start) {
+          trimmedRange.start -= deletionLength;
+          trimmedRange.end -= deletionLength;
+        } else if (nonCircularDeletionRange.start < trimmedRange.end) {
+          trimmedRange.end -= deletionLength;
+        } else
+          ;
+      }
+    });
+  }
+  return trimmedRange;
+}
+__name(adjustRangeToDeletionOfAnotherRange, "adjustRangeToDeletionOfAnotherRange");
+function adjustRangeToInsert(rangeToBeAdjusted, insertStart, insertLength) {
+  const newRange = assign({}, rangeToBeAdjusted);
+  if (rangeToBeAdjusted.start > rangeToBeAdjusted.end) {
+    if (rangeToBeAdjusted.end >= insertStart) {
+      newRange.start += insertLength;
+      newRange.end += insertLength;
+    } else if (rangeToBeAdjusted.start >= insertStart) {
+      newRange.start += insertLength;
+    }
+  } else {
+    if (rangeToBeAdjusted.start >= insertStart) {
+      newRange.start += insertLength;
+      newRange.end += insertLength;
+    } else if (rangeToBeAdjusted.end >= insertStart) {
+      newRange.end += insertLength;
+    }
+  }
+  return newRange;
+}
+__name(adjustRangeToInsert, "adjustRangeToInsert");
+function checkIfNonCircularRangesOverlap(range, comparisonRange) {
+  if (range.start < comparisonRange.start) {
+    if (range.end < comparisonRange.start) {
+      return false;
+    } else {
+      return true;
+    }
+  } else {
+    if (range.start > comparisonRange.end) {
+      return false;
+    } else {
+      return true;
+    }
+  }
+}
+__name(checkIfNonCircularRangesOverlap, "checkIfNonCircularRangesOverlap");
+function checkIfPotentiallyCircularRangesOverlap(range, comparisonRange) {
+  return splitRangeIntoTwoPartsIfItIsCircular(range, Infinity).some(
+    function(splitRange) {
+      return splitRangeIntoTwoPartsIfItIsCircular(
+        comparisonRange,
+        Infinity
+      ).some(function(splitComparisonRange) {
+        return checkIfNonCircularRangesOverlap(
+          splitRange,
+          splitComparisonRange
+        );
+      });
+    }
+  );
+}
+__name(checkIfPotentiallyCircularRangesOverlap, "checkIfPotentiallyCircularRangesOverlap");
+function collapseOverlapsGeneratedFromRangeComparisonIfPossible(overlaps, sequenceLength, optionalOriginalRange) {
+  const originalRangeLinear = optionalOriginalRange && optionalOriginalRange.start <= optionalOriginalRange.end;
+  if (overlaps.length === 1 || overlaps.length === 0) {
+    return overlaps;
+  } else if (overlaps.length === 2) {
+    if (overlaps[0].start === 0 && overlaps[1].end + 1 === sequenceLength && !originalRangeLinear) {
+      return [
+        {
+          start: overlaps[1].start,
+          end: overlaps[0].end
+        }
+      ];
+    } else if (overlaps[1].start === 0 && overlaps[0].end + 1 === sequenceLength && !originalRangeLinear) {
+      return [
+        {
+          start: overlaps[0].start,
+          end: overlaps[1].end
+        }
+      ];
+    } else {
+      return overlaps;
+    }
+  } else if (overlaps.length === 3) {
+    const firstOverlap = overlaps[0];
+    const secondOverlap = overlaps[1];
+    const thirdOverlap = overlaps[2];
+    let collapsedOverlaps = collapseOverlapsGeneratedFromRangeComparisonIfPossible(
+      [firstOverlap, secondOverlap],
+      sequenceLength,
+      optionalOriginalRange
+    );
+    if (collapsedOverlaps.length === 1) {
+      collapsedOverlaps.push(thirdOverlap);
+      return collapsedOverlaps;
+    } else {
+      collapsedOverlaps = collapseOverlapsGeneratedFromRangeComparisonIfPossible(
+        [firstOverlap, thirdOverlap],
+        sequenceLength,
+        optionalOriginalRange
+      );
+      if (collapsedOverlaps.length === 1) {
+        collapsedOverlaps.push(secondOverlap);
+        return collapsedOverlaps;
+      } else {
+        collapsedOverlaps = collapseOverlapsGeneratedFromRangeComparisonIfPossible(
+          [secondOverlap, thirdOverlap],
+          sequenceLength,
+          optionalOriginalRange
+        );
+        if (collapsedOverlaps.length === 1) {
+          collapsedOverlaps.push(firstOverlap);
+          return collapsedOverlaps;
+        } else {
+          return overlaps;
+        }
+      }
+    }
+  }
+}
+__name(collapseOverlapsGeneratedFromRangeComparisonIfPossible, "collapseOverlapsGeneratedFromRangeComparisonIfPossible");
+function convertRangeIndices(range, inputType, outputType) {
+  inputType = inputType || {};
+  outputType = outputType || {};
+  return assign({}, range, {
+    start: Number(range.start) + (inputType.inclusive1BasedStart ? outputType.inclusive1BasedStart ? 0 : -1 : outputType.inclusive1BasedStart ? 1 : 0),
+    end: Number(range.end) + (inputType.inclusive1BasedEnd ? outputType.inclusive1BasedEnd ? 0 : -1 : outputType.inclusive1BasedEnd ? 1 : 0)
+  });
+}
+__name(convertRangeIndices, "convertRangeIndices");
+function convertRangeTo0Based(range) {
+  return convertRangeIndices(range, {
+    inclusive1BasedStart: true,
+    inclusive1BasedEnd: true
+  });
+}
+__name(convertRangeTo0Based, "convertRangeTo0Based");
+function convertRangeTo1Based(range) {
+  return convertRangeIndices(
+    range,
+    {},
+    { inclusive1BasedStart: true, inclusive1BasedEnd: true }
+  );
+}
+__name(convertRangeTo1Based, "convertRangeTo1Based");
+function provideInclusiveOptions(funToWrap) {
+  return function() {
+    const args = Array.prototype.slice.call(arguments);
+    const options = args[args.length - 1];
+    if (options && (options.inclusive1BasedEnd || options.inclusive1BasedStart)) {
+      args.forEach(function(arg, index) {
+        if (arg && arg.start > -1 && options.inclusive1BasedStart) {
+          args[index] = assign(arg, { start: arg.start - 1 });
+        }
+        if (arg && arg.end > -1 && options.inclusive1BasedEnd) {
+          args[index] = assign(arg, { end: arg.end - 1 });
+        }
+      });
+    }
+    let returnVal = funToWrap.apply(this, args);
+    if (returnVal && returnVal.start > -1 && options && options.inclusive1BasedStart) {
+      returnVal = assign(returnVal, { start: returnVal.start + 1 });
+    }
+    if (returnVal && returnVal.end > -1 && options && options.inclusive1BasedEnd) {
+      returnVal = assign(returnVal, { end: returnVal.end + 1 });
+    }
+    return returnVal;
+  };
+}
+__name(provideInclusiveOptions, "provideInclusiveOptions");
+const getRangeLength = provideInclusiveOptions(getRangeLength$1);
+function getRangeLength$1(range, rangeMax) {
+  let toRet;
+  if (range.end < range.start) {
+    toRet = rangeMax - range.start + range.end + 1;
+  } else {
+    toRet = range.end - range.start + 1;
+  }
+  if (range.overlapsSelf && rangeMax) {
+    toRet += rangeMax;
+  }
+  return toRet;
+}
+__name(getRangeLength$1, "getRangeLength$1");
+function doesRangeSpanEntireSequence(range, sequenceLength) {
+  if (getRangeLength(range) === sequenceLength) {
+    return true;
+  }
+}
+__name(doesRangeSpanEntireSequence, "doesRangeSpanEntireSequence");
+function isRangeWithinRange(rangeToCheck, containingRange, maxLength) {
+  const ranges = trimRangeByAnotherRange(
+    rangeToCheck,
+    containingRange,
+    maxLength
+  );
+  if (ranges === null)
+    return false;
+  return !ranges;
+}
+__name(isRangeWithinRange, "isRangeWithinRange");
+function isPositionWithinRange(position, range, sequenceLength, includeStartEdge, includeEndEdge) {
+  const ranges = splitRangeIntoTwoPartsIfItIsCircular(range, sequenceLength);
+  const positionFits = ranges.some(function(range2) {
+    if (includeStartEdge ? position < range2.start : position <= range2.start) {
+      return false;
+    } else {
+      if (includeEndEdge ? position <= range2.end + 1 : position <= range2.end) {
+        return true;
+      } else {
+        return false;
+      }
+    }
+  });
+  return positionFits;
+}
+__name(isPositionWithinRange, "isPositionWithinRange");
+function isRangeOrPositionWithinRange(rangeOrPositionToCheck, containingRange, maxLength, includeStartEdge, includeEndEdge) {
+  if (rangeOrPositionToCheck === void 0 || rangeOrPositionToCheck === null || containingRange === void 0 || containingRange === null) {
+    return false;
+  }
+  if (isObject(rangeOrPositionToCheck)) {
+    return isRangeWithinRange(
+      rangeOrPositionToCheck,
+      containingRange,
+      maxLength
+    );
+  } else {
+    return isPositionWithinRange(
+      rangeOrPositionToCheck,
+      containingRange,
+      maxLength,
+      includeStartEdge,
+      includeEndEdge
+    );
+  }
+}
+__name(isRangeOrPositionWithinRange, "isRangeOrPositionWithinRange");
+function doesRangeSpanOrigin(range) {
+  return range.start > range.end;
+}
+__name(doesRangeSpanOrigin, "doesRangeSpanOrigin");
+function normalizePositionByRangeLength(pPosition, sequenceLength, isInBetweenPositions) {
+  let position = pPosition;
+  if (position < 0) {
+    position += sequenceLength;
+  } else if (position + (isInBetweenPositions ? 0 : 1) > sequenceLength) {
+    position -= sequenceLength;
+  }
+  return position < 0 ? 0 : position > sequenceLength - (isInBetweenPositions ? 0 : 1) ? sequenceLength - (isInBetweenPositions ? 0 : 1) : position;
+}
+__name(normalizePositionByRangeLength, "normalizePositionByRangeLength");
+function expandOrContractCircularRangeToPosition(range, position, maxLength) {
+  const newRange = assign({}, range);
+  let endMoved = true;
+  if (range.end >= position) {
+    if (position + maxLength - range.start > range.end - position) {
+      newRange.end = normalizePositionByRangeLength(
+        position - 1,
+        maxLength,
+        false
+      );
+    } else {
+      newRange.start = position;
+      endMoved = false;
+    }
+  } else {
+    if (range.start < position) {
+      if (range.end + maxLength - position > position - range.start) {
+        newRange.start = position;
+        endMoved = false;
+      } else {
+        newRange.end = position - 1;
+      }
+    } else {
+      if (range.start - position > position - range.end) {
+        newRange.end = position - 1;
+      } else {
+        endMoved = false;
+        newRange.start = position;
+      }
+    }
+  }
+  return {
+    newRange,
+    endMoved
+  };
+}
+__name(expandOrContractCircularRangeToPosition, "expandOrContractCircularRangeToPosition");
+function expandOrContractNonCircularRangeToPosition(range, position) {
+  const newRange = assign({}, range);
+  let endMoved = true;
+  if (range.start > position) {
+    newRange.start = position;
+    endMoved = false;
+  } else {
+    if (range.end < position) {
+      newRange.end = position - 1;
+    } else {
+      if (position - range.start > range.end - position) {
+        newRange.end = position - 1;
+      } else {
+        newRange.start = position;
+        endMoved = false;
+      }
+    }
+  }
+  return {
+    newRange,
+    endMoved
+  };
+}
+__name(expandOrContractNonCircularRangeToPosition, "expandOrContractNonCircularRangeToPosition");
+function normalizeRange(range, sequenceLength) {
+  return assign({}, range, {
+    start: normalizePositionByRangeLength(range.start, sequenceLength),
+    end: normalizePositionByRangeLength(range.end, sequenceLength)
+  });
+}
+__name(normalizeRange, "normalizeRange");
+function expandOrContractRangeByLength(range, shiftBy, shiftStart, sequenceLength) {
+  const rangeToReturn = clone(range);
+  if (shiftStart) {
+    rangeToReturn.start -= shiftBy;
+  } else {
+    rangeToReturn.end += shiftBy;
+  }
+  return normalizeRange(rangeToReturn, sequenceLength);
+}
+__name(expandOrContractRangeByLength, "expandOrContractRangeByLength");
+function expandOrContractRangeToPosition(range, position, maxLength) {
+  if (range.start > range.end) {
+    return expandOrContractCircularRangeToPosition(range, position, maxLength);
+  } else {
+    return expandOrContractNonCircularRangeToPosition(
+      range,
+      position
+    );
+  }
+}
+__name(expandOrContractRangeToPosition, "expandOrContractRangeToPosition");
+function translateRange(rangeToBeAdjusted, translateBy, rangeLength) {
+  return assign({}, rangeToBeAdjusted, {
+    start: normalizePositionByRangeLength(
+      rangeToBeAdjusted.start + translateBy,
+      rangeLength
+    ),
+    end: normalizePositionByRangeLength(
+      rangeToBeAdjusted.end + translateBy,
+      rangeLength
+    )
+  });
+}
+__name(translateRange, "translateRange");
+function flipRelativeRange(innerRange, outerRange, sequenceLength) {
+  const isFullyContained = isRangeWithinRange(
+    innerRange,
+    outerRange,
+    sequenceLength
+  );
+  if (isFullyContained) {
+    return flipFullyContainedRange(innerRange, outerRange, sequenceLength);
+  } else {
+    return flipNonFullyContainedRange(innerRange, outerRange, sequenceLength);
+  }
+}
+__name(flipRelativeRange, "flipRelativeRange");
+function flipNonFullyContainedRange(innerRange, outerRange, sequenceLength) {
+  const outerFullyContained = isRangeWithinRange(
+    outerRange,
+    innerRange,
+    sequenceLength
+  );
+  let flippedInnerRange;
+  if (outerFullyContained) {
+    const expandBy1 = getRangeLength(
+      {
+        start: innerRange.start,
+        end: outerRange.start
+      },
+      sequenceLength
+    ) - 1;
+    flippedInnerRange = expandOrContractRangeByLength(
+      outerRange,
+      expandBy1,
+      false,
+      sequenceLength
+    );
+    const expandBy2 = getRangeLength(
+      {
+        end: innerRange.end,
+        start: outerRange.end
+      },
+      sequenceLength
+    ) - 1;
+    flippedInnerRange = expandOrContractRangeByLength(
+      flippedInnerRange,
+      expandBy2,
+      true,
+      sequenceLength
+    );
+  } else {
+    const overlaps = getOverlapsOfPotentiallyCircularRanges(
+      innerRange,
+      outerRange,
+      sequenceLength
+    );
+    if (overlaps.length >= 1) {
+      const firstOverlap = overlaps[0];
+      const overlapExtendsForward = firstOverlap.start !== outerRange.start;
+      const flippedTruncatedInner = flipFullyContainedRange(
+        firstOverlap,
+        outerRange,
+        sequenceLength
+      );
+      const lengthToExtend = getRangeLength(innerRange, sequenceLength) - getRangeLength(flippedTruncatedInner, sequenceLength);
+      flippedInnerRange = expandOrContractRangeByLength(
+        flippedTruncatedInner,
+        lengthToExtend,
+        overlapExtendsForward,
+        sequenceLength
+      );
+    } else {
+      throw new Error(
+        "This case (relative ranges that do not overlap) is unsupported! "
+      );
+    }
+  }
+  return flippedInnerRange;
+}
+__name(flipNonFullyContainedRange, "flipNonFullyContainedRange");
+function flipFullyContainedRange(innerRange, outerRange, sequenceLength) {
+  const translateBy = -outerRange.start;
+  const translatedOuterRange = translateRange(
+    outerRange,
+    translateBy,
+    sequenceLength
+  );
+  const translatedInnerRange = translateRange(
+    innerRange,
+    translateBy,
+    sequenceLength
+  );
+  const translatedFlippedInnerRange = flipNonOriginSpanningContainedRange(
+    translatedInnerRange,
+    translatedOuterRange,
+    sequenceLength
+  );
+  const flippedInnerRange = translateRange(
+    translatedFlippedInnerRange,
+    -translateBy,
+    sequenceLength
+  );
+  return flippedInnerRange;
+}
+__name(flipFullyContainedRange, "flipFullyContainedRange");
+function flipNonOriginSpanningContainedRange(innerRange, outerRange, sequenceLength) {
+  const offsetFromStart = innerRange.start - outerRange.start;
+  const newInnerEnd = outerRange.end - offsetFromStart;
+  const innerRangeLength = getRangeLength(innerRange, sequenceLength);
+  return {
+    end: newInnerEnd,
+    start: newInnerEnd - (innerRangeLength - 1)
+  };
+}
+__name(flipNonOriginSpanningContainedRange, "flipNonOriginSpanningContainedRange");
+function generateRandomRange(minStart, maxEnd, maxLength) {
+  const start = getRandomInt(minStart, maxEnd);
+  let end;
+  if (maxLength) {
+    end = normalizePositionByRangeLength(
+      getRandomInt(start, start + maxLength),
+      maxEnd
+    );
+  } else {
+    end = getRandomInt(minStart, maxEnd);
+  }
+  return {
+    start,
+    end
+  };
+}
+__name(generateRandomRange, "generateRandomRange");
+function getRandomInt(min, max) {
+  return Math.floor(Math.random() * (max - min)) + min;
+}
+__name(getRandomInt, "getRandomInt");
+function getAnnotationRangeType(annotationRange, enclosingRangeType, forward) {
+  if (annotationRange.start === enclosingRangeType.start) {
+    if (annotationRange.end === enclosingRangeType.end) {
+      return "beginningAndEnd";
+    } else {
+      if (forward) {
+        return "start";
+      } else {
+        return "end";
+      }
+    }
+  } else {
+    if (annotationRange.end === enclosingRangeType.end) {
+      if (forward) {
+        return "end";
+      } else {
+        return "start";
+      }
+    } else {
+      return "middle";
+    }
+  }
+}
+__name(getAnnotationRangeType, "getAnnotationRangeType");
+function getEachPositionInRangeAsArray(range, rangeMax) {
+  const output = [];
+  const length = getRangeLength(range, rangeMax);
+  if (!(length > 0)) {
+    return output;
+  }
+  for (let i = range.start; i < length + range.start; i++) {
+    const position = normalizePositionByRangeLength(i, rangeMax);
+    output.push(position);
+  }
+  return output;
+}
+__name(getEachPositionInRangeAsArray, "getEachPositionInRangeAsArray");
+function getLengthOfOverlappingRegionsBetweenTwoRanges(rangeA, rangeB, maxLength) {
+  const overlaps = getOverlapsOfPotentiallyCircularRanges(
+    rangeA,
+    rangeB,
+    maxLength
+  );
+  return overlaps.reduce(function(counter, overlap) {
+    return counter + getRangeLength(overlap, maxLength);
+  }, 0);
+}
+__name(getLengthOfOverlappingRegionsBetweenTwoRanges, "getLengthOfOverlappingRegionsBetweenTwoRanges");
+function getPositionFromAngle(angle, rangeMax, isInBetweenPositions) {
+  const unroundedPostion = angle / Math.PI / 2 * rangeMax;
+  return isInBetweenPositions ? Math.round(unroundedPostion) : Math.floor(unroundedPostion);
+}
+__name(getPositionFromAngle, "getPositionFromAngle");
+function getRangeAngles(range, rangeMax) {
+  const { startAngle, totalAngle, endAngle } = getStartEndAndTotalAngle(
+    range,
+    rangeMax
+  );
+  return {
+    startAngle,
+    totalAngle,
+    endAngle,
+    centerAngle: startAngle + totalAngle / 2,
+    locationAngles: range.locations && range.locations.map((location) => {
+      return getRangeAngles(location, rangeMax);
+    })
+  };
+}
+__name(getRangeAngles, "getRangeAngles");
+function getStartEndAndTotalAngle(range, rangeMax) {
+  const rangeLength = getRangeLength(
+    { start: range.start, end: range.end },
+    rangeMax
+  );
+  return {
+    startAngle: 2 * Math.PI * (range.start / rangeMax),
+    totalAngle: rangeLength / rangeMax * Math.PI * 2,
+    endAngle: 2 * Math.PI * (range.end + 1) / rangeMax
+    //use a +1 here because the angle must encompass the end of the annotation
+  };
+}
+__name(getStartEndAndTotalAngle, "getStartEndAndTotalAngle");
+function getMiddleOfRange(range, rangeMax) {
+  const len = getRangeLength({ start: range.start, end: range.end }, rangeMax);
+  return normalizePositionByRangeLength(
+    range.start + Math.floor(len / 2),
+    rangeMax
+  );
+}
+__name(getMiddleOfRange, "getMiddleOfRange");
+function getRangesBetweenTwoRanges(range1, range2) {
+  const newRanges = [];
+  if (!(range1.start > -1 && range1.end > -1 && range2.start > -1 && range2.end > -1)) {
+    return newRanges;
+  }
+  return [
+    {
+      start: range1.start,
+      end: range2.end
+    },
+    {
+      start: range2.start,
+      end: range1.end
+    }
+  ];
+}
+__name(getRangesBetweenTwoRanges, "getRangesBetweenTwoRanges");
+function getSequenceWithinRange(range, sequence) {
+  if (range.start < 0 || range.end < 0)
+    return "";
+  if (range.start > range.end) {
+    let subSequence = sequence.slice(range.start, sequence.length);
+    if (typeof subSequence === "string") {
+      subSequence += sequence.slice(0, range.end + 1);
+    } else {
+      subSequence = subSequence.concat(sequence.slice(0, range.end + 1));
+    }
+    return subSequence;
+  } else {
+    return sequence.slice(range.start, range.end + 1);
+  }
+}
+__name(getSequenceWithinRange, "getSequenceWithinRange");
+function getShortestDistanceBetweenTwoPositions(position1, position2, sequenceLength) {
+  if (position1 < position2) {
+    const position1Holder = position1;
+    position1 = position2;
+    position2 = position1Holder;
+  }
+  const d1 = position1 - position2;
+  const d2 = sequenceLength - position1 + position2;
+  return Math.min(d1, d2);
+}
+__name(getShortestDistanceBetweenTwoPositions, "getShortestDistanceBetweenTwoPositions");
+function getYOffsetForPotentiallyCircularRange(range, YOffsetLevelsWithRanges, assignYOffsetToRange) {
+  let yOffset = [];
+  const openYOffsetFound = YOffsetLevelsWithRanges.some(
+    function(rangesAlreadyAddedToYOffset, index) {
+      const rangeBlocked = rangesAlreadyAddedToYOffset.some(
+        function(comparisonRange) {
+          return checkIfPotentiallyCircularRangesOverlap(
+            range,
+            comparisonRange
+          );
+        }
+      );
+      if (!rangeBlocked) {
+        yOffset = index;
+        if (assignYOffsetToRange)
+          range.yOffset = index;
+        rangesAlreadyAddedToYOffset.push(range);
+        return true;
+      }
+      return false;
+    }
+  );
+  if (!openYOffsetFound) {
+    yOffset = YOffsetLevelsWithRanges.length;
+    if (assignYOffsetToRange)
+      range.yOffset = YOffsetLevelsWithRanges.length;
+  }
+  return yOffset;
+}
+__name(getYOffsetForPotentiallyCircularRange, "getYOffsetForPotentiallyCircularRange");
+function getYOffsetsForPotentiallyCircularRanges(ranges, assignYOffsetToRange) {
+  const yOffsets = [];
+  let maxYOffset = 0;
+  const yOffsetLevels = [];
+  ranges.forEach(function(range) {
+    const yOffset = getYOffsetForPotentiallyCircularRange(
+      range,
+      yOffsetLevels,
+      assignYOffsetToRange
+    );
+    yOffsets.push(yOffset);
+    if (yOffset > maxYOffset) {
+      maxYOffset = yOffset;
+    }
+    range.yOffset = yOffset;
+    if (!yOffsetLevels[yOffset])
+      yOffsetLevels[yOffset] = [];
+    yOffsetLevels[yOffset].push(range);
+  });
+  return { yOffsets, maxYOffset };
+}
+__name(getYOffsetsForPotentiallyCircularRanges, "getYOffsetsForPotentiallyCircularRanges");
+const invertRange = provideInclusiveOptions(invertRange$1);
+function invertRange$1(rangeOrCaret, rangeMax) {
+  if (rangeOrCaret.start > -1) {
+    const start = rangeOrCaret.end + 1;
+    const end = rangeOrCaret.start - 1;
+    return {
+      start: normalizePositionByRangeLength(start, rangeMax, false),
+      end: normalizePositionByRangeLength(end, rangeMax, false)
+    };
+  } else {
+    if (rangeOrCaret > -1) {
+      return {
+        start: normalizePositionByRangeLength(rangeOrCaret, rangeMax, false),
+        end: normalizePositionByRangeLength(rangeOrCaret - 1, rangeMax, false)
+      };
+    }
+  }
+}
+__name(invertRange$1, "invertRange$1");
+function isPositionCloserToRangeStartThanRangeEnd(position, range, maxLength) {
+  const distanceFromStart = getShortestDistanceBetweenTwoPositions(
+    range.start,
+    position,
+    maxLength
+  );
+  const distanceFromEnd = getShortestDistanceBetweenTwoPositions(
+    range.end,
+    position,
+    maxLength
+  );
+  return distanceFromStart <= distanceFromEnd;
+}
+__name(isPositionCloserToRangeStartThanRangeEnd, "isPositionCloserToRangeStartThanRangeEnd");
+function loopEachPositionInRange(range, rangeMax, func) {
+  getEachPositionInRangeAsArray(range, rangeMax).map(func);
+}
+__name(loopEachPositionInRange, "loopEachPositionInRange");
+function modulatePositionByRange(position, range) {
+  let returnVal = position;
+  if (position < range.start) {
+    returnVal = range.end - (range.start - (position + 1));
+  } else if (position > range.end) {
+    returnVal = range.start + (position - range.end - 1);
+  }
+  return returnVal;
+}
+__name(modulatePositionByRange, "modulatePositionByRange");
+const modulateRangeBySequenceLength = provideInclusiveOptions(modulateRangeBySequenceLength$1);
+function modulateRangeBySequenceLength$1(range, seqLen) {
+  return assign(range, {
+    start: normalizePositionByRangeLength(range.start, seqLen),
+    end: normalizePositionByRangeLength(range.end, seqLen)
+  });
+}
+__name(modulateRangeBySequenceLength$1, "modulateRangeBySequenceLength$1");
+function normalizePositionByRangeLength1Based(position, sequenceLength) {
+  return modulatePositionByRange(position, { start: 1, end: sequenceLength });
+}
+__name(normalizePositionByRangeLength1Based, "normalizePositionByRangeLength1Based");
+function reversePositionInRange(position, rangeLength, isInBetweenPositions) {
+  return rangeLength - position - (isInBetweenPositions ? 0 : 1);
+}
+__name(reversePositionInRange, "reversePositionInRange");
+function trimNumberToFitWithin0ToAnotherNumber(numberToBeTrimmed, max) {
+  if (numberToBeTrimmed < 0) {
+    numberToBeTrimmed = 0;
+  }
+  if (numberToBeTrimmed > max) {
+    numberToBeTrimmed = max;
+  }
+  return numberToBeTrimmed;
+}
+__name(trimNumberToFitWithin0ToAnotherNumber, "trimNumberToFitWithin0ToAnotherNumber");
+function zeroSubrangeByContainerRange(subRange, containerRange, sequenceLength) {
+  const trimmedSubRange = trimRangeByAnotherRange(
+    subRange,
+    containerRange,
+    sequenceLength
+  );
+  if (trimmedSubRange) {
+    throw new Error(
+      "subRange must be fully contained by containerRange! Otherwise this function does not make sense"
+    );
+  }
+  const newSubrange = {};
+  newSubrange.start = subRange.start - containerRange.start;
+  newSubrange.end = subRange.end - containerRange.start;
+  if (newSubrange.start < 0) {
+    newSubrange.start += sequenceLength;
+  }
+  if (newSubrange.end < 0) {
+    newSubrange.end += sequenceLength;
+  }
+  return newSubrange;
+}
+__name(zeroSubrangeByContainerRange, "zeroSubrangeByContainerRange");
+function adjustRangeToRotation(rangeToBeAdjusted, rotateTo = 0, rangeLength) {
+  const mod = rangeLength ? modulo : identity;
+  const newRange = assign({}, rangeToBeAdjusted, {
+    start: mod(rangeToBeAdjusted.start - (rotateTo || 0), rangeLength),
+    end: mod(rangeToBeAdjusted.end - (rotateTo || 0), rangeLength)
+  });
+  return newRange;
+}
+__name(adjustRangeToRotation, "adjustRangeToRotation");
+function modulo(n, m) {
+  return (n % m + m) % m;
+}
+__name(modulo, "modulo");
+function getZeroedRangeOverlaps(annotation, selection, sequenceLength) {
+  const overlaps = collapseOverlapsGeneratedFromRangeComparisonIfPossible(
+    getOverlapsOfPotentiallyCircularRanges(
+      annotation,
+      selection,
+      sequenceLength
+    ),
+    sequenceLength,
+    annotation
+  );
+  const zeroedOverlaps = overlaps.map((overlap) => {
+    return zeroSubrangeByContainerRange(
+      overlap,
+      {
+        start: selection.start,
+        end: normalizePositionByRangeLength(selection.start - 1, sequenceLength)
+      },
+      sequenceLength
+    );
+  });
+  return zeroedOverlaps;
+}
+__name(getZeroedRangeOverlaps, "getZeroedRangeOverlaps");
+function trimAnnStartEndToFitSeqLength(annStartOrEnd, sequenceLength) {
+  return Math.max(
+    0,
+    Math.min(annStartOrEnd || 0, Math.max(sequenceLength - 1, 0))
+  );
+}
+__name(trimAnnStartEndToFitSeqLength, "trimAnnStartEndToFitSeqLength");
+exports.adjustRangeToDeletionOfAnotherRange = adjustRangeToDeletionOfAnotherRange;
+exports.adjustRangeToInsert = adjustRangeToInsert;
+exports.adjustRangeToRotation = adjustRangeToRotation;
+exports.checkIfNonCircularRangesOverlap = checkIfNonCircularRangesOverlap;
+exports.checkIfPotentiallyCircularRangesOverlap = checkIfPotentiallyCircularRangesOverlap;
+exports.collapseOverlapsGeneratedFromRangeComparisonIfPossible = collapseOverlapsGeneratedFromRangeComparisonIfPossible;
+exports.convertRangeIndices = convertRangeIndices;
+exports.convertRangeTo0Based = convertRangeTo0Based;
+exports.convertRangeTo1Based = convertRangeTo1Based;
+exports.doesRangeSpanEntireSequence = doesRangeSpanEntireSequence;
+exports.doesRangeSpanOrigin = doesRangeSpanOrigin;
+exports.expandOrContractCircularRangeToPosition = expandOrContractCircularRangeToPosition;
+exports.expandOrContractNonCircularRangeToPosition = expandOrContractNonCircularRangeToPosition;
+exports.expandOrContractRangeByLength = expandOrContractRangeByLength;
+exports.expandOrContractRangeToPosition = expandOrContractRangeToPosition;
+exports.flipContainedRange = flipRelativeRange;
+exports.generateRandomRange = generateRandomRange;
+exports.getAnnotationRangeType = getAnnotationRangeType;
+exports.getEachPositionInRangeAsArray = getEachPositionInRangeAsArray;
+exports.getLengthOfOverlappingRegionsBetweenTwoRanges = getLengthOfOverlappingRegionsBetweenTwoRanges;
+exports.getMiddleOfRange = getMiddleOfRange;
+exports.getOverlapOfNonCircularRanges = getOverlapOfNonCircularRanges;
+exports.getOverlapsOfPotentiallyCircularRanges = getOverlapsOfPotentiallyCircularRanges;
+exports.getPositionFromAngle = getPositionFromAngle;
+exports.getRangeAngles = getRangeAngles;
+exports.getRangeLength = getRangeLength;
+exports.getRangesBetweenTwoRanges = getRangesBetweenTwoRanges;
+exports.getSequenceWithinRange = getSequenceWithinRange;
+exports.getShortestDistanceBetweenTwoPositions = getShortestDistanceBetweenTwoPositions;
+exports.getYOffsetForPotentiallyCircularRange = getYOffsetForPotentiallyCircularRange;
+exports.getYOffsetsForPotentiallyCircularRanges = getYOffsetsForPotentiallyCircularRanges;
+exports.getZeroedRangeOverlaps = getZeroedRangeOverlaps;
+exports.invertRange = invertRange;
+exports.isPositionCloserToRangeStartThanRangeEnd = isPositionCloserToRangeStartThanRangeEnd;
+exports.isPositionWithinRange = isPositionWithinRange;
+exports.isRangeOrPositionWithinRange = isRangeOrPositionWithinRange;
+exports.isRangeWithinRange = isRangeWithinRange;
+exports.loopEachPositionInRange = loopEachPositionInRange;
+exports.modulatePositionByRange = modulatePositionByRange;
+exports.modulateRangeBySequenceLength = modulateRangeBySequenceLength;
+exports.normalizePositionByRangeLength = normalizePositionByRangeLength;
+exports.normalizePositionByRangeLength1Based = normalizePositionByRangeLength1Based;
+exports.normalizeRange = normalizeRange;
+exports.provideInclusiveOptions = provideInclusiveOptions;
+exports.reversePositionInRange = reversePositionInRange;
+exports.splitRangeIntoTwoPartsIfItIsCircular = splitRangeIntoTwoPartsIfItIsCircular;
+exports.translateRange = translateRange;
+exports.trimAnnStartEndToFitSeqLength = trimAnnStartEndToFitSeqLength;
+exports.trimNonCicularRangeByAnotherNonCircularRange = trimNonCicularRangeByAnotherNonCircularRange;
+exports.trimNumberToFitWithin0ToAnotherNumber = trimNumberToFitWithin0ToAnotherNumber;
+exports.trimRangeByAnotherRange = trimRangeByAnotherRange;
+exports.zeroSubrangeByContainerRange = zeroSubrangeByContainerRange;