audible-api-ts 0.1.0 → 0.3.0

package/dist/index.js

@@ -1,12 +1,1700 @@
 var __defProp = Object.defineProperty;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, {
       get: all[name],
       enumerable: true,
       configurable: true,
-      set: (newValue) => all[name] = () => newValue
+      set: __exportSetter.bind(all, name)
+    });
+};
+// node_modules/lodash-es/_arrayMap.js
+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;
+}
+var _arrayMap_default = arrayMap;
+
+// node_modules/lodash-es/isArray.js
+var isArray = Array.isArray;
+var isArray_default = isArray;
+
+// node_modules/lodash-es/_freeGlobal.js
+var freeGlobal = typeof global == "object" && global && global.Object === Object && global;
+var _freeGlobal_default = freeGlobal;
+
+// node_modules/lodash-es/_root.js
+var freeSelf = typeof self == "object" && self && self.Object === Object && self;
+var root = _freeGlobal_default || freeSelf || Function("return this")();
+var _root_default = root;
+
+// node_modules/lodash-es/_Symbol.js
+var Symbol2 = _root_default.Symbol;
+var _Symbol_default = Symbol2;
+
+// node_modules/lodash-es/_getRawTag.js
+var objectProto = Object.prototype;
+var hasOwnProperty = objectProto.hasOwnProperty;
+var nativeObjectToString = objectProto.toString;
+var symToStringTag = _Symbol_default ? _Symbol_default.toStringTag : undefined;
+function getRawTag(value) {
+  var isOwn = hasOwnProperty.call(value, symToStringTag), tag = value[symToStringTag];
+  try {
+    value[symToStringTag] = undefined;
+    var unmasked = true;
+  } catch (e) {}
+  var result = nativeObjectToString.call(value);
+  if (unmasked) {
+    if (isOwn) {
+      value[symToStringTag] = tag;
+    } else {
+      delete value[symToStringTag];
+    }
+  }
+  return result;
+}
+var _getRawTag_default = getRawTag;
+
+// node_modules/lodash-es/_objectToString.js
+var objectProto2 = Object.prototype;
+var nativeObjectToString2 = objectProto2.toString;
+function objectToString(value) {
+  return nativeObjectToString2.call(value);
+}
+var _objectToString_default = objectToString;
+
+// node_modules/lodash-es/_baseGetTag.js
+var nullTag = "[object Null]";
+var undefinedTag = "[object Undefined]";
+var symToStringTag2 = _Symbol_default ? _Symbol_default.toStringTag : undefined;
+function baseGetTag(value) {
+  if (value == null) {
+    return value === undefined ? undefinedTag : nullTag;
+  }
+  return symToStringTag2 && symToStringTag2 in Object(value) ? _getRawTag_default(value) : _objectToString_default(value);
+}
+var _baseGetTag_default = baseGetTag;
+
+// node_modules/lodash-es/isObjectLike.js
+function isObjectLike(value) {
+  return value != null && typeof value == "object";
+}
+var isObjectLike_default = isObjectLike;
+
+// node_modules/lodash-es/isSymbol.js
+var symbolTag = "[object Symbol]";
+function isSymbol(value) {
+  return typeof value == "symbol" || isObjectLike_default(value) && _baseGetTag_default(value) == symbolTag;
+}
+var isSymbol_default = isSymbol;
+
+// node_modules/lodash-es/_isKey.js
+var reIsDeepProp = /\.|\[(?:[^[\]]*|(["'])(?:(?!\1)[^\\]|\\.)*?\1)\]/;
+var reIsPlainProp = /^\w*$/;
+function isKey(value, object) {
+  if (isArray_default(value)) {
+    return false;
+  }
+  var type = typeof value;
+  if (type == "number" || type == "symbol" || type == "boolean" || value == null || isSymbol_default(value)) {
+    return true;
+  }
+  return reIsPlainProp.test(value) || !reIsDeepProp.test(value) || object != null && value in Object(object);
+}
+var _isKey_default = isKey;
+
+// node_modules/lodash-es/isObject.js
+function isObject(value) {
+  var type = typeof value;
+  return value != null && (type == "object" || type == "function");
+}
+var isObject_default = isObject;
+
+// node_modules/lodash-es/isFunction.js
+var asyncTag = "[object AsyncFunction]";
+var funcTag = "[object Function]";
+var genTag = "[object GeneratorFunction]";
+var proxyTag = "[object Proxy]";
+function isFunction(value) {
+  if (!isObject_default(value)) {
+    return false;
+  }
+  var tag = _baseGetTag_default(value);
+  return tag == funcTag || tag == genTag || tag == asyncTag || tag == proxyTag;
+}
+var isFunction_default = isFunction;
+
+// node_modules/lodash-es/_coreJsData.js
+var coreJsData = _root_default["__core-js_shared__"];
+var _coreJsData_default = coreJsData;
+
+// node_modules/lodash-es/_isMasked.js
+var maskSrcKey = function() {
+  var uid = /[^.]+$/.exec(_coreJsData_default && _coreJsData_default.keys && _coreJsData_default.keys.IE_PROTO || "");
+  return uid ? "Symbol(src)_1." + uid : "";
+}();
+function isMasked(func) {
+  return !!maskSrcKey && maskSrcKey in func;
+}
+var _isMasked_default = isMasked;
+
+// node_modules/lodash-es/_toSource.js
+var funcProto = Function.prototype;
+var funcToString = funcProto.toString;
+function toSource(func) {
+  if (func != null) {
+    try {
+      return funcToString.call(func);
+    } catch (e) {}
+    try {
+      return func + "";
+    } catch (e) {}
+  }
+  return "";
+}
+var _toSource_default = toSource;
+
+// node_modules/lodash-es/_baseIsNative.js
+var reRegExpChar = /[\\^$.*+?()[\]{}|]/g;
+var reIsHostCtor = /^\[object .+?Constructor\]$/;
+var funcProto2 = Function.prototype;
+var objectProto3 = Object.prototype;
+var funcToString2 = funcProto2.toString;
+var hasOwnProperty2 = objectProto3.hasOwnProperty;
+var reIsNative = RegExp("^" + funcToString2.call(hasOwnProperty2).replace(reRegExpChar, "\\$&").replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g, "$1.*?") + "$");
+function baseIsNative(value) {
+  if (!isObject_default(value) || _isMasked_default(value)) {
+    return false;
+  }
+  var pattern = isFunction_default(value) ? reIsNative : reIsHostCtor;
+  return pattern.test(_toSource_default(value));
+}
+var _baseIsNative_default = baseIsNative;
+
+// node_modules/lodash-es/_getValue.js
+function getValue(object, key) {
+  return object == null ? undefined : object[key];
+}
+var _getValue_default = getValue;
+
+// node_modules/lodash-es/_getNative.js
+function getNative(object, key) {
+  var value = _getValue_default(object, key);
+  return _baseIsNative_default(value) ? value : undefined;
+}
+var _getNative_default = getNative;
+
+// node_modules/lodash-es/_nativeCreate.js
+var nativeCreate = _getNative_default(Object, "create");
+var _nativeCreate_default = nativeCreate;
+
+// node_modules/lodash-es/_hashClear.js
+function hashClear() {
+  this.__data__ = _nativeCreate_default ? _nativeCreate_default(null) : {};
+  this.size = 0;
+}
+var _hashClear_default = hashClear;
+
+// node_modules/lodash-es/_hashDelete.js
+function hashDelete(key) {
+  var result = this.has(key) && delete this.__data__[key];
+  this.size -= result ? 1 : 0;
+  return result;
+}
+var _hashDelete_default = hashDelete;
+
+// node_modules/lodash-es/_hashGet.js
+var HASH_UNDEFINED = "__lodash_hash_undefined__";
+var objectProto4 = Object.prototype;
+var hasOwnProperty3 = objectProto4.hasOwnProperty;
+function hashGet(key) {
+  var data = this.__data__;
+  if (_nativeCreate_default) {
+    var result = data[key];
+    return result === HASH_UNDEFINED ? undefined : result;
+  }
+  return hasOwnProperty3.call(data, key) ? data[key] : undefined;
+}
+var _hashGet_default = hashGet;
+
+// node_modules/lodash-es/_hashHas.js
+var objectProto5 = Object.prototype;
+var hasOwnProperty4 = objectProto5.hasOwnProperty;
+function hashHas(key) {
+  var data = this.__data__;
+  return _nativeCreate_default ? data[key] !== undefined : hasOwnProperty4.call(data, key);
+}
+var _hashHas_default = hashHas;
+
+// node_modules/lodash-es/_hashSet.js
+var HASH_UNDEFINED2 = "__lodash_hash_undefined__";
+function hashSet(key, value) {
+  var data = this.__data__;
+  this.size += this.has(key) ? 0 : 1;
+  data[key] = _nativeCreate_default && value === undefined ? HASH_UNDEFINED2 : value;
+  return this;
+}
+var _hashSet_default = hashSet;
+
+// node_modules/lodash-es/_Hash.js
+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]);
+  }
+}
+Hash.prototype.clear = _hashClear_default;
+Hash.prototype["delete"] = _hashDelete_default;
+Hash.prototype.get = _hashGet_default;
+Hash.prototype.has = _hashHas_default;
+Hash.prototype.set = _hashSet_default;
+var _Hash_default = Hash;
+
+// node_modules/lodash-es/_listCacheClear.js
+function listCacheClear() {
+  this.__data__ = [];
+  this.size = 0;
+}
+var _listCacheClear_default = listCacheClear;
+
+// node_modules/lodash-es/eq.js
+function eq(value, other) {
+  return value === other || value !== value && other !== other;
+}
+var eq_default = eq;
+
+// node_modules/lodash-es/_assocIndexOf.js
+function assocIndexOf(array, key) {
+  var length = array.length;
+  while (length--) {
+    if (eq_default(array[length][0], key)) {
+      return length;
+    }
+  }
+  return -1;
+}
+var _assocIndexOf_default = assocIndexOf;
+
+// node_modules/lodash-es/_listCacheDelete.js
+var arrayProto = Array.prototype;
+var splice = arrayProto.splice;
+function listCacheDelete(key) {
+  var data = this.__data__, index = _assocIndexOf_default(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;
+}
+var _listCacheDelete_default = listCacheDelete;
+
+// node_modules/lodash-es/_listCacheGet.js
+function listCacheGet(key) {
+  var data = this.__data__, index = _assocIndexOf_default(data, key);
+  return index < 0 ? undefined : data[index][1];
+}
+var _listCacheGet_default = listCacheGet;
+
+// node_modules/lodash-es/_listCacheHas.js
+function listCacheHas(key) {
+  return _assocIndexOf_default(this.__data__, key) > -1;
+}
+var _listCacheHas_default = listCacheHas;
+
+// node_modules/lodash-es/_listCacheSet.js
+function listCacheSet(key, value) {
+  var data = this.__data__, index = _assocIndexOf_default(data, key);
+  if (index < 0) {
+    ++this.size;
+    data.push([key, value]);
+  } else {
+    data[index][1] = value;
+  }
+  return this;
+}
+var _listCacheSet_default = listCacheSet;
+
+// node_modules/lodash-es/_ListCache.js
+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]);
+  }
+}
+ListCache.prototype.clear = _listCacheClear_default;
+ListCache.prototype["delete"] = _listCacheDelete_default;
+ListCache.prototype.get = _listCacheGet_default;
+ListCache.prototype.has = _listCacheHas_default;
+ListCache.prototype.set = _listCacheSet_default;
+var _ListCache_default = ListCache;
+
+// node_modules/lodash-es/_Map.js
+var Map2 = _getNative_default(_root_default, "Map");
+var _Map_default = Map2;
+
+// node_modules/lodash-es/_mapCacheClear.js
+function mapCacheClear() {
+  this.size = 0;
+  this.__data__ = {
+    hash: new _Hash_default,
+    map: new (_Map_default || _ListCache_default),
+    string: new _Hash_default
+  };
+}
+var _mapCacheClear_default = mapCacheClear;
+
+// node_modules/lodash-es/_isKeyable.js
+function isKeyable(value) {
+  var type = typeof value;
+  return type == "string" || type == "number" || type == "symbol" || type == "boolean" ? value !== "__proto__" : value === null;
+}
+var _isKeyable_default = isKeyable;
+
+// node_modules/lodash-es/_getMapData.js
+function getMapData(map, key) {
+  var data = map.__data__;
+  return _isKeyable_default(key) ? data[typeof key == "string" ? "string" : "hash"] : data.map;
+}
+var _getMapData_default = getMapData;
+
+// node_modules/lodash-es/_mapCacheDelete.js
+function mapCacheDelete(key) {
+  var result = _getMapData_default(this, key)["delete"](key);
+  this.size -= result ? 1 : 0;
+  return result;
+}
+var _mapCacheDelete_default = mapCacheDelete;
+
+// node_modules/lodash-es/_mapCacheGet.js
+function mapCacheGet(key) {
+  return _getMapData_default(this, key).get(key);
+}
+var _mapCacheGet_default = mapCacheGet;
+
+// node_modules/lodash-es/_mapCacheHas.js
+function mapCacheHas(key) {
+  return _getMapData_default(this, key).has(key);
+}
+var _mapCacheHas_default = mapCacheHas;
+
+// node_modules/lodash-es/_mapCacheSet.js
+function mapCacheSet(key, value) {
+  var data = _getMapData_default(this, key), size = data.size;
+  data.set(key, value);
+  this.size += data.size == size ? 0 : 1;
+  return this;
+}
+var _mapCacheSet_default = mapCacheSet;
+
+// node_modules/lodash-es/_MapCache.js
+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]);
+  }
+}
+MapCache.prototype.clear = _mapCacheClear_default;
+MapCache.prototype["delete"] = _mapCacheDelete_default;
+MapCache.prototype.get = _mapCacheGet_default;
+MapCache.prototype.has = _mapCacheHas_default;
+MapCache.prototype.set = _mapCacheSet_default;
+var _MapCache_default = MapCache;
+
+// node_modules/lodash-es/memoize.js
+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 = 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.cache = new (memoize.Cache || _MapCache_default);
+  return memoized;
+}
+memoize.Cache = _MapCache_default;
+var memoize_default = memoize;
+
+// node_modules/lodash-es/_memoizeCapped.js
+var MAX_MEMOIZE_SIZE = 500;
+function memoizeCapped(func) {
+  var result = memoize_default(func, function(key) {
+    if (cache.size === MAX_MEMOIZE_SIZE) {
+      cache.clear();
+    }
+    return key;
+  });
+  var cache = result.cache;
+  return result;
+}
+var _memoizeCapped_default = memoizeCapped;
+
+// node_modules/lodash-es/_stringToPath.js
+var rePropName = /[^.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|(["'])((?:(?!\2)[^\\]|\\.)*?)\2)\]|(?=(?:\.|\[\])(?:\.|\[\]|$))/g;
+var reEscapeChar = /\\(\\)?/g;
+var stringToPath = _memoizeCapped_default(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;
+});
+var _stringToPath_default = stringToPath;
+
+// node_modules/lodash-es/_baseToString.js
+var INFINITY = 1 / 0;
+var symbolProto = _Symbol_default ? _Symbol_default.prototype : undefined;
+var symbolToString = symbolProto ? symbolProto.toString : undefined;
+function baseToString(value) {
+  if (typeof value == "string") {
+    return value;
+  }
+  if (isArray_default(value)) {
+    return _arrayMap_default(value, baseToString) + "";
+  }
+  if (isSymbol_default(value)) {
+    return symbolToString ? symbolToString.call(value) : "";
+  }
+  var result = value + "";
+  return result == "0" && 1 / value == -INFINITY ? "-0" : result;
+}
+var _baseToString_default = baseToString;
+
+// node_modules/lodash-es/toString.js
+function toString(value) {
+  return value == null ? "" : _baseToString_default(value);
+}
+var toString_default = toString;
+
+// node_modules/lodash-es/_castPath.js
+function castPath(value, object) {
+  if (isArray_default(value)) {
+    return value;
+  }
+  return _isKey_default(value, object) ? [value] : _stringToPath_default(toString_default(value));
+}
+var _castPath_default = castPath;
+
+// node_modules/lodash-es/_toKey.js
+var INFINITY2 = 1 / 0;
+function toKey(value) {
+  if (typeof value == "string" || isSymbol_default(value)) {
+    return value;
+  }
+  var result = value + "";
+  return result == "0" && 1 / value == -INFINITY2 ? "-0" : result;
+}
+var _toKey_default = toKey;
+
+// node_modules/lodash-es/_baseGet.js
+function baseGet(object, path) {
+  path = _castPath_default(path, object);
+  var index = 0, length = path.length;
+  while (object != null && index < length) {
+    object = object[_toKey_default(path[index++])];
+  }
+  return index && index == length ? object : undefined;
+}
+var _baseGet_default = baseGet;
+
+// node_modules/lodash-es/_stackClear.js
+function stackClear() {
+  this.__data__ = new _ListCache_default;
+  this.size = 0;
+}
+var _stackClear_default = stackClear;
+
+// node_modules/lodash-es/_stackDelete.js
+function stackDelete(key) {
+  var data = this.__data__, result = data["delete"](key);
+  this.size = data.size;
+  return result;
+}
+var _stackDelete_default = stackDelete;
+
+// node_modules/lodash-es/_stackGet.js
+function stackGet(key) {
+  return this.__data__.get(key);
+}
+var _stackGet_default = stackGet;
+
+// node_modules/lodash-es/_stackHas.js
+function stackHas(key) {
+  return this.__data__.has(key);
+}
+var _stackHas_default = stackHas;
+
+// node_modules/lodash-es/_stackSet.js
+var LARGE_ARRAY_SIZE = 200;
+function stackSet(key, value) {
+  var data = this.__data__;
+  if (data instanceof _ListCache_default) {
+    var pairs = data.__data__;
+    if (!_Map_default || pairs.length < LARGE_ARRAY_SIZE - 1) {
+      pairs.push([key, value]);
+      this.size = ++data.size;
+      return this;
+    }
+    data = this.__data__ = new _MapCache_default(pairs);
+  }
+  data.set(key, value);
+  this.size = data.size;
+  return this;
+}
+var _stackSet_default = stackSet;
+
+// node_modules/lodash-es/_Stack.js
+function Stack(entries) {
+  var data = this.__data__ = new _ListCache_default(entries);
+  this.size = data.size;
+}
+Stack.prototype.clear = _stackClear_default;
+Stack.prototype["delete"] = _stackDelete_default;
+Stack.prototype.get = _stackGet_default;
+Stack.prototype.has = _stackHas_default;
+Stack.prototype.set = _stackSet_default;
+var _Stack_default = Stack;
+
+// node_modules/lodash-es/_setCacheAdd.js
+var HASH_UNDEFINED3 = "__lodash_hash_undefined__";
+function setCacheAdd(value) {
+  this.__data__.set(value, HASH_UNDEFINED3);
+  return this;
+}
+var _setCacheAdd_default = setCacheAdd;
+
+// node_modules/lodash-es/_setCacheHas.js
+function setCacheHas(value) {
+  return this.__data__.has(value);
+}
+var _setCacheHas_default = setCacheHas;
+
+// node_modules/lodash-es/_SetCache.js
+function SetCache(values) {
+  var index = -1, length = values == null ? 0 : values.length;
+  this.__data__ = new _MapCache_default;
+  while (++index < length) {
+    this.add(values[index]);
+  }
+}
+SetCache.prototype.add = SetCache.prototype.push = _setCacheAdd_default;
+SetCache.prototype.has = _setCacheHas_default;
+var _SetCache_default = SetCache;
+
+// node_modules/lodash-es/_arraySome.js
+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;
+}
+var _arraySome_default = arraySome;
+
+// node_modules/lodash-es/_cacheHas.js
+function cacheHas(cache, key) {
+  return cache.has(key);
+}
+var _cacheHas_default = cacheHas;
+
+// node_modules/lodash-es/_equalArrays.js
+var COMPARE_PARTIAL_FLAG = 1;
+var COMPARE_UNORDERED_FLAG = 2;
+function equalArrays(array, other, bitmask, customizer, equalFunc, stack) {
+  var isPartial = bitmask & COMPARE_PARTIAL_FLAG, 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 ? new _SetCache_default : undefined;
+  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 !== undefined) {
+      if (compared) {
+        continue;
+      }
+      result = false;
+      break;
+    }
+    if (seen) {
+      if (!_arraySome_default(other, function(othValue, othIndex) {
+        if (!_cacheHas_default(seen, othIndex) && (arrValue === othValue || equalFunc(arrValue, othValue, 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;
+}
+var _equalArrays_default = equalArrays;
+
+// node_modules/lodash-es/_Uint8Array.js
+var Uint8Array = _root_default.Uint8Array;
+var _Uint8Array_default = Uint8Array;
+
+// node_modules/lodash-es/_mapToArray.js
+function mapToArray(map) {
+  var index = -1, result = Array(map.size);
+  map.forEach(function(value, key) {
+    result[++index] = [key, value];
+  });
+  return result;
+}
+var _mapToArray_default = mapToArray;
+
+// node_modules/lodash-es/_setToArray.js
+function setToArray(set) {
+  var index = -1, result = Array(set.size);
+  set.forEach(function(value) {
+    result[++index] = value;
+  });
+  return result;
+}
+var _setToArray_default = setToArray;
+
+// node_modules/lodash-es/_equalByTag.js
+var COMPARE_PARTIAL_FLAG2 = 1;
+var COMPARE_UNORDERED_FLAG2 = 2;
+var boolTag = "[object Boolean]";
+var dateTag = "[object Date]";
+var errorTag = "[object Error]";
+var mapTag = "[object Map]";
+var numberTag = "[object Number]";
+var regexpTag = "[object RegExp]";
+var setTag = "[object Set]";
+var stringTag = "[object String]";
+var symbolTag2 = "[object Symbol]";
+var arrayBufferTag = "[object ArrayBuffer]";
+var dataViewTag = "[object DataView]";
+var symbolProto2 = _Symbol_default ? _Symbol_default.prototype : undefined;
+var symbolValueOf = symbolProto2 ? symbolProto2.valueOf : undefined;
+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 _Uint8Array_default(object), new _Uint8Array_default(other))) {
+        return false;
+      }
+      return true;
+    case boolTag:
+    case dateTag:
+    case numberTag:
+      return eq_default(+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_default;
+    case setTag:
+      var isPartial = bitmask & COMPARE_PARTIAL_FLAG2;
+      convert || (convert = _setToArray_default);
+      if (object.size != other.size && !isPartial) {
+        return false;
+      }
+      var stacked = stack.get(object);
+      if (stacked) {
+        return stacked == other;
+      }
+      bitmask |= COMPARE_UNORDERED_FLAG2;
+      stack.set(object, other);
+      var result = _equalArrays_default(convert(object), convert(other), bitmask, customizer, equalFunc, stack);
+      stack["delete"](object);
+      return result;
+    case symbolTag2:
+      if (symbolValueOf) {
+        return symbolValueOf.call(object) == symbolValueOf.call(other);
+      }
+  }
+  return false;
+}
+var _equalByTag_default = equalByTag;
+
+// node_modules/lodash-es/_arrayPush.js
+function arrayPush(array, values) {
+  var index = -1, length = values.length, offset = array.length;
+  while (++index < length) {
+    array[offset + index] = values[index];
+  }
+  return array;
+}
+var _arrayPush_default = arrayPush;
+
+// node_modules/lodash-es/_baseGetAllKeys.js
+function baseGetAllKeys(object, keysFunc, symbolsFunc) {
+  var result = keysFunc(object);
+  return isArray_default(object) ? result : _arrayPush_default(result, symbolsFunc(object));
+}
+var _baseGetAllKeys_default = baseGetAllKeys;
+
+// node_modules/lodash-es/_arrayFilter.js
+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;
+}
+var _arrayFilter_default = arrayFilter;
+
+// node_modules/lodash-es/stubArray.js
+function stubArray() {
+  return [];
+}
+var stubArray_default = stubArray;
+
+// node_modules/lodash-es/_getSymbols.js
+var objectProto6 = Object.prototype;
+var propertyIsEnumerable = objectProto6.propertyIsEnumerable;
+var nativeGetSymbols = Object.getOwnPropertySymbols;
+var getSymbols = !nativeGetSymbols ? stubArray_default : function(object) {
+  if (object == null) {
+    return [];
+  }
+  object = Object(object);
+  return _arrayFilter_default(nativeGetSymbols(object), function(symbol) {
+    return propertyIsEnumerable.call(object, symbol);
+  });
+};
+var _getSymbols_default = getSymbols;
+
+// node_modules/lodash-es/_baseTimes.js
+function baseTimes(n, iteratee) {
+  var index = -1, result = Array(n);
+  while (++index < n) {
+    result[index] = iteratee(index);
+  }
+  return result;
+}
+var _baseTimes_default = baseTimes;
+
+// node_modules/lodash-es/_baseIsArguments.js
+var argsTag = "[object Arguments]";
+function baseIsArguments(value) {
+  return isObjectLike_default(value) && _baseGetTag_default(value) == argsTag;
+}
+var _baseIsArguments_default = baseIsArguments;
+
+// node_modules/lodash-es/isArguments.js
+var objectProto7 = Object.prototype;
+var hasOwnProperty5 = objectProto7.hasOwnProperty;
+var propertyIsEnumerable2 = objectProto7.propertyIsEnumerable;
+var isArguments = _baseIsArguments_default(function() {
+  return arguments;
+}()) ? _baseIsArguments_default : function(value) {
+  return isObjectLike_default(value) && hasOwnProperty5.call(value, "callee") && !propertyIsEnumerable2.call(value, "callee");
+};
+var isArguments_default = isArguments;
+
+// node_modules/lodash-es/isBuffer.js
+var exports_isBuffer = {};
+__export(exports_isBuffer, {
+  default: () => isBuffer_default
+});
+
+// node_modules/lodash-es/stubFalse.js
+function stubFalse() {
+  return false;
+}
+var stubFalse_default = stubFalse;
+
+// node_modules/lodash-es/isBuffer.js
+var freeExports = typeof exports_isBuffer == "object" && exports_isBuffer && !exports_isBuffer.nodeType && exports_isBuffer;
+var freeModule = freeExports && typeof module_isBuffer == "object" && module_isBuffer && !module_isBuffer.nodeType && module_isBuffer;
+var moduleExports = freeModule && freeModule.exports === freeExports;
+var Buffer2 = moduleExports ? _root_default.Buffer : undefined;
+var nativeIsBuffer = Buffer2 ? Buffer2.isBuffer : undefined;
+var isBuffer = nativeIsBuffer || stubFalse_default;
+var isBuffer_default = isBuffer;
+
+// node_modules/lodash-es/_isIndex.js
+var MAX_SAFE_INTEGER = 9007199254740991;
+var reIsUint = /^(?:0|[1-9]\d*)$/;
+function isIndex(value, length) {
+  var type = typeof value;
+  length = length == null ? MAX_SAFE_INTEGER : length;
+  return !!length && (type == "number" || type != "symbol" && reIsUint.test(value)) && (value > -1 && value % 1 == 0 && value < length);
+}
+var _isIndex_default = isIndex;
+
+// node_modules/lodash-es/isLength.js
+var MAX_SAFE_INTEGER2 = 9007199254740991;
+function isLength(value) {
+  return typeof value == "number" && value > -1 && value % 1 == 0 && value <= MAX_SAFE_INTEGER2;
+}
+var isLength_default = isLength;
+
+// node_modules/lodash-es/_baseIsTypedArray.js
+var argsTag2 = "[object Arguments]";
+var arrayTag = "[object Array]";
+var boolTag2 = "[object Boolean]";
+var dateTag2 = "[object Date]";
+var errorTag2 = "[object Error]";
+var funcTag2 = "[object Function]";
+var mapTag2 = "[object Map]";
+var numberTag2 = "[object Number]";
+var objectTag = "[object Object]";
+var regexpTag2 = "[object RegExp]";
+var setTag2 = "[object Set]";
+var stringTag2 = "[object String]";
+var weakMapTag = "[object WeakMap]";
+var arrayBufferTag2 = "[object ArrayBuffer]";
+var dataViewTag2 = "[object DataView]";
+var float32Tag = "[object Float32Array]";
+var float64Tag = "[object Float64Array]";
+var int8Tag = "[object Int8Array]";
+var int16Tag = "[object Int16Array]";
+var int32Tag = "[object Int32Array]";
+var uint8Tag = "[object Uint8Array]";
+var uint8ClampedTag = "[object Uint8ClampedArray]";
+var uint16Tag = "[object Uint16Array]";
+var uint32Tag = "[object Uint32Array]";
+var typedArrayTags = {};
+typedArrayTags[float32Tag] = typedArrayTags[float64Tag] = typedArrayTags[int8Tag] = typedArrayTags[int16Tag] = typedArrayTags[int32Tag] = typedArrayTags[uint8Tag] = typedArrayTags[uint8ClampedTag] = typedArrayTags[uint16Tag] = typedArrayTags[uint32Tag] = true;
+typedArrayTags[argsTag2] = typedArrayTags[arrayTag] = typedArrayTags[arrayBufferTag2] = typedArrayTags[boolTag2] = typedArrayTags[dataViewTag2] = typedArrayTags[dateTag2] = typedArrayTags[errorTag2] = typedArrayTags[funcTag2] = typedArrayTags[mapTag2] = typedArrayTags[numberTag2] = typedArrayTags[objectTag] = typedArrayTags[regexpTag2] = typedArrayTags[setTag2] = typedArrayTags[stringTag2] = typedArrayTags[weakMapTag] = false;
+function baseIsTypedArray(value) {
+  return isObjectLike_default(value) && isLength_default(value.length) && !!typedArrayTags[_baseGetTag_default(value)];
+}
+var _baseIsTypedArray_default = baseIsTypedArray;
+
+// node_modules/lodash-es/_baseUnary.js
+function baseUnary(func) {
+  return function(value) {
+    return func(value);
+  };
+}
+var _baseUnary_default = baseUnary;
+
+// node_modules/lodash-es/_nodeUtil.js
+var exports__nodeUtil = {};
+__export(exports__nodeUtil, {
+  default: () => _nodeUtil_default
+});
+var freeExports2 = typeof exports__nodeUtil == "object" && exports__nodeUtil && !exports__nodeUtil.nodeType && exports__nodeUtil;
+var freeModule2 = freeExports2 && typeof module__nodeUtil == "object" && module__nodeUtil && !module__nodeUtil.nodeType && module__nodeUtil;
+var moduleExports2 = freeModule2 && freeModule2.exports === freeExports2;
+var freeProcess = moduleExports2 && _freeGlobal_default.process;
+var nodeUtil = function() {
+  try {
+    var types = freeModule2 && freeModule2.require && freeModule2.require("util").types;
+    if (types) {
+      return types;
+    }
+    return freeProcess && freeProcess.binding && freeProcess.binding("util");
+  } catch (e) {}
+}();
+var _nodeUtil_default = nodeUtil;
+
+// node_modules/lodash-es/isTypedArray.js
+var nodeIsTypedArray = _nodeUtil_default && _nodeUtil_default.isTypedArray;
+var isTypedArray = nodeIsTypedArray ? _baseUnary_default(nodeIsTypedArray) : _baseIsTypedArray_default;
+var isTypedArray_default = isTypedArray;
+
+// node_modules/lodash-es/_arrayLikeKeys.js
+var objectProto8 = Object.prototype;
+var hasOwnProperty6 = objectProto8.hasOwnProperty;
+function arrayLikeKeys(value, inherited) {
+  var isArr = isArray_default(value), isArg = !isArr && isArguments_default(value), isBuff = !isArr && !isArg && isBuffer_default(value), isType = !isArr && !isArg && !isBuff && isTypedArray_default(value), skipIndexes = isArr || isArg || isBuff || isType, result = skipIndexes ? _baseTimes_default(value.length, String) : [], length = result.length;
+  for (var key in value) {
+    if ((inherited || hasOwnProperty6.call(value, key)) && !(skipIndexes && (key == "length" || isBuff && (key == "offset" || key == "parent") || isType && (key == "buffer" || key == "byteLength" || key == "byteOffset") || _isIndex_default(key, length)))) {
+      result.push(key);
+    }
+  }
+  return result;
+}
+var _arrayLikeKeys_default = arrayLikeKeys;
+
+// node_modules/lodash-es/_isPrototype.js
+var objectProto9 = Object.prototype;
+function isPrototype(value) {
+  var Ctor = value && value.constructor, proto = typeof Ctor == "function" && Ctor.prototype || objectProto9;
+  return value === proto;
+}
+var _isPrototype_default = isPrototype;
+
+// node_modules/lodash-es/_overArg.js
+function overArg(func, transform) {
+  return function(arg) {
+    return func(transform(arg));
+  };
+}
+var _overArg_default = overArg;
+
+// node_modules/lodash-es/_nativeKeys.js
+var nativeKeys = _overArg_default(Object.keys, Object);
+var _nativeKeys_default = nativeKeys;
+
+// node_modules/lodash-es/_baseKeys.js
+var objectProto10 = Object.prototype;
+var hasOwnProperty7 = objectProto10.hasOwnProperty;
+function baseKeys(object) {
+  if (!_isPrototype_default(object)) {
+    return _nativeKeys_default(object);
+  }
+  var result = [];
+  for (var key in Object(object)) {
+    if (hasOwnProperty7.call(object, key) && key != "constructor") {
+      result.push(key);
+    }
+  }
+  return result;
+}
+var _baseKeys_default = baseKeys;
+
+// node_modules/lodash-es/isArrayLike.js
+function isArrayLike(value) {
+  return value != null && isLength_default(value.length) && !isFunction_default(value);
+}
+var isArrayLike_default = isArrayLike;
+
+// node_modules/lodash-es/keys.js
+function keys(object) {
+  return isArrayLike_default(object) ? _arrayLikeKeys_default(object) : _baseKeys_default(object);
+}
+var keys_default = keys;
+
+// node_modules/lodash-es/_getAllKeys.js
+function getAllKeys(object) {
+  return _baseGetAllKeys_default(object, keys_default, _getSymbols_default);
+}
+var _getAllKeys_default = getAllKeys;
+
+// node_modules/lodash-es/_equalObjects.js
+var COMPARE_PARTIAL_FLAG3 = 1;
+var objectProto11 = Object.prototype;
+var hasOwnProperty8 = objectProto11.hasOwnProperty;
+function equalObjects(object, other, bitmask, customizer, equalFunc, stack) {
+  var isPartial = bitmask & COMPARE_PARTIAL_FLAG3, objProps = _getAllKeys_default(object), objLength = objProps.length, othProps = _getAllKeys_default(other), othLength = othProps.length;
+  if (objLength != othLength && !isPartial) {
+    return false;
+  }
+  var index = objLength;
+  while (index--) {
+    var key = objProps[index];
+    if (!(isPartial ? key in other : hasOwnProperty8.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 === undefined ? 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;
+}
+var _equalObjects_default = equalObjects;
+
+// node_modules/lodash-es/_DataView.js
+var DataView = _getNative_default(_root_default, "DataView");
+var _DataView_default = DataView;
+
+// node_modules/lodash-es/_Promise.js
+var Promise2 = _getNative_default(_root_default, "Promise");
+var _Promise_default = Promise2;
+
+// node_modules/lodash-es/_Set.js
+var Set2 = _getNative_default(_root_default, "Set");
+var _Set_default = Set2;
+
+// node_modules/lodash-es/_WeakMap.js
+var WeakMap2 = _getNative_default(_root_default, "WeakMap");
+var _WeakMap_default = WeakMap2;
+
+// node_modules/lodash-es/_getTag.js
+var mapTag3 = "[object Map]";
+var objectTag2 = "[object Object]";
+var promiseTag = "[object Promise]";
+var setTag3 = "[object Set]";
+var weakMapTag2 = "[object WeakMap]";
+var dataViewTag3 = "[object DataView]";
+var dataViewCtorString = _toSource_default(_DataView_default);
+var mapCtorString = _toSource_default(_Map_default);
+var promiseCtorString = _toSource_default(_Promise_default);
+var setCtorString = _toSource_default(_Set_default);
+var weakMapCtorString = _toSource_default(_WeakMap_default);
+var getTag = _baseGetTag_default;
+if (_DataView_default && getTag(new _DataView_default(new ArrayBuffer(1))) != dataViewTag3 || _Map_default && getTag(new _Map_default) != mapTag3 || _Promise_default && getTag(_Promise_default.resolve()) != promiseTag || _Set_default && getTag(new _Set_default) != setTag3 || _WeakMap_default && getTag(new _WeakMap_default) != weakMapTag2) {
+  getTag = function(value) {
+    var result = _baseGetTag_default(value), Ctor = result == objectTag2 ? value.constructor : undefined, ctorString = Ctor ? _toSource_default(Ctor) : "";
+    if (ctorString) {
+      switch (ctorString) {
+        case dataViewCtorString:
+          return dataViewTag3;
+        case mapCtorString:
+          return mapTag3;
+        case promiseCtorString:
+          return promiseTag;
+        case setCtorString:
+          return setTag3;
+        case weakMapCtorString:
+          return weakMapTag2;
+      }
+    }
+    return result;
+  };
+}
+var _getTag_default = getTag;
+
+// node_modules/lodash-es/_baseIsEqualDeep.js
+var COMPARE_PARTIAL_FLAG4 = 1;
+var argsTag3 = "[object Arguments]";
+var arrayTag2 = "[object Array]";
+var objectTag3 = "[object Object]";
+var objectProto12 = Object.prototype;
+var hasOwnProperty9 = objectProto12.hasOwnProperty;
+function baseIsEqualDeep(object, other, bitmask, customizer, equalFunc, stack) {
+  var objIsArr = isArray_default(object), othIsArr = isArray_default(other), objTag = objIsArr ? arrayTag2 : _getTag_default(object), othTag = othIsArr ? arrayTag2 : _getTag_default(other);
+  objTag = objTag == argsTag3 ? objectTag3 : objTag;
+  othTag = othTag == argsTag3 ? objectTag3 : othTag;
+  var objIsObj = objTag == objectTag3, othIsObj = othTag == objectTag3, isSameTag = objTag == othTag;
+  if (isSameTag && isBuffer_default(object)) {
+    if (!isBuffer_default(other)) {
+      return false;
+    }
+    objIsArr = true;
+    objIsObj = false;
+  }
+  if (isSameTag && !objIsObj) {
+    stack || (stack = new _Stack_default);
+    return objIsArr || isTypedArray_default(object) ? _equalArrays_default(object, other, bitmask, customizer, equalFunc, stack) : _equalByTag_default(object, other, objTag, bitmask, customizer, equalFunc, stack);
+  }
+  if (!(bitmask & COMPARE_PARTIAL_FLAG4)) {
+    var objIsWrapped = objIsObj && hasOwnProperty9.call(object, "__wrapped__"), othIsWrapped = othIsObj && hasOwnProperty9.call(other, "__wrapped__");
+    if (objIsWrapped || othIsWrapped) {
+      var objUnwrapped = objIsWrapped ? object.value() : object, othUnwrapped = othIsWrapped ? other.value() : other;
+      stack || (stack = new _Stack_default);
+      return equalFunc(objUnwrapped, othUnwrapped, bitmask, customizer, stack);
+    }
+  }
+  if (!isSameTag) {
+    return false;
+  }
+  stack || (stack = new _Stack_default);
+  return _equalObjects_default(object, other, bitmask, customizer, equalFunc, stack);
+}
+var _baseIsEqualDeep_default = baseIsEqualDeep;
+
+// node_modules/lodash-es/_baseIsEqual.js
+function baseIsEqual(value, other, bitmask, customizer, stack) {
+  if (value === other) {
+    return true;
+  }
+  if (value == null || other == null || !isObjectLike_default(value) && !isObjectLike_default(other)) {
+    return value !== value && other !== other;
+  }
+  return _baseIsEqualDeep_default(value, other, bitmask, customizer, baseIsEqual, stack);
+}
+var _baseIsEqual_default = baseIsEqual;
+
+// node_modules/lodash-es/_baseIsMatch.js
+var COMPARE_PARTIAL_FLAG5 = 1;
+var COMPARE_UNORDERED_FLAG3 = 2;
+function baseIsMatch(object, source, matchData, customizer) {
+  var index = matchData.length, length = index, noCustomizer = !customizer;
+  if (object == null) {
+    return !length;
+  }
+  object = Object(object);
+  while (index--) {
+    var data = matchData[index];
+    if (noCustomizer && 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 (noCustomizer && data[2]) {
+      if (objValue === undefined && !(key in object)) {
+        return false;
+      }
+    } else {
+      var stack = new _Stack_default;
+      if (customizer) {
+        var result = customizer(objValue, srcValue, key, object, source, stack);
+      }
+      if (!(result === undefined ? _baseIsEqual_default(srcValue, objValue, COMPARE_PARTIAL_FLAG5 | COMPARE_UNORDERED_FLAG3, customizer, stack) : result)) {
+        return false;
+      }
+    }
+  }
+  return true;
+}
+var _baseIsMatch_default = baseIsMatch;
+
+// node_modules/lodash-es/_isStrictComparable.js
+function isStrictComparable(value) {
+  return value === value && !isObject_default(value);
+}
+var _isStrictComparable_default = isStrictComparable;
+
+// node_modules/lodash-es/_getMatchData.js
+function getMatchData(object) {
+  var result = keys_default(object), length = result.length;
+  while (length--) {
+    var key = result[length], value = object[key];
+    result[length] = [key, value, _isStrictComparable_default(value)];
+  }
+  return result;
+}
+var _getMatchData_default = getMatchData;
+
+// node_modules/lodash-es/_matchesStrictComparable.js
+function matchesStrictComparable(key, srcValue) {
+  return function(object) {
+    if (object == null) {
+      return false;
+    }
+    return object[key] === srcValue && (srcValue !== undefined || (key in Object(object)));
+  };
+}
+var _matchesStrictComparable_default = matchesStrictComparable;
+
+// node_modules/lodash-es/_baseMatches.js
+function baseMatches(source) {
+  var matchData = _getMatchData_default(source);
+  if (matchData.length == 1 && matchData[0][2]) {
+    return _matchesStrictComparable_default(matchData[0][0], matchData[0][1]);
+  }
+  return function(object) {
+    return object === source || _baseIsMatch_default(object, source, matchData);
+  };
+}
+var _baseMatches_default = baseMatches;
+
+// node_modules/lodash-es/get.js
+function get(object, path, defaultValue) {
+  var result = object == null ? undefined : _baseGet_default(object, path);
+  return result === undefined ? defaultValue : result;
+}
+var get_default = get;
+
+// node_modules/lodash-es/_baseHasIn.js
+function baseHasIn(object, key) {
+  return object != null && key in Object(object);
+}
+var _baseHasIn_default = baseHasIn;
+
+// node_modules/lodash-es/_hasPath.js
+function hasPath(object, path, hasFunc) {
+  path = _castPath_default(path, object);
+  var index = -1, length = path.length, result = false;
+  while (++index < length) {
+    var key = _toKey_default(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_default(length) && _isIndex_default(key, length) && (isArray_default(object) || isArguments_default(object));
+}
+var _hasPath_default = hasPath;
+
+// node_modules/lodash-es/hasIn.js
+function hasIn(object, path) {
+  return object != null && _hasPath_default(object, path, _baseHasIn_default);
+}
+var hasIn_default = hasIn;
+
+// node_modules/lodash-es/_baseMatchesProperty.js
+var COMPARE_PARTIAL_FLAG6 = 1;
+var COMPARE_UNORDERED_FLAG4 = 2;
+function baseMatchesProperty(path, srcValue) {
+  if (_isKey_default(path) && _isStrictComparable_default(srcValue)) {
+    return _matchesStrictComparable_default(_toKey_default(path), srcValue);
+  }
+  return function(object) {
+    var objValue = get_default(object, path);
+    return objValue === undefined && objValue === srcValue ? hasIn_default(object, path) : _baseIsEqual_default(srcValue, objValue, COMPARE_PARTIAL_FLAG6 | COMPARE_UNORDERED_FLAG4);
+  };
+}
+var _baseMatchesProperty_default = baseMatchesProperty;
+
+// node_modules/lodash-es/identity.js
+function identity(value) {
+  return value;
+}
+var identity_default = identity;
+
+// node_modules/lodash-es/_baseProperty.js
+function baseProperty(key) {
+  return function(object) {
+    return object == null ? undefined : object[key];
+  };
+}
+var _baseProperty_default = baseProperty;
+
+// node_modules/lodash-es/_basePropertyDeep.js
+function basePropertyDeep(path) {
+  return function(object) {
+    return _baseGet_default(object, path);
+  };
+}
+var _basePropertyDeep_default = basePropertyDeep;
+
+// node_modules/lodash-es/property.js
+function property(path) {
+  return _isKey_default(path) ? _baseProperty_default(_toKey_default(path)) : _basePropertyDeep_default(path);
+}
+var property_default = property;
+
+// node_modules/lodash-es/_baseIteratee.js
+function baseIteratee(value) {
+  if (typeof value == "function") {
+    return value;
+  }
+  if (value == null) {
+    return identity_default;
+  }
+  if (typeof value == "object") {
+    return isArray_default(value) ? _baseMatchesProperty_default(value[0], value[1]) : _baseMatches_default(value);
+  }
+  return property_default(value);
+}
+var _baseIteratee_default = baseIteratee;
+
+// node_modules/lodash-es/_createBaseFor.js
+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[fromRight ? length : ++index];
+      if (iteratee(iterable[key], key, iterable) === false) {
+        break;
+      }
+    }
+    return object;
+  };
+}
+var _createBaseFor_default = createBaseFor;
+
+// node_modules/lodash-es/_baseFor.js
+var baseFor = _createBaseFor_default();
+var _baseFor_default = baseFor;
+
+// node_modules/lodash-es/_baseForOwn.js
+function baseForOwn(object, iteratee) {
+  return object && _baseFor_default(object, iteratee, keys_default);
+}
+var _baseForOwn_default = baseForOwn;
+
+// node_modules/lodash-es/_createBaseEach.js
+function createBaseEach(eachFunc, fromRight) {
+  return function(collection, iteratee) {
+    if (collection == null) {
+      return collection;
+    }
+    if (!isArrayLike_default(collection)) {
+      return eachFunc(collection, iteratee);
+    }
+    var length = collection.length, index = fromRight ? length : -1, iterable = Object(collection);
+    while (fromRight ? index-- : ++index < length) {
+      if (iteratee(iterable[index], index, iterable) === false) {
+        break;
+      }
+    }
+    return collection;
+  };
+}
+var _createBaseEach_default = createBaseEach;
+
+// node_modules/lodash-es/_baseEach.js
+var baseEach = _createBaseEach_default(_baseForOwn_default);
+var _baseEach_default = baseEach;
+
+// node_modules/lodash-es/_baseMap.js
+function baseMap(collection, iteratee) {
+  var index = -1, result = isArrayLike_default(collection) ? Array(collection.length) : [];
+  _baseEach_default(collection, function(value, key, collection) {
+    result[++index] = iteratee(value, key, collection);
+  });
+  return result;
+}
+var _baseMap_default = baseMap;
+
+// node_modules/lodash-es/_baseSortBy.js
+function baseSortBy(array, comparer) {
+  var length = array.length;
+  array.sort(comparer);
+  while (length--) {
+    array[length] = array[length].value;
+  }
+  return array;
+}
+var _baseSortBy_default = baseSortBy;
+
+// node_modules/lodash-es/_compareAscending.js
+function compareAscending(value, other) {
+  if (value !== other) {
+    var valIsDefined = value !== undefined, valIsNull = value === null, valIsReflexive = value === value, valIsSymbol = isSymbol_default(value);
+    var othIsDefined = other !== undefined, othIsNull = other === null, othIsReflexive = other === other, othIsSymbol = isSymbol_default(other);
+    if (!othIsNull && !othIsSymbol && !valIsSymbol && value > other || valIsSymbol && othIsDefined && othIsReflexive && !othIsNull && !othIsSymbol || valIsNull && othIsDefined && othIsReflexive || !valIsDefined && othIsReflexive || !valIsReflexive) {
+      return 1;
+    }
+    if (!valIsNull && !valIsSymbol && !othIsSymbol && value < other || othIsSymbol && valIsDefined && valIsReflexive && !valIsNull && !valIsSymbol || othIsNull && valIsDefined && valIsReflexive || !othIsDefined && valIsReflexive || !othIsReflexive) {
+      return -1;
+    }
+  }
+  return 0;
+}
+var _compareAscending_default = compareAscending;
+
+// node_modules/lodash-es/_compareMultiple.js
+function compareMultiple(object, other, orders) {
+  var index = -1, objCriteria = object.criteria, othCriteria = other.criteria, length = objCriteria.length, ordersLength = orders.length;
+  while (++index < length) {
+    var result = _compareAscending_default(objCriteria[index], othCriteria[index]);
+    if (result) {
+      if (index >= ordersLength) {
+        return result;
+      }
+      var order = orders[index];
+      return result * (order == "desc" ? -1 : 1);
+    }
+  }
+  return object.index - other.index;
+}
+var _compareMultiple_default = compareMultiple;
+
+// node_modules/lodash-es/_baseOrderBy.js
+function baseOrderBy(collection, iteratees, orders) {
+  if (iteratees.length) {
+    iteratees = _arrayMap_default(iteratees, function(iteratee) {
+      if (isArray_default(iteratee)) {
+        return function(value) {
+          return _baseGet_default(value, iteratee.length === 1 ? iteratee[0] : iteratee);
+        };
+      }
+      return iteratee;
+    });
+  } else {
+    iteratees = [identity_default];
+  }
+  var index = -1;
+  iteratees = _arrayMap_default(iteratees, _baseUnary_default(_baseIteratee_default));
+  var result = _baseMap_default(collection, function(value, key, collection) {
+    var criteria = _arrayMap_default(iteratees, function(iteratee) {
+      return iteratee(value);
     });
+    return { criteria, index: ++index, value };
+  });
+  return _baseSortBy_default(result, function(object, other) {
+    return _compareMultiple_default(object, other, orders);
+  });
+}
+var _baseOrderBy_default = baseOrderBy;
+
+// node_modules/lodash-es/orderBy.js
+function orderBy(collection, iteratees, orders, guard) {
+  if (collection == null) {
+    return [];
+  }
+  if (!isArray_default(iteratees)) {
+    iteratees = iteratees == null ? [] : [iteratees];
+  }
+  orders = guard ? undefined : orders;
+  if (!isArray_default(orders)) {
+    orders = orders == null ? [] : [orders];
+  }
+  return _baseOrderBy_default(collection, iteratees, orders);
+}
+var orderBy_default = orderBy;
+// node_modules/lodash-es/_baseFindIndex.js
+function baseFindIndex(array, predicate, fromIndex, fromRight) {
+  var length = array.length, index = fromIndex + (fromRight ? 1 : -1);
+  while (fromRight ? index-- : ++index < length) {
+    if (predicate(array[index], index, array)) {
+      return index;
+    }
+  }
+  return -1;
+}
+var _baseFindIndex_default = baseFindIndex;
+
+// node_modules/lodash-es/_baseIsNaN.js
+function baseIsNaN(value) {
+  return value !== value;
+}
+var _baseIsNaN_default = baseIsNaN;
+
+// node_modules/lodash-es/_strictIndexOf.js
+function strictIndexOf(array, value, fromIndex) {
+  var index = fromIndex - 1, length = array.length;
+  while (++index < length) {
+    if (array[index] === value) {
+      return index;
+    }
+  }
+  return -1;
+}
+var _strictIndexOf_default = strictIndexOf;
+
+// node_modules/lodash-es/_baseIndexOf.js
+function baseIndexOf(array, value, fromIndex) {
+  return value === value ? _strictIndexOf_default(array, value, fromIndex) : _baseFindIndex_default(array, _baseIsNaN_default, fromIndex);
+}
+var _baseIndexOf_default = baseIndexOf;
+
+// node_modules/lodash-es/_arrayIncludes.js
+function arrayIncludes(array, value) {
+  var length = array == null ? 0 : array.length;
+  return !!length && _baseIndexOf_default(array, value, 0) > -1;
+}
+var _arrayIncludes_default = arrayIncludes;
+
+// node_modules/lodash-es/_arrayIncludesWith.js
+function arrayIncludesWith(array, value, comparator) {
+  var index = -1, length = array == null ? 0 : array.length;
+  while (++index < length) {
+    if (comparator(value, array[index])) {
+      return true;
+    }
+  }
+  return false;
+}
+var _arrayIncludesWith_default = arrayIncludesWith;
+
+// node_modules/lodash-es/noop.js
+function noop() {}
+var noop_default = noop;
+
+// node_modules/lodash-es/_createSet.js
+var INFINITY3 = 1 / 0;
+var createSet = !(_Set_default && 1 / _setToArray_default(new _Set_default([, -0]))[1] == INFINITY3) ? noop_default : function(values) {
+  return new _Set_default(values);
+};
+var _createSet_default = createSet;
+
+// node_modules/lodash-es/_baseUniq.js
+var LARGE_ARRAY_SIZE2 = 200;
+function baseUniq(array, iteratee, comparator) {
+  var index = -1, includes = _arrayIncludes_default, length = array.length, isCommon = true, result = [], seen = result;
+  if (comparator) {
+    isCommon = false;
+    includes = _arrayIncludesWith_default;
+  } else if (length >= LARGE_ARRAY_SIZE2) {
+    var set = iteratee ? null : _createSet_default(array);
+    if (set) {
+      return _setToArray_default(set);
+    }
+    isCommon = false;
+    includes = _cacheHas_default;
+    seen = new _SetCache_default;
+  } else {
+    seen = iteratee ? [] : result;
+  }
+  outer:
+    while (++index < length) {
+      var value = array[index], computed = iteratee ? iteratee(value) : value;
+      value = comparator || value !== 0 ? value : 0;
+      if (isCommon && computed === computed) {
+        var seenIndex = seen.length;
+        while (seenIndex--) {
+          if (seen[seenIndex] === computed) {
+            continue outer;
+          }
+        }
+        if (iteratee) {
+          seen.push(computed);
+        }
+        result.push(value);
+      } else if (!includes(seen, computed, comparator)) {
+        if (seen !== result) {
+          seen.push(computed);
+        }
+        result.push(value);
+      }
+    }
+  return result;
+}
+var _baseUniq_default = baseUniq;
+
+// node_modules/lodash-es/uniqBy.js
+function uniqBy(array, iteratee) {
+  return array && array.length ? _baseUniq_default(array, _baseIteratee_default(iteratee, 2)) : [];
+}
+var uniqBy_default = uniqBy;
+// src/categories.ts
+var GENRE_CATEGORIES = {
+  "science-fiction": { fr: "21229020031", com: "18580628011" },
+  fantasy: { fr: "21229021031", com: "18580607011" },
+  "science-fiction-fantasy": { fr: "21228885031", com: "18580606011" },
+  "mystery-thriller-suspense": { fr: "21228876031", com: "18574597011" },
+  thriller: { fr: "21228906031", com: "18574621011" },
+  mystery: { fr: "21228905031", com: "18574606011" },
+  "crime-fiction": { fr: "21228907031", com: "18574598011" },
+  horror: { fr: "21229011031", com: "18574490011" },
+  romance: { fr: "21228893031", com: "18580518011" },
+  "historical-fiction": { fr: "21229010031", com: "18574482011" },
+  "literary-fiction": { fr: "21228884031", com: "18574426011" },
+  biography: { fr: "21228881031", com: "18571951011" },
+  history: { fr: "21228890031", com: "18573518011" },
+  business: { fr: "21228882031", com: "18572029011" },
+  "self-help": { fr: "21228892031", com: "18574784011" },
+  science: { fr: "21228897031", com: "18580540011" },
+  children: { fr: "21228877031", com: "18572091011" },
+  "young-adult": { fr: "21228895031", com: "18580715011" },
+  comedy: { fr: "34003928031", com: "24427740011" },
+  erotica: { fr: "21228894031", com: "18573351011" },
+  religion: { fr: "21228880031", com: "18574839011" },
+  sports: { fr: "21228879031", com: "18580648011" },
+  travel: { fr: "21228891031", com: "18581095011" },
+  lgbtq: { fr: "21228883031", com: "18573743011" },
+  "science-fiction/adventure": { fr: "21229681031", com: "18580629011" },
+  "science-fiction/adaptations": { fr: "21229683031", com: "18580642011" },
+  "science-fiction/cyberpunk": { fr: "21229684031", com: "18580633011" },
+  "science-fiction/dystopian": { fr: "21229685031", com: "18580635011" },
+  "science-fiction/first-contact": { fr: "21229682031", com: "18580636011" },
+  "science-fiction/galactic-empire": { fr: "21229693031" },
+  "science-fiction/genetic-engineering": { fr: "21229686031", com: "18580638011" },
+  "science-fiction/military": { fr: "21229688031", com: "18580641011" },
+  "science-fiction/post-apocalyptic": { fr: "21229687031", com: "18580643011" },
+  "science-fiction/space-exploration": { fr: "21229689031", com: "18580644011" },
+  "science-fiction/space-opera": { fr: "21229694031", com: "18580645011" },
+  "fantasy/action-adventure": { fr: "21229712031", com: "18580608011" },
+  "fantasy/adaptations": { fr: "21229708031", com: "18580621011" },
+  "fantasy/dragons": { fr: "21229709031", com: "18580613011" },
+  "fantasy/epic": { fr: "21229701031", com: "18580615011" },
+  "fantasy/historical": { fr: "21229700031", com: "18580618011" },
+  "fantasy/sword-sorcery": { fr: "21229713031", com: "18580627011" },
+  "fantasy/urban-paranormal": { fr: "21229711031", com: "18580622011" },
+  "thriller/suspense": { fr: "21229158031", com: "18574639011" },
+  "thriller/psychological": { fr: "21229165031", com: "18574631011" },
+  "thriller/domestic": { fr: "21229163031", com: "18574624011" },
+  "thriller/historical": { fr: "21229168031", com: "18574627011" },
+  "mystery/amateur-sleuth": { fr: "21229145031", com: "18574607011" },
+  "mystery/cozy": { fr: "21229150031", com: "18574609011" },
+  "mystery/detective": { fr: "21229148031", com: "18574618011" },
+  "mystery/hard-boiled": { fr: "21229153031", com: "18574614011" },
+  "mystery/historical": { fr: "21229155031", com: "18574615011" },
+  "mystery/noir": { fr: "21229177031", com: "18574602011" },
+  "mystery/police-procedural": { fr: "21229144031", com: "18574617011" },
+  "mystery/private-investigator": { fr: "21229148031", com: "18574618011" },
+  "mystery/traditional": { fr: "21229152031", com: "18574619011" },
+  "romance/action-adventure": { fr: "21229096031", com: "18580519011" },
+  "romance/comedy": { fr: "21229087031", com: "18580535011" },
+  "romance/contemporary": { fr: "21230152031", com: "18580522011" },
+  "romance/fantasy": { fr: "21229095031", com: "18580523011" },
+  "romance/historical": { fr: "21229093031", com: "18580524011" },
+  "romance/paranormal": { fr: "21229088031", com: "18580534011" },
+  "romance/science-fiction": { fr: "21229085031", com: "18580537011" },
+  "romance/sports": { fr: "21229086031", com: "18580538011" },
+  "romance/suspense": { fr: "21229090031", com: "18580536011" },
+  "literary-fiction/action-adventure": { fr: "21229016031", com: "18574427011" },
+  "literary-fiction/classics": { fr: "21229007031", com: "18574449011" },
+  "literary-fiction/coming-of-age": { fr: "21229655031", com: "18574461011" },
+  "literary-fiction/contemporary": { fr: "21229657031", com: "18574462011" },
+  "literary-fiction/drama": { fr: "21229017031", com: "18574450011" },
+  "literary-fiction/family-life": { fr: "21229670031", com: "18574465011" },
+  "literary-fiction/fiction": { fr: "21229019031", com: "18574456011" },
+  "literary-fiction/historical": { fr: "21229010031", com: "18574482011" },
+  "literary-fiction/sagas": { fr: "21229654031", com: "18574476011" },
+  "literary-fiction/sea-adventures": { fr: "21229673031", com: "18574434011" },
+  "literary-fiction/world-literature": { fr: "21229018031", com: "18574521011" },
+  "biography/entertainment": { fr: "21228985031", com: "18571984011" },
+  "history/europe": { fr: "21229067031", com: "18573582011" },
+  "children/action-adventure": { fr: "21228913031", com: "18572092011" },
+  "children/mystery": { fr: "21228927031", com: "18572548011" },
+  "children/science-fiction-fantasy": { fr: "21228926031", com: "18572586011" },
+  "children/fantasy": { fr: "21229338031", com: "18572587011" },
+  "children/science-fiction": { fr: "21229339031", com: "18572593011" },
+  "young-adult/literary-fiction": { fr: "21229110031", com: "18580894011" },
+  "young-adult/romance": { fr: "21229117031", com: "18581004011" },
+  "young-adult/science-fiction-fantasy": { fr: "21229103031", com: "18581048011" },
+  "young-adult/fantasy": { fr: "21230013031", com: "18581049011" },
+  "young-adult/science-fiction": { fr: "21230014031", com: "18581062011" },
+  "young-adult/thriller": { fr: "21229114031", com: "18580961011" }
+};
+var resolveGenreId = (genre, locale) => {
+  const id = GENRE_CATEGORIES[genre]?.[locale];
+  if (!id) {
+    throw new Error(`Genre "${genre}" is not mapped for locale "${locale}". Use categoryId directly or contribute the mapping.`);
+  }
+  return id;
 };
 
 // src/client.ts
@@ -27,16 +1715,16 @@ var AUDIBLE_LOCALES = {
 };
 
 // src/utils.ts
-import { Buffer as Buffer2 } from "node:buffer";
+import { Buffer as Buffer3 } from "node:buffer";
 var base64url = (buffer) => buffer.toString("base64").replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
 var base64nopad = (buffer) => buffer.toString("base64").replace(/=+$/, "");
-var toHexString = (input) => Buffer2.from(input, "utf-8").toString("hex");
+var toHexString = (input) => Buffer3.from(input, "utf-8").toString("hex");
 
 // src/client.ts
 var DEVICE_TYPE = "A2CZJZGLK2JJVM";
 var APP_VERSION = "3.56.2";
 var SOFTWARE_VERSION = "35602678";
-var generateLoginUrl = async (locale) => {
+var login = async (locale) => {
   const config = AUDIBLE_LOCALES[locale];
   const codeVerifier = base64url(randomBytes(32));
   const codeChallenge = base64url(createHash("sha256").update(codeVerifier).digest());
@@ -92,7 +1780,7 @@ var generateLoginUrl = async (locale) => {
   ];
   return { loginUrl, session, cookies };
 };
-var registerDevice = async (authorizationCode, session) => {
+var register = async (authorizationCode, session) => {
   const config = AUDIBLE_LOCALES[session.locale];
   const clientId = toHexString(`${session.serial}#${DEVICE_TYPE}`);
   const body = {
@@ -139,7 +1827,7 @@ var registerDevice = async (authorizationCode, session) => {
     expiresAt: new Date(Date.now() + Number(bearer.expires_in) * 1000)
   };
 };
-var refreshAccessToken = async (credentials) => {
+var refresh = async (credentials) => {
   const config = AUDIBLE_LOCALES[credentials.locale];
   const response = await fetch(`https://api.amazon.${config.domain}/auth/token`, {
     method: "POST",
@@ -162,149 +1850,38 @@ var refreshAccessToken = async (credentials) => {
     expiresAt: new Date(Date.now() + data.expires_in * 1000)
   };
 };
-// node_modules/zod/v3/external.js
-var exports_external = {};
-__export(exports_external, {
-  void: () => voidType,
-  util: () => util,
-  unknown: () => unknownType,
-  union: () => unionType,
-  undefined: () => undefinedType,
-  tuple: () => tupleType,
-  transformer: () => effectsType,
-  symbol: () => symbolType,
-  string: () => stringType,
-  strictObject: () => strictObjectType,
-  setErrorMap: () => setErrorMap,
-  set: () => setType,
-  record: () => recordType,
-  quotelessJson: () => quotelessJson,
-  promise: () => promiseType,
-  preprocess: () => preprocessType,
-  pipeline: () => pipelineType,
-  ostring: () => ostring,
-  optional: () => optionalType,
-  onumber: () => onumber,
-  oboolean: () => oboolean,
-  objectUtil: () => objectUtil,
-  object: () => objectType,
-  number: () => numberType,
-  nullable: () => nullableType,
-  null: () => nullType,
-  never: () => neverType,
-  nativeEnum: () => nativeEnumType,
-  nan: () => nanType,
-  map: () => mapType,
-  makeIssue: () => makeIssue,
-  literal: () => literalType,
-  lazy: () => lazyType,
-  late: () => late,
-  isValid: () => isValid,
-  isDirty: () => isDirty,
-  isAsync: () => isAsync,
-  isAborted: () => isAborted,
-  intersection: () => intersectionType,
-  instanceof: () => instanceOfType,
-  getParsedType: () => getParsedType,
-  getErrorMap: () => getErrorMap,
-  function: () => functionType,
-  enum: () => enumType,
-  effect: () => effectsType,
-  discriminatedUnion: () => discriminatedUnionType,
-  defaultErrorMap: () => en_default,
-  datetimeRegex: () => datetimeRegex,
-  date: () => dateType,
-  custom: () => custom,
-  coerce: () => coerce,
-  boolean: () => booleanType,
-  bigint: () => bigIntType,
-  array: () => arrayType,
-  any: () => anyType,
-  addIssueToContext: () => addIssueToContext,
-  ZodVoid: () => ZodVoid,
-  ZodUnknown: () => ZodUnknown,
-  ZodUnion: () => ZodUnion,
-  ZodUndefined: () => ZodUndefined,
-  ZodType: () => ZodType,
-  ZodTuple: () => ZodTuple,
-  ZodTransformer: () => ZodEffects,
-  ZodSymbol: () => ZodSymbol,
-  ZodString: () => ZodString,
-  ZodSet: () => ZodSet,
-  ZodSchema: () => ZodType,
-  ZodRecord: () => ZodRecord,
-  ZodReadonly: () => ZodReadonly,
-  ZodPromise: () => ZodPromise,
-  ZodPipeline: () => ZodPipeline,
-  ZodParsedType: () => ZodParsedType,
-  ZodOptional: () => ZodOptional,
-  ZodObject: () => ZodObject,
-  ZodNumber: () => ZodNumber,
-  ZodNullable: () => ZodNullable,
-  ZodNull: () => ZodNull,
-  ZodNever: () => ZodNever,
-  ZodNativeEnum: () => ZodNativeEnum,
-  ZodNaN: () => ZodNaN,
-  ZodMap: () => ZodMap,
-  ZodLiteral: () => ZodLiteral,
-  ZodLazy: () => ZodLazy,
-  ZodIssueCode: () => ZodIssueCode,
-  ZodIntersection: () => ZodIntersection,
-  ZodFunction: () => ZodFunction,
-  ZodFirstPartyTypeKind: () => ZodFirstPartyTypeKind,
-  ZodError: () => ZodError,
-  ZodEnum: () => ZodEnum,
-  ZodEffects: () => ZodEffects,
-  ZodDiscriminatedUnion: () => ZodDiscriminatedUnion,
-  ZodDefault: () => ZodDefault,
-  ZodDate: () => ZodDate,
-  ZodCatch: () => ZodCatch,
-  ZodBranded: () => ZodBranded,
-  ZodBoolean: () => ZodBoolean,
-  ZodBigInt: () => ZodBigInt,
-  ZodArray: () => ZodArray,
-  ZodAny: () => ZodAny,
-  Schema: () => ZodType,
-  ParseStatus: () => ParseStatus,
-  OK: () => OK,
-  NEVER: () => NEVER,
-  INVALID: () => INVALID,
-  EMPTY_PATH: () => EMPTY_PATH,
-  DIRTY: () => DIRTY,
-  BRAND: () => BRAND
-});
 
 // node_modules/zod/v3/helpers/util.js
 var util;
-(function(util2) {
-  util2.assertEqual = (_) => {};
+(function(util) {
+  util.assertEqual = (_) => {};
   function assertIs(_arg) {}
-  util2.assertIs = assertIs;
+  util.assertIs = assertIs;
   function assertNever(_x) {
     throw new Error;
   }
-  util2.assertNever = assertNever;
-  util2.arrayToEnum = (items) => {
+  util.assertNever = assertNever;
+  util.arrayToEnum = (items) => {
     const obj = {};
     for (const item of items) {
       obj[item] = item;
     }
     return obj;
   };
-  util2.getValidEnumValues = (obj) => {
-    const validKeys = util2.objectKeys(obj).filter((k) => typeof obj[obj[k]] !== "number");
+  util.getValidEnumValues = (obj) => {
+    const validKeys = util.objectKeys(obj).filter((k) => typeof obj[obj[k]] !== "number");
     const filtered = {};
     for (const k of validKeys) {
       filtered[k] = obj[k];
     }
-    return util2.objectValues(filtered);
+    return util.objectValues(filtered);
   };
-  util2.objectValues = (obj) => {
-    return util2.objectKeys(obj).map(function(e) {
+  util.objectValues = (obj) => {
+    return util.objectKeys(obj).map(function(e) {
       return obj[e];
     });
   };
-  util2.objectKeys = typeof Object.keys === "function" ? (obj) => Object.keys(obj) : (object) => {
+  util.objectKeys = typeof Object.keys === "function" ? (obj) => Object.keys(obj) : (object) => {
     const keys = [];
     for (const key in object) {
       if (Object.prototype.hasOwnProperty.call(object, key)) {
@@ -313,19 +1890,19 @@ var util;
     }
     return keys;
   };
-  util2.find = (arr, checker) => {
+  util.find = (arr, checker) => {
     for (const item of arr) {
       if (checker(item))
         return item;
     }
     return;
   };
-  util2.isInteger = typeof Number.isInteger === "function" ? (val) => Number.isInteger(val) : (val) => typeof val === "number" && Number.isFinite(val) && Math.floor(val) === val;
+  util.isInteger = typeof Number.isInteger === "function" ? (val) => Number.isInteger(val) : (val) => typeof val === "number" && Number.isFinite(val) && Math.floor(val) === val;
   function joinValues(array, separator = " | ") {
     return array.map((val) => typeof val === "string" ? `'${val}'` : val).join(separator);
   }
-  util2.joinValues = joinValues;
-  util2.jsonStringifyReplacer = (_, value) => {
+  util.joinValues = joinValues;
+  util.jsonStringifyReplacer = (_, value) => {
     if (typeof value === "bigint") {
       return value.toString();
     }
@@ -333,8 +1910,8 @@ var util;
   };
 })(util || (util = {}));
 var objectUtil;
-(function(objectUtil2) {
-  objectUtil2.mergeShapes = (first, second) => {
+(function(objectUtil) {
+  objectUtil.mergeShapes = (first, second) => {
     return {
       ...first,
       ...second
@@ -424,11 +2001,6 @@ var ZodIssueCode = util.arrayToEnum([
   "not_multiple_of",
   "not_finite"
 ]);
-var quotelessJson = (obj) => {
-  const json = JSON.stringify(obj, null, 2);
-  return json.replace(/"([^"]+)":/g, "$1:");
-};
-
 class ZodError extends Error {
   get errors() {
     return this.issues;
@@ -629,12 +2201,10 @@ var en_default = errorMap;
 
 // node_modules/zod/v3/errors.js
 var overrideErrorMap = en_default;
-function setErrorMap(map) {
-  overrideErrorMap = map;
-}
 function getErrorMap() {
   return overrideErrorMap;
 }
+
 // node_modules/zod/v3/helpers/parseUtil.js
 var makeIssue = (params) => {
   const { data, path, errorMaps, issueData } = params;
@@ -661,7 +2231,6 @@ var makeIssue = (params) => {
     message: errorMessage
   };
 };
-var EMPTY_PATH = [];
 function addIssueToContext(ctx, issueData) {
   const overrideMap = getErrorMap();
   const issue = makeIssue({
@@ -741,11 +2310,12 @@ var isAborted = (x) => x.status === "aborted";
 var isDirty = (x) => x.status === "dirty";
 var isValid = (x) => x.status === "valid";
 var isAsync = (x) => typeof Promise !== "undefined" && x instanceof Promise;
+
 // node_modules/zod/v3/helpers/errorUtil.js
 var errorUtil;
-(function(errorUtil2) {
-  errorUtil2.errToObj = (message) => typeof message === "string" ? { message } : message || {};
-  errorUtil2.toString = (message) => typeof message === "string" ? message : message?.message;
+(function(errorUtil) {
+  errorUtil.errToObj = (message) => typeof message === "string" ? { message } : message || {};
+  errorUtil.toString = (message) => typeof message === "string" ? message : message?.message;
 })(errorUtil || (errorUtil = {}));
 
 // node_modules/zod/v3/types.js
@@ -790,12 +2360,12 @@ var handleResult = (ctx, result) => {
 function processCreateParams(params) {
   if (!params)
     return {};
-  const { errorMap: errorMap2, invalid_type_error, required_error, description } = params;
-  if (errorMap2 && (invalid_type_error || required_error)) {
+  const { errorMap, invalid_type_error, required_error, description } = params;
+  if (errorMap && (invalid_type_error || required_error)) {
     throw new Error(`Can't use "invalid_type_error" or "required_error" in conjunction with custom error map.`);
   }
-  if (errorMap2)
-    return { errorMap: errorMap2, description };
+  if (errorMap)
+    return { errorMap, description };
   const customMap = (iss, ctx) => {
     const { message } = params;
     if (iss.code === "invalid_enum_value") {
@@ -1182,11 +2752,11 @@ class ZodString extends ZodType {
     }
     const parsedType = this._getType(input);
     if (parsedType !== ZodParsedType.string) {
-      const ctx2 = this._getOrReturnCtx(input);
-      addIssueToContext(ctx2, {
+      const ctx = this._getOrReturnCtx(input);
+      addIssueToContext(ctx, {
         code: ZodIssueCode.invalid_type,
         expected: ZodParsedType.string,
-        received: ctx2.parsedType
+        received: ctx.parsedType
       });
       return INVALID;
     }
@@ -1740,11 +3310,11 @@ class ZodNumber extends ZodType {
     }
     const parsedType = this._getType(input);
     if (parsedType !== ZodParsedType.number) {
-      const ctx2 = this._getOrReturnCtx(input);
-      addIssueToContext(ctx2, {
+      const ctx = this._getOrReturnCtx(input);
+      addIssueToContext(ctx, {
         code: ZodIssueCode.invalid_type,
         expected: ZodParsedType.number,
-        received: ctx2.parsedType
+        received: ctx.parsedType
       });
       return INVALID;
     }
@@ -2166,17 +3736,17 @@ class ZodDate extends ZodType {
     }
     const parsedType = this._getType(input);
     if (parsedType !== ZodParsedType.date) {
-      const ctx2 = this._getOrReturnCtx(input);
-      addIssueToContext(ctx2, {
+      const ctx = this._getOrReturnCtx(input);
+      addIssueToContext(ctx, {
         code: ZodIssueCode.invalid_type,
         expected: ZodParsedType.date,
-        received: ctx2.parsedType
+        received: ctx.parsedType
       });
       return INVALID;
     }
     if (Number.isNaN(input.data.getTime())) {
-      const ctx2 = this._getOrReturnCtx(input);
-      addIssueToContext(ctx2, {
+      const ctx = this._getOrReturnCtx(input);
+      addIssueToContext(ctx, {
         code: ZodIssueCode.invalid_date
       });
       return INVALID;
@@ -2464,8 +4034,8 @@ class ZodArray extends ZodType {
     if (ctx.common.async) {
       return Promise.all([...ctx.data].map((item, i) => {
         return def.type._parseAsync(new ParseInputLazyPath(ctx, item, ctx.path, i));
-      })).then((result2) => {
-        return ParseStatus.mergeArray(status, result2);
+      })).then((result) => {
+        return ParseStatus.mergeArray(status, result);
       });
     }
     const result = [...ctx.data].map((item, i) => {
@@ -2553,11 +4123,11 @@ class ZodObject extends ZodType {
   _parse(input) {
     const parsedType = this._getType(input);
     if (parsedType !== ZodParsedType.object) {
-      const ctx2 = this._getOrReturnCtx(input);
-      addIssueToContext(ctx2, {
+      const ctx = this._getOrReturnCtx(input);
+      addIssueToContext(ctx, {
         code: ZodIssueCode.invalid_type,
         expected: ZodParsedType.object,
-        received: ctx2.parsedType
+        received: ctx.parsedType
       });
       return INVALID;
     }
@@ -2861,7 +4431,7 @@ class ZodUnion extends ZodType {
         ctx.common.issues.push(...dirty.ctx.common.issues);
         return dirty.result;
       }
-      const unionErrors = issues.map((issues2) => new ZodError(issues2));
+      const unionErrors = issues.map((issues) => new ZodError(issues));
       addIssueToContext(ctx, {
         code: ZodIssueCode.invalid_union,
         unionErrors
@@ -3301,9 +4871,9 @@ class ZodSet extends ZodType {
       }
     }
     const valueType = this._def.valueType;
-    function finalizeSet(elements2) {
+    function finalizeSet(elements) {
       const parsedSet = new Set;
-      for (const element of elements2) {
+      for (const element of elements) {
         if (element.status === "aborted")
           return INVALID;
         if (element.status === "dirty")
@@ -3314,7 +4884,7 @@ class ZodSet extends ZodType {
     }
     const elements = [...ctx.data.values()].map((item, i) => valueType._parse(new ParseInputLazyPath(ctx, item, ctx.path, i)));
     if (ctx.common.async) {
-      return Promise.all(elements).then((elements2) => finalizeSet(elements2));
+      return Promise.all(elements).then((elements) => finalizeSet(elements));
     } else {
       return finalizeSet(elements);
     }
@@ -3667,11 +5237,11 @@ class ZodEffects extends ZodType {
     if (effect.type === "preprocess") {
       const processed = effect.transform(ctx.data, checkCtx);
       if (ctx.common.async) {
-        return Promise.resolve(processed).then(async (processed2) => {
+        return Promise.resolve(processed).then(async (processed) => {
           if (status.value === "aborted")
             return INVALID;
           const result = await this._def.schema._parseAsync({
-            data: processed2,
+            data: processed,
             path: ctx.path,
             parent: ctx
           });
@@ -3863,10 +5433,10 @@ class ZodCatch extends ZodType {
       }
     });
     if (isAsync(result)) {
-      return result.then((result2) => {
+      return result.then((result) => {
         return {
           status: "valid",
-          value: result2.status === "valid" ? result2.value : this._def.catchValue({
+          value: result.status === "valid" ? result.value : this._def.catchValue({
             get error() {
               return new ZodError(newCtx.common.issues);
             },
@@ -4015,78 +5585,48 @@ ZodReadonly.create = (type, params) => {
     ...processCreateParams(params)
   });
 };
-function cleanParams(params, data) {
-  const p = typeof params === "function" ? params(data) : typeof params === "string" ? { message: params } : params;
-  const p2 = typeof p === "string" ? { message: p } : p;
-  return p2;
-}
-function custom(check, _params = {}, fatal) {
-  if (check)
-    return ZodAny.create().superRefine((data, ctx) => {
-      const r = check(data);
-      if (r instanceof Promise) {
-        return r.then((r2) => {
-          if (!r2) {
-            const params = cleanParams(_params, data);
-            const _fatal = params.fatal ?? fatal ?? true;
-            ctx.addIssue({ code: "custom", ...params, fatal: _fatal });
-          }
-        });
-      }
-      if (!r) {
-        const params = cleanParams(_params, data);
-        const _fatal = params.fatal ?? fatal ?? true;
-        ctx.addIssue({ code: "custom", ...params, fatal: _fatal });
-      }
-      return;
-    });
-  return ZodAny.create();
-}
 var late = {
   object: ZodObject.lazycreate
 };
 var ZodFirstPartyTypeKind;
-(function(ZodFirstPartyTypeKind2) {
-  ZodFirstPartyTypeKind2["ZodString"] = "ZodString";
-  ZodFirstPartyTypeKind2["ZodNumber"] = "ZodNumber";
-  ZodFirstPartyTypeKind2["ZodNaN"] = "ZodNaN";
-  ZodFirstPartyTypeKind2["ZodBigInt"] = "ZodBigInt";
-  ZodFirstPartyTypeKind2["ZodBoolean"] = "ZodBoolean";
-  ZodFirstPartyTypeKind2["ZodDate"] = "ZodDate";
-  ZodFirstPartyTypeKind2["ZodSymbol"] = "ZodSymbol";
-  ZodFirstPartyTypeKind2["ZodUndefined"] = "ZodUndefined";
-  ZodFirstPartyTypeKind2["ZodNull"] = "ZodNull";
-  ZodFirstPartyTypeKind2["ZodAny"] = "ZodAny";
-  ZodFirstPartyTypeKind2["ZodUnknown"] = "ZodUnknown";
-  ZodFirstPartyTypeKind2["ZodNever"] = "ZodNever";
-  ZodFirstPartyTypeKind2["ZodVoid"] = "ZodVoid";
-  ZodFirstPartyTypeKind2["ZodArray"] = "ZodArray";
-  ZodFirstPartyTypeKind2["ZodObject"] = "ZodObject";
-  ZodFirstPartyTypeKind2["ZodUnion"] = "ZodUnion";
-  ZodFirstPartyTypeKind2["ZodDiscriminatedUnion"] = "ZodDiscriminatedUnion";
-  ZodFirstPartyTypeKind2["ZodIntersection"] = "ZodIntersection";
-  ZodFirstPartyTypeKind2["ZodTuple"] = "ZodTuple";
-  ZodFirstPartyTypeKind2["ZodRecord"] = "ZodRecord";
-  ZodFirstPartyTypeKind2["ZodMap"] = "ZodMap";
-  ZodFirstPartyTypeKind2["ZodSet"] = "ZodSet";
-  ZodFirstPartyTypeKind2["ZodFunction"] = "ZodFunction";
-  ZodFirstPartyTypeKind2["ZodLazy"] = "ZodLazy";
-  ZodFirstPartyTypeKind2["ZodLiteral"] = "ZodLiteral";
-  ZodFirstPartyTypeKind2["ZodEnum"] = "ZodEnum";
-  ZodFirstPartyTypeKind2["ZodEffects"] = "ZodEffects";
-  ZodFirstPartyTypeKind2["ZodNativeEnum"] = "ZodNativeEnum";
-  ZodFirstPartyTypeKind2["ZodOptional"] = "ZodOptional";
-  ZodFirstPartyTypeKind2["ZodNullable"] = "ZodNullable";
-  ZodFirstPartyTypeKind2["ZodDefault"] = "ZodDefault";
-  ZodFirstPartyTypeKind2["ZodCatch"] = "ZodCatch";
-  ZodFirstPartyTypeKind2["ZodPromise"] = "ZodPromise";
-  ZodFirstPartyTypeKind2["ZodBranded"] = "ZodBranded";
-  ZodFirstPartyTypeKind2["ZodPipeline"] = "ZodPipeline";
-  ZodFirstPartyTypeKind2["ZodReadonly"] = "ZodReadonly";
+(function(ZodFirstPartyTypeKind) {
+  ZodFirstPartyTypeKind["ZodString"] = "ZodString";
+  ZodFirstPartyTypeKind["ZodNumber"] = "ZodNumber";
+  ZodFirstPartyTypeKind["ZodNaN"] = "ZodNaN";
+  ZodFirstPartyTypeKind["ZodBigInt"] = "ZodBigInt";
+  ZodFirstPartyTypeKind["ZodBoolean"] = "ZodBoolean";
+  ZodFirstPartyTypeKind["ZodDate"] = "ZodDate";
+  ZodFirstPartyTypeKind["ZodSymbol"] = "ZodSymbol";
+  ZodFirstPartyTypeKind["ZodUndefined"] = "ZodUndefined";
+  ZodFirstPartyTypeKind["ZodNull"] = "ZodNull";
+  ZodFirstPartyTypeKind["ZodAny"] = "ZodAny";
+  ZodFirstPartyTypeKind["ZodUnknown"] = "ZodUnknown";
+  ZodFirstPartyTypeKind["ZodNever"] = "ZodNever";
+  ZodFirstPartyTypeKind["ZodVoid"] = "ZodVoid";
+  ZodFirstPartyTypeKind["ZodArray"] = "ZodArray";
+  ZodFirstPartyTypeKind["ZodObject"] = "ZodObject";
+  ZodFirstPartyTypeKind["ZodUnion"] = "ZodUnion";
+  ZodFirstPartyTypeKind["ZodDiscriminatedUnion"] = "ZodDiscriminatedUnion";
+  ZodFirstPartyTypeKind["ZodIntersection"] = "ZodIntersection";
+  ZodFirstPartyTypeKind["ZodTuple"] = "ZodTuple";
+  ZodFirstPartyTypeKind["ZodRecord"] = "ZodRecord";
+  ZodFirstPartyTypeKind["ZodMap"] = "ZodMap";
+  ZodFirstPartyTypeKind["ZodSet"] = "ZodSet";
+  ZodFirstPartyTypeKind["ZodFunction"] = "ZodFunction";
+  ZodFirstPartyTypeKind["ZodLazy"] = "ZodLazy";
+  ZodFirstPartyTypeKind["ZodLiteral"] = "ZodLiteral";
+  ZodFirstPartyTypeKind["ZodEnum"] = "ZodEnum";
+  ZodFirstPartyTypeKind["ZodEffects"] = "ZodEffects";
+  ZodFirstPartyTypeKind["ZodNativeEnum"] = "ZodNativeEnum";
+  ZodFirstPartyTypeKind["ZodOptional"] = "ZodOptional";
+  ZodFirstPartyTypeKind["ZodNullable"] = "ZodNullable";
+  ZodFirstPartyTypeKind["ZodDefault"] = "ZodDefault";
+  ZodFirstPartyTypeKind["ZodCatch"] = "ZodCatch";
+  ZodFirstPartyTypeKind["ZodPromise"] = "ZodPromise";
+  ZodFirstPartyTypeKind["ZodBranded"] = "ZodBranded";
+  ZodFirstPartyTypeKind["ZodPipeline"] = "ZodPipeline";
+  ZodFirstPartyTypeKind["ZodReadonly"] = "ZodReadonly";
 })(ZodFirstPartyTypeKind || (ZodFirstPartyTypeKind = {}));
-var instanceOfType = (cls, params = {
-  message: `Input not instance of ${cls.name}`
-}) => custom((data) => data instanceof cls, params);
 var stringType = ZodString.create;
 var numberType = ZodNumber.create;
 var nanType = ZodNaN.create;
@@ -4121,41 +5661,84 @@ var optionalType = ZodOptional.create;
 var nullableType = ZodNullable.create;
 var preprocessType = ZodEffects.createWithPreprocess;
 var pipelineType = ZodPipeline.create;
-var ostring = () => stringType().optional();
-var onumber = () => numberType().optional();
-var oboolean = () => booleanType().optional();
-var coerce = {
-  string: (arg) => ZodString.create({ ...arg, coerce: true }),
-  number: (arg) => ZodNumber.create({ ...arg, coerce: true }),
-  boolean: (arg) => ZodBoolean.create({
-    ...arg,
-    coerce: true
-  }),
-  bigint: (arg) => ZodBigInt.create({ ...arg, coerce: true }),
-  date: (arg) => ZodDate.create({ ...arg, coerce: true })
-};
-var NEVER = INVALID;
 // src/schemas.ts
-var audibleRawItemSchema = exports_external.object({
-  asin: exports_external.string().min(1),
-  title: exports_external.string().min(1),
-  authors: exports_external.array(exports_external.object({ name: exports_external.string() })).default([]),
-  narrators: exports_external.array(exports_external.object({ name: exports_external.string() })).default([]),
-  runtime_length_min: exports_external.number().nonnegative().default(0),
-  publisher_name: exports_external.string().nullish().transform((v) => v ?? undefined),
-  language: exports_external.string().nullish().transform((v) => v ?? undefined),
-  release_date: exports_external.string().nullish().transform((v) => v ?? undefined),
-  product_images: exports_external.record(exports_external.string(), exports_external.string()).nullish().transform((v) => v ?? undefined),
-  series: exports_external.array(exports_external.object({
-    asin: exports_external.string(),
-    title: exports_external.string(),
-    sequence: exports_external.string().nullish().transform((v) => v ?? undefined)
+var nullToUndefined = (v) => v ?? undefined;
+var optionalString = stringType().nullish().transform(nullToUndefined);
+var ratingDistributionSchema = objectType({
+  average_rating: numberType(),
+  display_average_rating: stringType().default("0"),
+  display_stars: numberType().default(0),
+  num_ratings: numberType(),
+  num_five_star_ratings: numberType().default(0),
+  num_four_star_ratings: numberType().default(0),
+  num_three_star_ratings: numberType().default(0),
+  num_two_star_ratings: numberType().default(0),
+  num_one_star_ratings: numberType().default(0)
+});
+var audibleRatingSchema = objectType({
+  num_reviews: numberType().default(0),
+  overall_distribution: ratingDistributionSchema.nullish(),
+  performance_distribution: ratingDistributionSchema.nullish(),
+  story_distribution: ratingDistributionSchema.nullish()
+}).nullish();
+var categoryLadderSchema = objectType({
+  root: stringType().default("Genres"),
+  ladder: arrayType(objectType({
+    id: stringType(),
+    name: stringType()
+  })).default([])
+});
+var relationshipSchema = objectType({
+  asin: stringType(),
+  relationship_to_product: optionalString,
+  relationship_type: optionalString,
+  title: optionalString,
+  sort: optionalString,
+  url: optionalString
+});
+var audibleRawItemSchema = objectType({
+  asin: stringType().min(1),
+  title: stringType().min(1),
+  subtitle: optionalString,
+  isbn: optionalString,
+  sku: optionalString,
+  authors: arrayType(objectType({ name: stringType() })).default([]),
+  narrators: arrayType(objectType({ name: stringType() })).default([]),
+  runtime_length_min: numberType().nonnegative().default(0),
+  publisher_name: optionalString,
+  language: optionalString,
+  release_date: optionalString,
+  publisher_summary: optionalString,
+  extended_product_description: optionalString,
+  merchandising_summary: optionalString,
+  copyright: optionalString,
+  format_type: optionalString,
+  content_type: optionalString,
+  content_delivery_type: optionalString,
+  program_participation: optionalString,
+  product_images: recordType(stringType(), stringType()).nullish().transform((v) => v ?? {}),
+  social_media_images: recordType(stringType(), stringType()).nullish().transform((v) => v ?? {}),
+  series: arrayType(objectType({
+    asin: stringType(),
+    title: stringType(),
+    sequence: optionalString
   })).nullish().transform((v) => v ?? []),
-  listening_status: exports_external.object({
-    is_finished: exports_external.boolean().optional(),
-    percent_complete: exports_external.number().optional(),
-    finished_at_timestamp: exports_external.string().nullish()
-  }).nullish().transform((v) => v ?? undefined)
+  category_ladders: arrayType(categoryLadderSchema).nullish().transform((v) => v ?? []),
+  platinum_keywords: arrayType(stringType()).nullish().transform((v) => v ?? []),
+  thesaurus_subject_keywords: arrayType(stringType()).nullish().transform((v) => v ?? []),
+  rating: audibleRatingSchema,
+  listening_status: objectType({
+    is_finished: booleanType().optional(),
+    percent_complete: numberType().optional(),
+    finished_at_timestamp: stringType().nullish(),
+    time_remaining_seconds: numberType().optional()
+  }).nullish().transform(nullToUndefined),
+  purchase_date: optionalString,
+  library_status: objectType({
+    date_added: stringType().nullish()
+  }).nullish().transform(nullToUndefined),
+  relationships: arrayType(relationshipSchema).nullish().transform((v) => v ?? []),
+  is_adult_product: booleanType().nullish().transform((v) => v ?? false)
 });
 
 // src/signing.ts
@@ -4177,73 +5760,161 @@ ${credentials.adpToken}`;
   };
 };
 
-// src/library.ts
-var RESPONSE_GROUPS = "product_details,contributors,media,product_attrs,listening_status";
+// src/fetch.ts
+var PAGE_SIZE = 50;
+var REFRESH_BUFFER_MS = 5 * 60 * 1000;
+var ensureFresh = async (credentials) => credentials.expiresAt.getTime() - Date.now() < REFRESH_BUFFER_MS ? refresh(credentials) : credentials;
 var audibleFetch = async (path, credentials, query) => {
-  const config = AUDIBLE_LOCALES[credentials.locale];
+  const fresh = await ensureFresh(credentials);
+  const config = AUDIBLE_LOCALES[fresh.locale];
   const fullPath = `/1.0${path}`;
   const queryString = query ? `?${Object.entries(query).map(([k, v]) => `${k}=${v}`).join("&")}` : "";
   const signPath = `${fullPath}${queryString}`;
-  const headers = signRequest("GET", signPath, "", credentials);
-  const url = new URL(`https://api.audible.${config.domain}${fullPath}`);
-  if (query) {
-    for (const [k, v] of Object.entries(query)) {
-      url.searchParams.set(k, v);
-    }
-  }
-  const response = await fetch(url.toString(), { headers });
+  const headers = signRequest("GET", signPath, "", fresh);
+  const fetchUrl = `https://api.audible.${config.domain}${fullPath}${queryString}`;
+  const response = await fetch(fetchUrl, { headers });
   if (!response.ok) {
     throw new Error(`Audible API error: ${response.status} ${response.statusText} (${path})`);
   }
-  return await response.json();
+  return { data: await response.json(), credentials: fresh };
 };
-var parseItems = (items) => items.map((raw) => {
-  const item = audibleRawItemSchema.parse(raw);
-  return {
-    asin: item.asin,
-    title: item.title,
-    authors: item.authors.map(({ name }) => name),
-    narrators: item.narrators.map(({ name }) => name),
-    durationMinutes: item.runtime_length_min,
-    publisher: item.publisher_name,
-    language: item.language,
-    releaseDate: item.release_date ? new Date(item.release_date) : undefined,
-    coverUrl: item.product_images?.["500"] ?? item.product_images?.["252"],
-    series: item.series[0] ? {
-      name: item.series[0].title,
-      position: item.series[0].sequence ? Number(item.series[0].sequence) : undefined
-    } : undefined,
-    finishedAt: item.listening_status?.finished_at_timestamp ? new Date(item.listening_status.finished_at_timestamp) : undefined
-  };
+var extractItems = (response) => Array.isArray(response.items) ? response.items : Array.isArray(response.products) ? response.products : [];
+var toRatingDistribution = (dist) => ({
+  averageRating: dist.average_rating,
+  displayAverageRating: dist.display_average_rating,
+  displayStars: dist.display_stars,
+  numRatings: dist.num_ratings,
+  numFiveStarRatings: dist.num_five_star_ratings,
+  numFourStarRatings: dist.num_four_star_ratings,
+  numThreeStarRatings: dist.num_three_star_ratings,
+  numTwoStarRatings: dist.num_two_star_ratings,
+  numOneStarRatings: dist.num_one_star_ratings
 });
-var extractItems = (response) => {
-  if (Array.isArray(response.items))
-    return response.items;
-  if (Array.isArray(response.products))
-    return response.products;
-  return [];
+var toRating = (raw) => raw ? {
+  numReviews: raw.num_reviews,
+  overallDistribution: raw.overall_distribution ? toRatingDistribution(raw.overall_distribution) : undefined,
+  performanceDistribution: raw.performance_distribution ? toRatingDistribution(raw.performance_distribution) : undefined,
+  storyDistribution: raw.story_distribution ? toRatingDistribution(raw.story_distribution) : undefined
+} : undefined;
+var toAudibleItem = (item) => ({
+  asin: item.asin,
+  title: item.title,
+  subtitle: item.subtitle,
+  isbn: item.isbn,
+  sku: item.sku,
+  authors: item.authors.map(({ name }) => name),
+  narrators: item.narrators.map(({ name }) => name),
+  durationMinutes: item.runtime_length_min,
+  publisher: item.publisher_name,
+  language: item.language,
+  releaseDate: item.release_date ? new Date(item.release_date) : undefined,
+  coverUrl: item.product_images["500"] ?? item.product_images["252"],
+  summary: item.publisher_summary,
+  description: item.extended_product_description,
+  merchandisingSummary: item.merchandising_summary,
+  copyright: item.copyright,
+  formatType: item.format_type,
+  contentType: item.content_type,
+  contentDeliveryType: item.content_delivery_type,
+  programParticipation: item.program_participation,
+  series: item.series[0] ? {
+    name: item.series[0].title,
+    position: item.series[0].sequence ? Number(item.series[0].sequence) : undefined
+  } : undefined,
+  categories: item.category_ladders.map((ladder) => ({
+    root: ladder.root,
+    categories: ladder.ladder.map(({ id, name }) => ({ id, name }))
+  })),
+  keywords: [...item.platinum_keywords, ...item.thesaurus_subject_keywords],
+  rating: toRating(item.rating),
+  listeningStatus: item.listening_status ? {
+    finishedAt: item.listening_status.finished_at_timestamp ? new Date(item.listening_status.finished_at_timestamp) : undefined,
+    isFinished: item.listening_status.is_finished,
+    percentComplete: item.listening_status.percent_complete,
+    timeRemainingSeconds: item.listening_status.time_remaining_seconds
+  } : undefined,
+  purchaseDate: item.purchase_date ? new Date(item.purchase_date) : undefined,
+  dateAdded: item.library_status?.date_added ? new Date(item.library_status.date_added) : undefined,
+  relationships: item.relationships.map((rel) => ({
+    asin: rel.asin,
+    relationshipToProduct: rel.relationship_to_product ?? "",
+    relationshipType: rel.relationship_type ?? "",
+    title: rel.title,
+    sort: rel.sort,
+    url: rel.url
+  })),
+  isAdultProduct: item.is_adult_product,
+  productImages: item.product_images,
+  socialMediaImages: item.social_media_images
+});
+var parseItems = (items) => items.map((raw) => toAudibleItem(audibleRawItemSchema.parse(raw)));
+var fetchAllPages = async (path, credentials, responseGroups, accumulated = [], page = 1) => {
+  const { data: response, credentials: fresh } = await audibleFetch(path, credentials, {
+    response_groups: responseGroups,
+    num_results: String(PAGE_SIZE),
+    page: String(page)
+  });
+  const rawItems = extractItems(response);
+  const items = [...accumulated, ...parseItems(rawItems)];
+  return rawItems.length < PAGE_SIZE ? { items, credentials: fresh } : fetchAllPages(path, fresh, responseGroups, items, page + 1);
 };
-var fetchPaginated = async (path, credentials) => {
-  const allItems = [];
-  const pageSize = 50;
-  let page = 1;
-  while (true) {
-    const response = await audibleFetch(path, credentials, {
-      response_groups: RESPONSE_GROUPS,
-      num_results: String(pageSize),
-      page: String(page)
-    });
-    const rawItems = extractItems(response);
-    allItems.push(...parseItems(rawItems));
-    if (rawItems.length < pageSize)
-      break;
-    page += 1;
+
+// src/catalog.ts
+var CATALOG_RESPONSE_GROUPS = "product_details,contributors,media,product_attrs,rating,category_ladders,series,product_desc,product_extended_attrs,relationships";
+var PAGE_SIZE2 = 50;
+var extractItems2 = (response) => Array.isArray(response.products) ? response.products : Array.isArray(response.items) ? response.items : [];
+var parseResponse = (response) => extractItems2(response).map((raw) => toAudibleItem(audibleRawItemSchema.parse(raw)));
+var fetchCatalogPages = async (credentials, categoryId, options, maxPages, accumulated = [], page = 1) => {
+  const { data: response, credentials: fresh } = await audibleFetch("/catalog/products", credentials, {
+    category_id: categoryId,
+    products_sort_by: "Relevance",
+    num_results: String(PAGE_SIZE2),
+    page: String(page),
+    response_groups: CATALOG_RESPONSE_GROUPS,
+    ...options.keywords ? { keywords: options.keywords } : {},
+    ...options.author ? { author: options.author } : {},
+    ...options.narrator ? { narrator: options.narrator } : {}
+  });
+  const rawItems = extractItems2(response);
+  const items = [...accumulated, ...parseResponse(response)];
+  return rawItems.length < PAGE_SIZE2 || page >= maxPages ? { items, credentials: fresh } : fetchCatalogPages(fresh, categoryId, options, maxPages, items, page + 1);
+};
+var catalog = async (credentials, options) => {
+  const categoryId = options.category ? resolveGenreId(options.category, credentials.locale) : options.categoryId;
+  if (!categoryId) {
+    throw new Error('Either "category" or "categoryId" must be provided');
+  }
+  const sortBy = options.sortBy ?? "Relevance";
+  const limit = options.limit ?? 50;
+  if (sortBy === "MostVoted") {
+    const MAX_PAGES = 20;
+    const { items: allItems, credentials: fresh } = await fetchCatalogPages(credentials, categoryId, options, MAX_PAGES);
+    const sorted = orderBy_default(uniqBy_default(allItems, ({ asin }) => asin), [
+      ({ rating }) => rating?.overallDistribution?.numRatings ?? 0,
+      ({ rating }) => rating?.overallDistribution?.averageRating ?? 0
+    ], ["desc", "desc"]);
+    return {
+      items: limit === "all" ? sorted : sorted.slice(0, limit),
+      credentials: fresh
+    };
   }
-  return { items: allItems, credentials };
+  const { data: response, credentials: fresh } = await audibleFetch("/catalog/products", credentials, {
+    category_id: categoryId,
+    products_sort_by: sortBy,
+    num_results: String(limit === "all" ? PAGE_SIZE2 : Math.min(limit, PAGE_SIZE2)),
+    page: "1",
+    response_groups: CATALOG_RESPONSE_GROUPS,
+    ...options.keywords ? { keywords: options.keywords } : {},
+    ...options.author ? { author: options.author } : {},
+    ...options.narrator ? { narrator: options.narrator } : {}
+  });
+  return { items: parseResponse(response), credentials: fresh };
 };
-var fetchLibrary = async (credentials) => fetchPaginated("/library", credentials);
-var fetchWishlist = async (credentials) => fetchPaginated("/wishlist", credentials);
-var verifyConnection = async (credentials) => {
+// src/library.ts
+var RESPONSE_GROUPS = "product_details,contributors,media,product_attrs,listening_status,series,rating,category_ladders,product_desc,product_extended_attrs,relationships";
+var library = async (credentials) => fetchAllPages("/library", credentials, RESPONSE_GROUPS);
+var wishlist = async (credentials) => fetchAllPages("/wishlist", credentials, RESPONSE_GROUPS);
+var verify = async (credentials) => {
   await audibleFetch("/library", credentials, {
     num_results: "1",
     page: "1",
@@ -4251,11 +5922,14 @@ var verifyConnection = async (credentials) => {
   });
 };
 export {
-  verifyConnection,
-  registerDevice,
-  refreshAccessToken,
-  generateLoginUrl,
-  fetchWishlist,
-  fetchLibrary,
-  AUDIBLE_LOCALES
+  AUDIBLE_LOCALES,
+  GENRE_CATEGORIES,
+  catalog,
+  library,
+  login,
+  refresh,
+  register,
+  resolveGenreId,
+  verify,
+  wishlist
 };