audible-api-ts 0.2.0 → 0.4.0

package/dist/index.js

@@ -12,19 +12,31 @@ var __export = (target, all) => {
       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);
+// node_modules/lodash-es/_baseSlice.js
+function baseSlice(array, start, end) {
+  var index = -1, length = array.length;
+  if (start < 0) {
+    start = -start > length ? 0 : length + start;
+  }
+  end = end > length ? length : end;
+  if (end < 0) {
+    end += length;
+  }
+  length = start > end ? 0 : end - start >>> 0;
+  start >>>= 0;
+  var result = Array(length);
   while (++index < length) {
-    result[index] = iteratee(array[index], index, array);
+    result[index] = array[index + start];
   }
   return result;
 }
-var _arrayMap_default = arrayMap;
+var _baseSlice_default = baseSlice;
 
-// node_modules/lodash-es/isArray.js
-var isArray = Array.isArray;
-var isArray_default = isArray;
+// 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/_freeGlobal.js
 var freeGlobal = typeof global == "object" && global && global.Object === Object && global;
@@ -82,6 +94,79 @@ function baseGetTag(value) {
 }
 var _baseGetTag_default = baseGetTag;
 
+// 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/isLength.js
+var MAX_SAFE_INTEGER = 9007199254740991;
+function isLength(value) {
+  return typeof value == "number" && value > -1 && value % 1 == 0 && value <= MAX_SAFE_INTEGER;
+}
+var isLength_default = isLength;
+
+// 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/_isIndex.js
+var MAX_SAFE_INTEGER2 = 9007199254740991;
+var reIsUint = /^(?:0|[1-9]\d*)$/;
+function isIndex(value, length) {
+  var type = typeof value;
+  length = length == null ? MAX_SAFE_INTEGER2 : 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/_isIterateeCall.js
+function isIterateeCall(value, index, object) {
+  if (!isObject_default(object)) {
+    return false;
+  }
+  var type = typeof index;
+  if (type == "number" ? isArrayLike_default(object) && _isIndex_default(index, object.length) : type == "string" && (index in object)) {
+    return eq_default(object[index], value);
+  }
+  return false;
+}
+var _isIterateeCall_default = isIterateeCall;
+
+// node_modules/lodash-es/_trimmedEndIndex.js
+var reWhitespace = /\s/;
+function trimmedEndIndex(string) {
+  var index = string.length;
+  while (index-- && reWhitespace.test(string.charAt(index))) {}
+  return index;
+}
+var _trimmedEndIndex_default = trimmedEndIndex;
+
+// node_modules/lodash-es/_baseTrim.js
+var reTrimStart = /^\s+/;
+function baseTrim(string) {
+  return string ? string.slice(0, _trimmedEndIndex_default(string) + 1).replace(reTrimStart, "") : string;
+}
+var _baseTrim_default = baseTrim;
+
 // node_modules/lodash-es/isObjectLike.js
 function isObjectLike(value) {
   return value != null && typeof value == "object";
@@ -95,6 +180,89 @@ function isSymbol(value) {
 }
 var isSymbol_default = isSymbol;
 
+// node_modules/lodash-es/toNumber.js
+var NAN = 0 / 0;
+var reIsBadHex = /^[-+]0x[0-9a-f]+$/i;
+var reIsBinary = /^0b[01]+$/i;
+var reIsOctal = /^0o[0-7]+$/i;
+var freeParseInt = parseInt;
+function toNumber(value) {
+  if (typeof value == "number") {
+    return value;
+  }
+  if (isSymbol_default(value)) {
+    return NAN;
+  }
+  if (isObject_default(value)) {
+    var other = typeof value.valueOf == "function" ? value.valueOf() : value;
+    value = isObject_default(other) ? other + "" : other;
+  }
+  if (typeof value != "string") {
+    return value === 0 ? value : +value;
+  }
+  value = _baseTrim_default(value);
+  var isBinary = reIsBinary.test(value);
+  return isBinary || reIsOctal.test(value) ? freeParseInt(value.slice(2), isBinary ? 2 : 8) : reIsBadHex.test(value) ? NAN : +value;
+}
+var toNumber_default = toNumber;
+
+// node_modules/lodash-es/toFinite.js
+var INFINITY = 1 / 0;
+var MAX_INTEGER = 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000;
+function toFinite(value) {
+  if (!value) {
+    return value === 0 ? value : 0;
+  }
+  value = toNumber_default(value);
+  if (value === INFINITY || value === -INFINITY) {
+    var sign = value < 0 ? -1 : 1;
+    return sign * MAX_INTEGER;
+  }
+  return value === value ? value : 0;
+}
+var toFinite_default = toFinite;
+
+// node_modules/lodash-es/toInteger.js
+function toInteger(value) {
+  var result = toFinite_default(value), remainder = result % 1;
+  return result === result ? remainder ? result - remainder : result : 0;
+}
+var toInteger_default = toInteger;
+
+// node_modules/lodash-es/chunk.js
+var nativeCeil = Math.ceil;
+var nativeMax = Math.max;
+function chunk(array, size, guard) {
+  if (guard ? _isIterateeCall_default(array, size, guard) : size === undefined) {
+    size = 1;
+  } else {
+    size = nativeMax(toInteger_default(size), 0);
+  }
+  var length = array == null ? 0 : array.length;
+  if (!length || size < 1) {
+    return [];
+  }
+  var index = 0, resIndex = 0, result = Array(nativeCeil(length / size));
+  while (index < length) {
+    result[resIndex++] = _baseSlice_default(array, index, index += size);
+  }
+  return result;
+}
+var chunk_default = chunk;
+// 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/_isKey.js
 var reIsDeepProp = /\.|\[(?:[^[\]]*|(["'])(?:(?!\1)[^\\]|\\.)*?\1)\]/;
 var reIsPlainProp = /^\w*$/;
@@ -110,27 +278,6 @@ function isKey(value, 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;
@@ -266,12 +413,6 @@ function listCacheClear() {
 }
 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;
@@ -470,7 +611,7 @@ var stringToPath = _memoizeCapped_default(function(string) {
 var _stringToPath_default = stringToPath;
 
 // node_modules/lodash-es/_baseToString.js
-var INFINITY = 1 / 0;
+var INFINITY2 = 1 / 0;
 var symbolProto = _Symbol_default ? _Symbol_default.prototype : undefined;
 var symbolToString = symbolProto ? symbolProto.toString : undefined;
 function baseToString(value) {
@@ -484,7 +625,7 @@ function baseToString(value) {
     return symbolToString ? symbolToString.call(value) : "";
   }
   var result = value + "";
-  return result == "0" && 1 / value == -INFINITY ? "-0" : result;
+  return result == "0" && 1 / value == -INFINITY2 ? "-0" : result;
 }
 var _baseToString_default = baseToString;
 
@@ -504,13 +645,13 @@ function castPath(value, object) {
 var _castPath_default = castPath;
 
 // node_modules/lodash-es/_toKey.js
-var INFINITY2 = 1 / 0;
+var INFINITY3 = 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;
+  return result == "0" && 1 / value == -INFINITY3 ? "-0" : result;
 }
 var _toKey_default = toKey;
 
@@ -656,8 +797,8 @@ function equalArrays(array, other, bitmask, customizer, equalFunc, stack) {
       break;
     }
     if (seen) {
-      if (!_arraySome_default(other, function(othValue2, othIndex) {
-        if (!_cacheHas_default(seen, othIndex) && (arrValue === othValue2 || equalFunc(arrValue, othValue2, bitmask, customizer, stack))) {
+      if (!_arraySome_default(other, function(othValue, othIndex) {
+        if (!_cacheHas_default(seen, othIndex) && (arrValue === othValue || equalFunc(arrValue, othValue, bitmask, customizer, stack))) {
           return seen.push(othIndex);
         }
       })) {
@@ -863,23 +1004,6 @@ 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]";
@@ -997,12 +1121,6 @@ function baseKeys(object) {
 }
 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);
@@ -1389,8 +1507,8 @@ 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, collection2) {
-    result[++index] = iteratee(value, key, collection2);
+  _baseEach_default(collection, function(value, key, collection) {
+    result[++index] = iteratee(value, key, collection);
   });
   return result;
 }
@@ -1456,7 +1574,7 @@ function baseOrderBy(collection, iteratees, orders) {
   }
   var index = -1;
   iteratees = _arrayMap_default(iteratees, _baseUnary_default(_baseIteratee_default));
-  var result = _baseMap_default(collection, function(value, key, collection2) {
+  var result = _baseMap_default(collection, function(value, key, collection) {
     var criteria = _arrayMap_default(iteratees, function(iteratee) {
       return iteratee(value);
     });
@@ -1543,8 +1661,8 @@ 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) {
+var INFINITY4 = 1 / 0;
+var createSet = !(_Set_default && 1 / _setToArray_default(new _Set_default([, -0]))[1] == INFINITY4) ? noop_default : function(values) {
   return new _Set_default(values);
 };
 var _createSet_default = createSet;
@@ -1603,78 +1721,91 @@ var GENRE_CATEGORIES = {
   "science-fiction": { fr: "21229020031", com: "18580628011" },
   fantasy: { fr: "21229021031", com: "18580607011" },
   "science-fiction-fantasy": { fr: "21228885031", com: "18580606011" },
-  thriller: { fr: "21228906031", com: "18574449011" },
-  mystery: { fr: "21228905031", com: "18574427011" },
-  horror: { fr: "21229011031", com: "18573211011" },
+  "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" },
-  "literary-fiction": { fr: "21228884031", com: "18574784011" },
+  "historical-fiction": { fr: "21229010031", com: "18574482011" },
+  "literary-fiction": { fr: "21228884031", com: "18574426011" },
   biography: { fr: "21228881031", com: "18571951011" },
-  history: { fr: "21228890031" },
-  business: { fr: "21228882031", com: "18571961011" },
-  "self-help": { fr: "21228892031", com: "18571967011" },
-  science: { fr: "21228897031", com: "18571997011" },
+  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" },
-  comedy: { fr: "34003928031", com: "18572049011" },
-  erotica: { fr: "21228894031", com: "18573267011" },
-  religion: { fr: "21228880031", com: "18574606011" },
-  sports: { fr: "21228879031", com: "18574713011" },
-  travel: { fr: "21228891031", com: "18574721011" },
-  lgbtq: { fr: "21228883031", com: "18573939011" },
+  "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" },
+  "science-fiction/adaptations": { fr: "21229683031", com: "18580642011" },
   "science-fiction/cyberpunk": { fr: "21229684031", com: "18580633011" },
-  "science-fiction/dystopian": { fr: "21229685031", com: "18580634011" },
-  "science-fiction/first-contact": { fr: "21229682031", com: "18580635011" },
-  "science-fiction/galactic-empire": { fr: "21229693031", com: "18580636011" },
-  "science-fiction/genetic-engineering": { fr: "21229686031", com: "18580637011" },
-  "science-fiction/military": { fr: "21229688031", com: "18580643011" },
-  "science-fiction/post-apocalyptic": { fr: "21229687031", com: "18580645011" },
-  "science-fiction/space-exploration": { fr: "21229689031", com: "18580647011" },
-  "science-fiction/space-opera": { fr: "21229694031", com: "18580648011" },
+  "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" },
-  "fantasy/dragons": { fr: "21229709031", com: "18580612011" },
-  "fantasy/epic": { fr: "21229701031", com: "18580614011" },
-  "fantasy/historical": { fr: "21229700031", com: "18580616011" },
-  "fantasy/urban-paranormal": { fr: "21229711031", com: "18580621011" },
-  "thriller/suspense": { fr: "21229158031", com: "18574450011" },
-  "thriller/psychological": { fr: "21229165031", com: "18574459011" },
-  "thriller/domestic": { fr: "21229163031", com: "18574455011" },
-  "thriller/historical": { fr: "21229168031", com: "18574456011" },
-  "mystery/amateur-sleuth": { fr: "21229145031", com: "18574430011" },
-  "mystery/detective": { fr: "21229148031" },
-  "mystery/historical": { fr: "21229155031", com: "18574435011" },
-  "mystery/noir": { fr: "21229177031", com: "18574434011" },
-  "mystery/private-investigator": { fr: "21229148031", com: "18574439011" },
-  "mystery/traditional": { fr: "21229152031", com: "18574443011" },
-  "romance/action-adventure": { fr: "21229096031" },
-  "romance/comedy": { fr: "21229087031" },
-  "romance/contemporary": { fr: "21230152031" },
-  "romance/fantasy": { fr: "21229095031" },
-  "romance/historical": { fr: "21229093031" },
-  "romance/paranormal": { fr: "21229088031" },
-  "romance/science-fiction": { fr: "21229085031" },
-  "romance/sports": { fr: "21229086031" },
-  "romance/suspense": { fr: "21229090031" },
-  "literary-fiction/action-adventure": { fr: "21230085031" },
-  "literary-fiction/classics": { fr: "21229007031" },
-  "literary-fiction/coming-of-age": { fr: "21230090031" },
-  "literary-fiction/contemporary": { fr: "21229657031" },
-  "literary-fiction/drama": { fr: "21229017031" },
-  "literary-fiction/family-life": { fr: "21229670031" },
-  "literary-fiction/historical": { fr: "21229010031" },
-  "literary-fiction/sagas": { fr: "21229654031" },
-  "literary-fiction/sea-adventures": { fr: "21229673031" },
-  "literary-fiction/world-literature": { fr: "21229018031" },
-  "biography/entertainment": { fr: "21228985031" },
-  "history/europe": { fr: "21229067031" },
-  "children/action-adventure": { fr: "21228913031" },
-  "young-adult/literary-fiction": { fr: "21229110031" },
-  "young-adult/romance": { fr: "21229117031" },
-  "young-adult/science-fiction-fantasy": { fr: "21229103031" },
-  "young-adult/thriller": { fr: "21229114031" }
+  "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];
@@ -1838,170 +1969,58 @@ var refresh = async (credentials) => {
   };
 };
 
-// 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) => {
-    const keys2 = [];
+  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)) {
-        keys2.push(key);
+        keys.push(key);
       }
     }
-    return keys2;
+    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();
     }
@@ -2009,8 +2028,8 @@ var util;
   };
 })(util || (util = {}));
 var objectUtil;
-(function(objectUtil2) {
-  objectUtil2.mergeShapes = (first, second) => {
+(function(objectUtil) {
+  objectUtil.mergeShapes = (first, second) => {
     return {
       ...first,
       ...second
@@ -2100,11 +2119,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;
@@ -2305,12 +2319,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;
@@ -2337,7 +2349,6 @@ var makeIssue = (params) => {
     message: errorMessage
   };
 };
-var EMPTY_PATH = [];
 function addIssueToContext(ctx, issueData) {
   const overrideMap = getErrorMap();
   const issue = makeIssue({
@@ -2417,11 +2428,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
@@ -2466,12 +2478,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") {
@@ -2858,11 +2870,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;
     }
@@ -3416,11 +3428,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;
     }
@@ -3842,17 +3854,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;
@@ -4140,8 +4152,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) => {
@@ -4222,18 +4234,18 @@ class ZodObject extends ZodType {
     if (this._cached !== null)
       return this._cached;
     const shape = this._def.shape();
-    const keys2 = util.objectKeys(shape);
-    this._cached = { shape, keys: keys2 };
+    const keys = util.objectKeys(shape);
+    this._cached = { shape, keys };
     return this._cached;
   }
   _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;
     }
@@ -4537,7 +4549,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
@@ -4977,9 +4989,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")
@@ -4990,7 +5002,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);
     }
@@ -5343,11 +5355,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
           });
@@ -5539,10 +5551,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);
             },
@@ -5691,78 +5703,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;
@@ -5797,64 +5779,60 @@ 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 nullToUndefined = (v) => v ?? undefined;
-var optionalString = exports_external.string().nullish().transform(nullToUndefined);
-var ratingDistributionSchema = exports_external.object({
-  average_rating: exports_external.number(),
-  display_average_rating: exports_external.string().default("0"),
-  display_stars: exports_external.number().default(0),
-  num_ratings: exports_external.number(),
-  num_five_star_ratings: exports_external.number().default(0),
-  num_four_star_ratings: exports_external.number().default(0),
-  num_three_star_ratings: exports_external.number().default(0),
-  num_two_star_ratings: exports_external.number().default(0),
-  num_one_star_ratings: exports_external.number().default(0)
+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 = exports_external.object({
-  num_reviews: exports_external.number().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 = exports_external.object({
-  root: exports_external.string().default("Genres"),
-  ladder: exports_external.array(exports_external.object({
-    id: exports_external.string(),
-    name: exports_external.string()
+var categoryLadderSchema = objectType({
+  root: stringType().default("Genres"),
+  ladder: arrayType(objectType({
+    id: stringType(),
+    name: stringType()
   })).default([])
 });
-var relationshipSchema = exports_external.object({
-  asin: exports_external.string(),
+var relationshipSchema = objectType({
+  asin: stringType(),
   relationship_to_product: optionalString,
   relationship_type: optionalString,
   title: optionalString,
   sort: optionalString,
   url: optionalString
 });
-var audibleRawItemSchema = exports_external.object({
-  asin: exports_external.string().min(1),
-  title: exports_external.string().min(1),
+var lastPositionsSchema = objectType({
+  asin_last_position_heard_annots: arrayType(objectType({
+    asin: stringType(),
+    last_position_heard: objectType({
+      status: stringType(),
+      position_ms: numberType().nullish(),
+      last_updated: stringType().nullish()
+    })
+  })).nullish().transform((v) => v ?? [])
+});
+var audibleRawItemSchema = objectType({
+  asin: stringType().min(1),
+  title: stringType().min(1),
   subtitle: optionalString,
   isbn: optionalString,
   sku: optionalString,
-  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),
+  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,
@@ -5866,29 +5844,29 @@ var audibleRawItemSchema = exports_external.object({
   content_type: optionalString,
   content_delivery_type: optionalString,
   program_participation: optionalString,
-  product_images: exports_external.record(exports_external.string(), exports_external.string()).nullish().transform((v) => v ?? {}),
-  social_media_images: exports_external.record(exports_external.string(), exports_external.string()).nullish().transform((v) => v ?? {}),
-  series: exports_external.array(exports_external.object({
-    asin: exports_external.string(),
-    title: exports_external.string(),
+  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 ?? []),
-  category_ladders: exports_external.array(categoryLadderSchema).nullish().transform((v) => v ?? []),
-  platinum_keywords: exports_external.array(exports_external.string()).nullish().transform((v) => v ?? []),
-  thesaurus_subject_keywords: exports_external.array(exports_external.string()).nullish().transform((v) => v ?? []),
+  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: exports_external.object({
-    is_finished: exports_external.boolean().optional(),
-    percent_complete: exports_external.number().optional(),
-    finished_at_timestamp: exports_external.string().nullish(),
-    time_remaining_seconds: exports_external.number().optional()
+  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: exports_external.object({
-    date_added: exports_external.string().nullish()
+  library_status: objectType({
+    date_added: stringType().nullish()
   }).nullish().transform(nullToUndefined),
-  relationships: exports_external.array(relationshipSchema).nullish().transform((v) => v ?? []),
-  is_adult_product: exports_external.boolean().nullish().transform((v) => v ?? false)
+  relationships: arrayType(relationshipSchema).nullish().transform((v) => v ?? []),
+  is_adult_product: booleanType().nullish().transform((v) => v ?? false)
 });
 
 // src/signing.ts
@@ -6038,14 +6016,14 @@ var catalog = async (credentials, options) => {
   const limit = options.limit ?? 50;
   if (sortBy === "MostVoted") {
     const MAX_PAGES = 20;
-    const { items: allItems, credentials: fresh2 } = await fetchCatalogPages(credentials, categoryId, options, MAX_PAGES);
+    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: fresh2
+      credentials: fresh
     };
   }
   const { data: response, credentials: fresh } = await audibleFetch("/catalog/products", credentials, {
@@ -6064,6 +6042,23 @@ var catalog = async (credentials, options) => {
 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 POSITIONS_BATCH_SIZE = 25;
+var utcDateOf = (value) => new Date(`${value.replace(" ", "T")}Z`);
+var fetchPositionBatches = async (batches, credentials, accumulated = []) => {
+  const [batch, ...rest] = batches;
+  if (!batch)
+    return { positions: accumulated, credentials };
+  const { data, credentials: fresh } = await audibleFetch("/annotations/lastpositions", credentials, { asins: batch.join(",") });
+  const heard = lastPositionsSchema.parse(data).asin_last_position_heard_annots.flatMap(({ asin, last_position_heard: position }) => position.status === "Exists" && position.last_updated ? [
+    {
+      asin,
+      positionMs: position.position_ms ?? 0,
+      lastUpdatedAt: utcDateOf(position.last_updated)
+    }
+  ] : []);
+  return fetchPositionBatches(rest, fresh, [...accumulated, ...heard]);
+};
+var lastPositions = async (credentials, asins) => fetchPositionBatches(chunk_default([...asins], POSITIONS_BATCH_SIZE), credentials);
 var verify = async (credentials) => {
   await audibleFetch("/library", credentials, {
     num_results: "1",
@@ -6072,14 +6067,15 @@ var verify = async (credentials) => {
   });
 };
 export {
-  wishlist,
-  verify,
-  resolveGenreId,
-  register,
-  refresh,
-  login,
-  library,
-  catalog,
+  AUDIBLE_LOCALES,
   GENRE_CATEGORIES,
-  AUDIBLE_LOCALES
+  catalog,
+  lastPositions,
+  library,
+  login,
+  refresh,
+  register,
+  resolveGenreId,
+  verify,
+  wishlist
 };