zupost 0.0.0 → 0.1.1

package/dist/index.js

@@ -24,6 +24,18 @@ var __spreadValues = (a, b) => {
   return a;
 };
 var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __objRest = (source, exclude) => {
+  var target = {};
+  for (var prop in source)
+    if (__hasOwnProp.call(source, prop) && exclude.indexOf(prop) < 0)
+      target[prop] = source[prop];
+  if (source != null && __getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(source)) {
+      if (exclude.indexOf(prop) < 0 && __propIsEnum.call(source, prop))
+        target[prop] = source[prop];
+    }
+  return target;
+};
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
@@ -39,8 +51,18 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
 var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
 var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
 var __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "access private method"), method);
+var __privateWrapper = (obj, member, setter, getter) => ({
+  set _(value) {
+    __privateSet(obj, member, value, setter);
+  },
+  get _() {
+    return __privateGet(obj, member, getter);
+  }
+});
 var __async = (__this, __arguments, generator) => {
   return new Promise((resolve, reject) => {
     var fulfilled = (value) => {
@@ -70,9 +92,9 @@ __export(index_exports, {
 module.exports = __toCommonJS(index_exports);
 
 // package.json
-var version = "0.0.0";
+var version = "0.1.1";
 
-// node_modules/.pnpm/ky@1.11.0/node_modules/ky/distribution/errors/HTTPError.js
+// node_modules/.pnpm/ky@1.14.3/node_modules/ky/distribution/errors/HTTPError.js
 var HTTPError = class extends Error {
   constructor(response, request, options) {
     var _a;
@@ -91,17 +113,41 @@ var HTTPError = class extends Error {
   }
 };
 
-// node_modules/.pnpm/ky@1.11.0/node_modules/ky/distribution/errors/TimeoutError.js
-var TimeoutError = class extends Error {
-  constructor(request) {
-    super(`Request timed out: ${request.method} ${request.url}`);
-    __publicField(this, "request");
-    this.name = "TimeoutError";
-    this.request = request;
+// node_modules/.pnpm/ky@1.14.3/node_modules/ky/distribution/errors/NonError.js
+var NonError = class extends Error {
+  constructor(value) {
+    let message = "Non-error value was thrown";
+    try {
+      if (typeof value === "string") {
+        message = value;
+      } else if (value && typeof value === "object" && "message" in value && typeof value.message === "string") {
+        message = value.message;
+      }
+    } catch (e) {
+    }
+    super(message);
+    __publicField(this, "name", "NonError");
+    __publicField(this, "value");
+    this.value = value;
   }
 };
 
-// node_modules/.pnpm/ky@1.11.0/node_modules/ky/distribution/core/constants.js
+// node_modules/.pnpm/ky@1.14.3/node_modules/ky/distribution/errors/ForceRetryError.js
+var ForceRetryError = class extends Error {
+  constructor(options) {
+    const cause = (options == null ? void 0 : options.cause) ? options.cause instanceof Error ? options.cause : new NonError(options.cause) : void 0;
+    super((options == null ? void 0 : options.code) ? `Forced retry: ${options.code}` : "Forced retry", cause ? { cause } : void 0);
+    __publicField(this, "name", "ForceRetryError");
+    __publicField(this, "customDelay");
+    __publicField(this, "code");
+    __publicField(this, "customRequest");
+    this.customDelay = options == null ? void 0 : options.delay;
+    this.code = options == null ? void 0 : options.code;
+    this.customRequest = options == null ? void 0 : options.request;
+  }
+};
+
+// node_modules/.pnpm/ky@1.14.3/node_modules/ky/distribution/core/constants.js
 var supportsRequestStreams = (() => {
   let duplexAccessed = false;
   let hasContentType = false;
@@ -146,7 +192,14 @@ var responseTypes = {
 };
 var maxSafeTimeout = 2147483647;
 var usualFormBoundarySize = new TextEncoder().encode("------WebKitFormBoundaryaxpyiPgbbPti10Rw").length;
-var stop = Symbol("stop");
+var stop = /* @__PURE__ */ Symbol("stop");
+var RetryMarker = class {
+  constructor(options) {
+    __publicField(this, "options");
+    this.options = options;
+  }
+};
+var retry = (options) => new RetryMarker(options);
 var kyOptionKeys = {
   json: true,
   parseJson: true,
@@ -159,7 +212,12 @@ var kyOptionKeys = {
   throwHttpErrors: true,
   onDownloadProgress: true,
   onUploadProgress: true,
-  fetch: true
+  fetch: true,
+  context: true
+};
+var vendorSpecificOptions = {
+  next: true
+  // Next.js cache revalidation (revalidate, tags)
 };
 var requestOptionsRegistry = {
   method: true,
@@ -175,12 +233,10 @@ var requestOptionsRegistry = {
   keepalive: true,
   signal: true,
   window: true,
-  dispatcher: true,
-  duplex: true,
-  priority: true
+  duplex: true
 };
 
-// node_modules/.pnpm/ky@1.11.0/node_modules/ky/distribution/utils/body.js
+// node_modules/.pnpm/ky@1.14.3/node_modules/ky/distribution/utils/body.js
 var getBodySize = (body) => {
   if (!body) {
     return 0;
@@ -254,7 +310,7 @@ var streamResponse = (response, onDownloadProgress) => {
       headers: response.headers
     });
   }
-  const totalBytes = Number(response.headers.get("content-length")) || 0;
+  const totalBytes = Math.max(0, Number(response.headers.get("content-length")) || 0);
   return new Response(withProgress(response.body, totalBytes, onDownloadProgress), {
     status: response.status,
     statusText: response.statusText,
@@ -273,10 +329,10 @@ var streamRequest = (request, onUploadProgress, originalBody) => {
   });
 };
 
-// node_modules/.pnpm/ky@1.11.0/node_modules/ky/distribution/utils/is.js
+// node_modules/.pnpm/ky@1.14.3/node_modules/ky/distribution/utils/is.js
 var isObject = (value) => value !== null && typeof value === "object";
 
-// node_modules/.pnpm/ky@1.11.0/node_modules/ky/distribution/utils/merge.js
+// node_modules/.pnpm/ky@1.14.3/node_modules/ky/distribution/utils/merge.js
 var validateAndMerge = (...sources) => {
   for (const source of sources) {
     if ((!isObject(source) || Array.isArray(source)) && source !== void 0) {
@@ -308,10 +364,44 @@ var mergeHooks = (original = {}, incoming = {}) => ({
   afterResponse: newHookValue(original, incoming, "afterResponse"),
   beforeError: newHookValue(original, incoming, "beforeError")
 });
+var appendSearchParameters = (target, source) => {
+  const result = new URLSearchParams();
+  for (const input of [target, source]) {
+    if (input === void 0) {
+      continue;
+    }
+    if (input instanceof URLSearchParams) {
+      for (const [key, value] of input.entries()) {
+        result.append(key, value);
+      }
+    } else if (Array.isArray(input)) {
+      for (const pair of input) {
+        if (!Array.isArray(pair) || pair.length !== 2) {
+          throw new TypeError("Array search parameters must be provided in [[key, value], ...] format");
+        }
+        result.append(String(pair[0]), String(pair[1]));
+      }
+    } else if (isObject(input)) {
+      for (const [key, value] of Object.entries(input)) {
+        if (value !== void 0) {
+          result.append(key, String(value));
+        }
+      }
+    } else {
+      const parameters = new URLSearchParams(input);
+      for (const [key, value] of parameters.entries()) {
+        result.append(key, value);
+      }
+    }
+  }
+  return result;
+};
 var deepMerge = (...sources) => {
   let returnValue = {};
   let headers = {};
   let hooks = {};
+  let searchParameters;
+  const signals = [];
   for (const source of sources) {
     if (Array.isArray(source)) {
       if (!Array.isArray(returnValue)) {
@@ -320,6 +410,27 @@ var deepMerge = (...sources) => {
       returnValue = [...returnValue, ...source];
     } else if (isObject(source)) {
       for (let [key, value] of Object.entries(source)) {
+        if (key === "signal" && value instanceof globalThis.AbortSignal) {
+          signals.push(value);
+          continue;
+        }
+        if (key === "context") {
+          if (value !== void 0 && value !== null && (!isObject(value) || Array.isArray(value))) {
+            throw new TypeError("The `context` option must be an object");
+          }
+          returnValue = __spreadProps(__spreadValues({}, returnValue), {
+            context: value === void 0 || value === null ? {} : __spreadValues(__spreadValues({}, returnValue.context), value)
+          });
+          continue;
+        }
+        if (key === "searchParams") {
+          if (value === void 0 || value === null) {
+            searchParameters = void 0;
+          } else {
+            searchParameters = searchParameters === void 0 ? value : appendSearchParameters(searchParameters, value);
+          }
+          continue;
+        }
         if (isObject(value) && key in returnValue) {
           value = deepMerge(returnValue[key], value);
         }
@@ -335,10 +446,22 @@ var deepMerge = (...sources) => {
       }
     }
   }
+  if (searchParameters !== void 0) {
+    returnValue.searchParams = searchParameters;
+  }
+  if (signals.length > 0) {
+    if (signals.length === 1) {
+      returnValue.signal = signals[0];
+    } else if (supportsAbortSignal) {
+      returnValue.signal = AbortSignal.any(signals);
+    } else {
+      returnValue.signal = signals.at(-1);
+    }
+  }
   return returnValue;
 };
 
-// node_modules/.pnpm/ky@1.11.0/node_modules/ky/distribution/utils/normalize.js
+// node_modules/.pnpm/ky@1.14.3/node_modules/ky/distribution/utils/normalize.js
 var normalizeRequestMethod = (input) => requestMethods.includes(input) ? input.toUpperCase() : input;
 var retryMethods = ["get", "put", "head", "delete", "options", "trace"];
 var retryStatusCodes = [408, 413, 429, 500, 502, 503, 504];
@@ -350,24 +473,38 @@ var defaultRetryOptions = {
   afterStatusCodes: retryAfterStatusCodes,
   maxRetryAfter: Number.POSITIVE_INFINITY,
   backoffLimit: Number.POSITIVE_INFINITY,
-  delay: (attemptCount) => 0.3 * __pow(2, attemptCount - 1) * 1e3
+  delay: (attemptCount) => 0.3 * __pow(2, attemptCount - 1) * 1e3,
+  jitter: void 0,
+  retryOnTimeout: false
 };
-var normalizeRetryOptions = (retry = {}) => {
-  if (typeof retry === "number") {
+var normalizeRetryOptions = (retry2 = {}) => {
+  if (typeof retry2 === "number") {
     return __spreadProps(__spreadValues({}, defaultRetryOptions), {
-      limit: retry
+      limit: retry2
     });
   }
-  if (retry.methods && !Array.isArray(retry.methods)) {
+  if (retry2.methods && !Array.isArray(retry2.methods)) {
     throw new Error("retry.methods must be an array");
   }
-  if (retry.statusCodes && !Array.isArray(retry.statusCodes)) {
+  retry2.methods && (retry2.methods = retry2.methods.map((method) => method.toLowerCase()));
+  if (retry2.statusCodes && !Array.isArray(retry2.statusCodes)) {
     throw new Error("retry.statusCodes must be an array");
   }
-  return __spreadValues(__spreadValues({}, defaultRetryOptions), retry);
+  const normalizedRetry = Object.fromEntries(Object.entries(retry2).filter(([, value]) => value !== void 0));
+  return __spreadValues(__spreadValues({}, defaultRetryOptions), normalizedRetry);
 };
 
-// node_modules/.pnpm/ky@1.11.0/node_modules/ky/distribution/utils/timeout.js
+// node_modules/.pnpm/ky@1.14.3/node_modules/ky/distribution/errors/TimeoutError.js
+var TimeoutError = class extends Error {
+  constructor(request) {
+    super(`Request timed out: ${request.method} ${request.url}`);
+    __publicField(this, "request");
+    this.name = "TimeoutError";
+    this.request = request;
+  }
+};
+
+// node_modules/.pnpm/ky@1.14.3/node_modules/ky/distribution/utils/timeout.js
 function timeout(request, init, abortController, options) {
   return __async(this, null, function* () {
     return new Promise((resolve, reject) => {
@@ -384,7 +521,7 @@ function timeout(request, init, abortController, options) {
   });
 }
 
-// node_modules/.pnpm/ky@1.11.0/node_modules/ky/distribution/utils/delay.js
+// node_modules/.pnpm/ky@1.14.3/node_modules/ky/distribution/utils/delay.js
 function delay(_0, _1) {
   return __async(this, arguments, function* (ms, { signal }) {
     return new Promise((resolve, reject) => {
@@ -404,11 +541,14 @@ function delay(_0, _1) {
   });
 }
 
-// node_modules/.pnpm/ky@1.11.0/node_modules/ky/distribution/utils/options.js
+// node_modules/.pnpm/ky@1.14.3/node_modules/ky/distribution/utils/options.js
 var findUnknownOptions = (request, options) => {
   const unknownOptions = {};
   for (const key in options) {
-    if (!(key in requestOptionsRegistry) && !(key in kyOptionKeys) && !(key in request)) {
+    if (!Object.hasOwn(options, key)) {
+      continue;
+    }
+    if (!(key in requestOptionsRegistry) && !(key in kyOptionKeys) && (!(key in request) || key in vendorSpecificOptions)) {
       unknownOptions[key] = options[key];
     }
   }
@@ -433,131 +573,156 @@ var hasSearchParameters = (search) => {
   return Boolean(search);
 };
 
-// node_modules/.pnpm/ky@1.11.0/node_modules/ky/distribution/core/Ky.js
-var _Ky_static, normalizeSearchParams_fn;
+// node_modules/.pnpm/ky@1.14.3/node_modules/ky/distribution/utils/type-guards.js
+function isHTTPError(error) {
+  return error instanceof HTTPError || (error == null ? void 0 : error.name) === HTTPError.name;
+}
+function isTimeoutError(error) {
+  return error instanceof TimeoutError || (error == null ? void 0 : error.name) === TimeoutError.name;
+}
+
+// node_modules/.pnpm/ky@1.14.3/node_modules/ky/distribution/core/Ky.js
+var _Ky_static, normalizeSearchParams_fn, _abortController, _retryCount, _input, _options, _originalRequest, _userProvidedAbortSignal, _cachedNormalizedOptions, _Ky_instances, calculateDelay_fn, calculateRetryDelay_fn, decorateResponse_fn, cancelBody_fn, cancelResponseBody_fn, retry_fn, fetch_fn, getNormalizedOptions_fn, assignRequest_fn, wrapRequestWithUploadProgress_fn;
 var _Ky = class _Ky {
   // eslint-disable-next-line complexity
   constructor(input, options = {}) {
+    __privateAdd(this, _Ky_instances);
     __publicField(this, "request");
-    __publicField(this, "abortController");
-    __publicField(this, "_retryCount", 0);
-    __publicField(this, "_input");
-    __publicField(this, "_options");
-    __publicField(this, "_originalRequest");
-    var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j;
-    this._input = input;
-    this._options = __spreadProps(__spreadValues({}, options), {
-      headers: mergeHeaders(this._input.headers, options.headers),
+    __privateAdd(this, _abortController);
+    __privateAdd(this, _retryCount, 0);
+    // eslint-disable-next-line @typescript-eslint/prefer-readonly -- False positive: #input is reassigned on line 202
+    __privateAdd(this, _input);
+    __privateAdd(this, _options);
+    __privateAdd(this, _originalRequest);
+    __privateAdd(this, _userProvidedAbortSignal);
+    __privateAdd(this, _cachedNormalizedOptions);
+    var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m;
+    __privateSet(this, _input, input);
+    __privateSet(this, _options, __spreadProps(__spreadValues({}, options), {
+      headers: mergeHeaders(__privateGet(this, _input).headers, options.headers),
       hooks: mergeHooks({
         beforeRequest: [],
         beforeRetry: [],
         beforeError: [],
         afterResponse: []
       }, options.hooks),
-      method: normalizeRequestMethod((_b = (_a = options.method) != null ? _a : this._input.method) != null ? _b : "GET"),
+      method: normalizeRequestMethod((_b = (_a = options.method) != null ? _a : __privateGet(this, _input).method) != null ? _b : "GET"),
       // eslint-disable-next-line @typescript-eslint/prefer-nullish-coalescing
       prefixUrl: String(options.prefixUrl || ""),
       retry: normalizeRetryOptions(options.retry),
-      throwHttpErrors: options.throwHttpErrors !== false,
-      timeout: (_c = options.timeout) != null ? _c : 1e4,
-      fetch: (_d = options.fetch) != null ? _d : globalThis.fetch.bind(globalThis)
-    });
-    if (typeof this._input !== "string" && !(this._input instanceof URL || this._input instanceof globalThis.Request)) {
+      throwHttpErrors: (_c = options.throwHttpErrors) != null ? _c : true,
+      timeout: (_d = options.timeout) != null ? _d : 1e4,
+      fetch: (_e = options.fetch) != null ? _e : globalThis.fetch.bind(globalThis),
+      context: (_f = options.context) != null ? _f : {}
+    }));
+    if (typeof __privateGet(this, _input) !== "string" && !(__privateGet(this, _input) instanceof URL || __privateGet(this, _input) instanceof globalThis.Request)) {
       throw new TypeError("`input` must be a string, URL, or Request");
     }
-    if (this._options.prefixUrl && typeof this._input === "string") {
-      if (this._input.startsWith("/")) {
+    if (__privateGet(this, _options).prefixUrl && typeof __privateGet(this, _input) === "string") {
+      if (__privateGet(this, _input).startsWith("/")) {
         throw new Error("`input` must not begin with a slash when using `prefixUrl`");
       }
-      if (!this._options.prefixUrl.endsWith("/")) {
-        this._options.prefixUrl += "/";
+      if (!__privateGet(this, _options).prefixUrl.endsWith("/")) {
+        __privateGet(this, _options).prefixUrl += "/";
       }
-      this._input = this._options.prefixUrl + this._input;
+      __privateSet(this, _input, __privateGet(this, _options).prefixUrl + __privateGet(this, _input));
     }
     if (supportsAbortController && supportsAbortSignal) {
-      const originalSignal = (_e = this._options.signal) != null ? _e : this._input.signal;
-      this.abortController = new globalThis.AbortController();
-      this._options.signal = originalSignal ? AbortSignal.any([originalSignal, this.abortController.signal]) : this.abortController.signal;
+      __privateSet(this, _userProvidedAbortSignal, (_g = __privateGet(this, _options).signal) != null ? _g : __privateGet(this, _input).signal);
+      __privateSet(this, _abortController, new globalThis.AbortController());
+      __privateGet(this, _options).signal = __privateGet(this, _userProvidedAbortSignal) ? AbortSignal.any([__privateGet(this, _userProvidedAbortSignal), __privateGet(this, _abortController).signal]) : __privateGet(this, _abortController).signal;
     }
     if (supportsRequestStreams) {
-      this._options.duplex = "half";
+      __privateGet(this, _options).duplex = "half";
+    }
+    if (__privateGet(this, _options).json !== void 0) {
+      __privateGet(this, _options).body = (_j = (_i = (_h = __privateGet(this, _options)).stringifyJson) == null ? void 0 : _i.call(_h, __privateGet(this, _options).json)) != null ? _j : JSON.stringify(__privateGet(this, _options).json);
+      __privateGet(this, _options).headers.set("content-type", (_k = __privateGet(this, _options).headers.get("content-type")) != null ? _k : "application/json");
     }
-    if (this._options.json !== void 0) {
-      this._options.body = (_h = (_g = (_f = this._options).stringifyJson) == null ? void 0 : _g.call(_f, this._options.json)) != null ? _h : JSON.stringify(this._options.json);
-      this._options.headers.set("content-type", (_i = this._options.headers.get("content-type")) != null ? _i : "application/json");
+    const userProvidedContentType = options.headers && new globalThis.Headers(options.headers).has("content-type");
+    if (__privateGet(this, _input) instanceof globalThis.Request && (supportsFormData && __privateGet(this, _options).body instanceof globalThis.FormData || __privateGet(this, _options).body instanceof URLSearchParams) && !userProvidedContentType) {
+      __privateGet(this, _options).headers.delete("content-type");
     }
-    this.request = new globalThis.Request(this._input, this._options);
-    if (hasSearchParameters(this._options.searchParams)) {
-      const textSearchParams = typeof this._options.searchParams === "string" ? this._options.searchParams.replace(/^\?/, "") : new URLSearchParams(__privateMethod(_j = _Ky, _Ky_static, normalizeSearchParams_fn).call(_j, this._options.searchParams)).toString();
+    this.request = new globalThis.Request(__privateGet(this, _input), __privateGet(this, _options));
+    if (hasSearchParameters(__privateGet(this, _options).searchParams)) {
+      const textSearchParams = typeof __privateGet(this, _options).searchParams === "string" ? __privateGet(this, _options).searchParams.replace(/^\?/, "") : new URLSearchParams(__privateMethod(_l = _Ky, _Ky_static, normalizeSearchParams_fn).call(_l, __privateGet(this, _options).searchParams)).toString();
       const searchParams = "?" + textSearchParams;
       const url = this.request.url.replace(/(?:\?.*?)?(?=#|$)/, searchParams);
-      if ((supportsFormData && this._options.body instanceof globalThis.FormData || this._options.body instanceof URLSearchParams) && !(this._options.headers && this._options.headers["content-type"])) {
-        this.request.headers.delete("content-type");
-      }
-      this.request = new globalThis.Request(new globalThis.Request(url, __spreadValues({}, this.request)), this._options);
+      this.request = new globalThis.Request(url, __privateGet(this, _options));
     }
-    if (this._options.onUploadProgress) {
-      if (typeof this._options.onUploadProgress !== "function") {
+    if (__privateGet(this, _options).onUploadProgress) {
+      if (typeof __privateGet(this, _options).onUploadProgress !== "function") {
         throw new TypeError("The `onUploadProgress` option must be a function");
       }
       if (!supportsRequestStreams) {
         throw new Error("Request streams are not supported in your environment. The `duplex` option for `Request` is not available.");
       }
-      const originalBody = this.request.body;
-      if (originalBody) {
-        this.request = streamRequest(this.request, this._options.onUploadProgress, this._options.body);
-      }
+      this.request = __privateMethod(this, _Ky_instances, wrapRequestWithUploadProgress_fn).call(this, this.request, (_m = __privateGet(this, _options).body) != null ? _m : void 0);
     }
   }
   static create(input, options) {
-    var _a, _b;
+    var _a, _b, _c;
     const ky2 = new _Ky(input, options);
     const function_ = () => __async(null, null, function* () {
-      if (typeof ky2._options.timeout === "number" && ky2._options.timeout > maxSafeTimeout) {
+      var _a2, _b2, _c2, _d, _e, _f, _g, _h, _i, _j, _k, _l;
+      if (typeof __privateGet(ky2, _options).timeout === "number" && __privateGet(ky2, _options).timeout > maxSafeTimeout) {
         throw new RangeError(`The \`timeout\` option cannot be greater than ${maxSafeTimeout}`);
       }
       yield Promise.resolve();
-      let response = yield ky2._fetch();
-      for (const hook of ky2._options.hooks.afterResponse) {
-        const modifiedResponse = yield hook(ky2.request, ky2._options, ky2._decorateResponse(response.clone()));
-        if (modifiedResponse instanceof globalThis.Response) {
-          response = modifiedResponse;
+      let response = yield __privateMethod(_a2 = ky2, _Ky_instances, fetch_fn).call(_a2);
+      for (const hook of __privateGet(ky2, _options).hooks.afterResponse) {
+        const clonedResponse = __privateMethod(_b2 = ky2, _Ky_instances, decorateResponse_fn).call(_b2, response.clone());
+        let modifiedResponse;
+        try {
+          modifiedResponse = yield hook(ky2.request, __privateMethod(_c2 = ky2, _Ky_instances, getNormalizedOptions_fn).call(_c2), clonedResponse, { retryCount: __privateGet(ky2, _retryCount) });
+        } catch (error) {
+          __privateMethod(_d = ky2, _Ky_instances, cancelResponseBody_fn).call(_d, clonedResponse);
+          __privateMethod(_e = ky2, _Ky_instances, cancelResponseBody_fn).call(_e, response);
+          throw error;
+        }
+        if (modifiedResponse instanceof RetryMarker) {
+          __privateMethod(_f = ky2, _Ky_instances, cancelResponseBody_fn).call(_f, clonedResponse);
+          __privateMethod(_g = ky2, _Ky_instances, cancelResponseBody_fn).call(_g, response);
+          throw new ForceRetryError(modifiedResponse.options);
+        }
+        const nextResponse = modifiedResponse instanceof globalThis.Response ? modifiedResponse : response;
+        if (clonedResponse !== nextResponse) {
+          __privateMethod(_h = ky2, _Ky_instances, cancelResponseBody_fn).call(_h, clonedResponse);
+        }
+        if (response !== nextResponse) {
+          __privateMethod(_i = ky2, _Ky_instances, cancelResponseBody_fn).call(_i, response);
         }
+        response = nextResponse;
       }
-      ky2._decorateResponse(response);
-      if (!response.ok && ky2._options.throwHttpErrors) {
-        let error = new HTTPError(response, ky2.request, ky2._options);
-        for (const hook of ky2._options.hooks.beforeError) {
-          error = yield hook(error);
+      __privateMethod(_j = ky2, _Ky_instances, decorateResponse_fn).call(_j, response);
+      if (!response.ok && (typeof __privateGet(ky2, _options).throwHttpErrors === "function" ? __privateGet(ky2, _options).throwHttpErrors(response.status) : __privateGet(ky2, _options).throwHttpErrors)) {
+        let error = new HTTPError(response, ky2.request, __privateMethod(_k = ky2, _Ky_instances, getNormalizedOptions_fn).call(_k));
+        for (const hook of __privateGet(ky2, _options).hooks.beforeError) {
+          error = yield hook(error, { retryCount: __privateGet(ky2, _retryCount) });
         }
         throw error;
       }
-      if (ky2._options.onDownloadProgress) {
-        if (typeof ky2._options.onDownloadProgress !== "function") {
+      if (__privateGet(ky2, _options).onDownloadProgress) {
+        if (typeof __privateGet(ky2, _options).onDownloadProgress !== "function") {
           throw new TypeError("The `onDownloadProgress` option must be a function");
         }
         if (!supportsResponseStreams) {
           throw new Error("Streams are not supported in your environment. `ReadableStream` is missing.");
         }
-        return streamResponse(response.clone(), ky2._options.onDownloadProgress);
+        const progressResponse = response.clone();
+        __privateMethod(_l = ky2, _Ky_instances, cancelResponseBody_fn).call(_l, response);
+        return streamResponse(progressResponse, __privateGet(ky2, _options).onDownloadProgress);
       }
       return response;
     });
-    const isRetriableMethod = ky2._options.retry.methods.includes(ky2.request.method.toLowerCase());
-    const result = (isRetriableMethod ? ky2._retry(function_) : function_()).finally(() => __async(null, null, function* () {
-      var _a2, _b2;
-      const originalRequest = ky2._originalRequest;
-      const cleanupPromises = [];
-      if (originalRequest && !originalRequest.bodyUsed) {
-        cleanupPromises.push((_a2 = originalRequest.body) == null ? void 0 : _a2.cancel());
-      }
-      if (!ky2.request.bodyUsed) {
-        cleanupPromises.push((_b2 = ky2.request.body) == null ? void 0 : _b2.cancel());
-      }
-      yield Promise.all(cleanupPromises);
-    }));
+    const result = __privateMethod(_a = ky2, _Ky_instances, retry_fn).call(_a, function_).finally(() => {
+      var _a2, _b2, _c2, _d;
+      const originalRequest = __privateGet(ky2, _originalRequest);
+      __privateMethod(_b2 = ky2, _Ky_instances, cancelBody_fn).call(_b2, (_a2 = originalRequest == null ? void 0 : originalRequest.body) != null ? _a2 : void 0);
+      __privateMethod(_d = ky2, _Ky_instances, cancelBody_fn).call(_d, (_c2 = ky2.request.body) != null ? _c2 : void 0);
+    });
     for (const [type, mimeType] of Object.entries(responseTypes)) {
-      if (type === "bytes" && typeof ((_b = (_a = globalThis.Response) == null ? void 0 : _a.prototype) == null ? void 0 : _b.bytes) !== "function") {
+      if (type === "bytes" && typeof ((_c = (_b = globalThis.Response) == null ? void 0 : _b.prototype) == null ? void 0 : _c.bytes) !== "function") {
         continue;
       }
       result[type] = () => __async(null, null, function* () {
@@ -581,100 +746,188 @@ var _Ky = class _Ky {
     }
     return result;
   }
-  _calculateRetryDelay(error) {
-    var _a, _b, _c, _d;
-    this._retryCount++;
-    if (this._retryCount > this._options.retry.limit || error instanceof TimeoutError) {
+};
+_Ky_static = new WeakSet();
+normalizeSearchParams_fn = function(searchParams) {
+  if (searchParams && typeof searchParams === "object" && !Array.isArray(searchParams) && !(searchParams instanceof URLSearchParams)) {
+    return Object.fromEntries(Object.entries(searchParams).filter(([, value]) => value !== void 0));
+  }
+  return searchParams;
+};
+_abortController = new WeakMap();
+_retryCount = new WeakMap();
+_input = new WeakMap();
+_options = new WeakMap();
+_originalRequest = new WeakMap();
+_userProvidedAbortSignal = new WeakMap();
+_cachedNormalizedOptions = new WeakMap();
+_Ky_instances = new WeakSet();
+calculateDelay_fn = function() {
+  var _a;
+  const retryDelay = __privateGet(this, _options).retry.delay(__privateGet(this, _retryCount));
+  let jitteredDelay = retryDelay;
+  if (__privateGet(this, _options).retry.jitter === true) {
+    jitteredDelay = Math.random() * retryDelay;
+  } else if (typeof __privateGet(this, _options).retry.jitter === "function") {
+    jitteredDelay = __privateGet(this, _options).retry.jitter(retryDelay);
+    if (!Number.isFinite(jitteredDelay) || jitteredDelay < 0) {
+      jitteredDelay = retryDelay;
+    }
+  }
+  const backoffLimit = (_a = __privateGet(this, _options).retry.backoffLimit) != null ? _a : Number.POSITIVE_INFINITY;
+  return Math.min(backoffLimit, jitteredDelay);
+};
+calculateRetryDelay_fn = function(error) {
+  return __async(this, null, function* () {
+    var _a, _b, _c, _d, _e, _f;
+    __privateWrapper(this, _retryCount)._++;
+    if (__privateGet(this, _retryCount) > __privateGet(this, _options).retry.limit) {
       throw error;
     }
-    if (error instanceof HTTPError) {
-      if (!this._options.retry.statusCodes.includes(error.response.status)) {
+    const errorObject = error instanceof Error ? error : new NonError(error);
+    if (errorObject instanceof ForceRetryError) {
+      return (_a = errorObject.customDelay) != null ? _a : __privateMethod(this, _Ky_instances, calculateDelay_fn).call(this);
+    }
+    if (!__privateGet(this, _options).retry.methods.includes(this.request.method.toLowerCase())) {
+      throw error;
+    }
+    if (__privateGet(this, _options).retry.shouldRetry !== void 0) {
+      const result = yield __privateGet(this, _options).retry.shouldRetry({ error: errorObject, retryCount: __privateGet(this, _retryCount) });
+      if (result === false) {
         throw error;
       }
-      const retryAfter = (_c = (_b = (_a = error.response.headers.get("Retry-After")) != null ? _a : error.response.headers.get("RateLimit-Reset")) != null ? _b : error.response.headers.get("X-RateLimit-Reset")) != null ? _c : error.response.headers.get("X-Rate-Limit-Reset");
-      if (retryAfter && this._options.retry.afterStatusCodes.includes(error.response.status)) {
+      if (result === true) {
+        return __privateMethod(this, _Ky_instances, calculateDelay_fn).call(this);
+      }
+    }
+    if (isTimeoutError(error) && !__privateGet(this, _options).retry.retryOnTimeout) {
+      throw error;
+    }
+    if (isHTTPError(error)) {
+      if (!__privateGet(this, _options).retry.statusCodes.includes(error.response.status)) {
+        throw error;
+      }
+      const retryAfter = (_e = (_d = (_c = (_b = error.response.headers.get("Retry-After")) != null ? _b : error.response.headers.get("RateLimit-Reset")) != null ? _c : error.response.headers.get("X-RateLimit-Retry-After")) != null ? _d : error.response.headers.get("X-RateLimit-Reset")) != null ? _e : error.response.headers.get("X-Rate-Limit-Reset");
+      if (retryAfter && __privateGet(this, _options).retry.afterStatusCodes.includes(error.response.status)) {
         let after = Number(retryAfter) * 1e3;
         if (Number.isNaN(after)) {
           after = Date.parse(retryAfter) - Date.now();
         } else if (after >= Date.parse("2024-01-01")) {
           after -= Date.now();
         }
-        const max = (_d = this._options.retry.maxRetryAfter) != null ? _d : after;
+        const max = (_f = __privateGet(this, _options).retry.maxRetryAfter) != null ? _f : after;
         return after < max ? after : max;
       }
       if (error.response.status === 413) {
         throw error;
       }
     }
-    const retryDelay = this._options.retry.delay(this._retryCount);
-    return Math.min(this._options.retry.backoffLimit, retryDelay);
+    return __privateMethod(this, _Ky_instances, calculateDelay_fn).call(this);
+  });
+};
+decorateResponse_fn = function(response) {
+  if (__privateGet(this, _options).parseJson) {
+    response.json = () => __async(this, null, function* () {
+      return __privateGet(this, _options).parseJson(yield response.text());
+    });
   }
-  _decorateResponse(response) {
-    if (this._options.parseJson) {
-      response.json = () => __async(this, null, function* () {
-        return this._options.parseJson(yield response.text());
-      });
-    }
-    return response;
+  return response;
+};
+cancelBody_fn = function(body) {
+  if (!body) {
+    return;
   }
-  _retry(function_) {
-    return __async(this, null, function* () {
-      try {
-        return yield function_();
-      } catch (error) {
-        const ms = Math.min(this._calculateRetryDelay(error), maxSafeTimeout);
-        if (this._retryCount < 1) {
-          throw error;
-        }
-        yield delay(ms, { signal: this._options.signal });
-        for (const hook of this._options.hooks.beforeRetry) {
-          const hookResult = yield hook({
-            request: this.request,
-            options: this._options,
-            error,
-            retryCount: this._retryCount
-          });
-          if (hookResult === stop) {
-            return;
-          }
-        }
-        return this._retry(function_);
+  void body.cancel().catch(() => void 0);
+};
+cancelResponseBody_fn = function(response) {
+  var _a;
+  __privateMethod(this, _Ky_instances, cancelBody_fn).call(this, (_a = response.body) != null ? _a : void 0);
+};
+retry_fn = function(function_) {
+  return __async(this, null, function* () {
+    try {
+      return yield function_();
+    } catch (error) {
+      const ms = Math.min(yield __privateMethod(this, _Ky_instances, calculateRetryDelay_fn).call(this, error), maxSafeTimeout);
+      if (__privateGet(this, _retryCount) < 1) {
+        throw error;
       }
-    });
-  }
-  _fetch() {
-    return __async(this, null, function* () {
-      for (const hook of this._options.hooks.beforeRequest) {
-        const result = yield hook(this.request, this._options);
-        if (result instanceof Request) {
-          this.request = result;
+      yield delay(ms, __privateGet(this, _userProvidedAbortSignal) ? { signal: __privateGet(this, _userProvidedAbortSignal) } : {});
+      if (error instanceof ForceRetryError && error.customRequest) {
+        const managedRequest = __privateGet(this, _options).signal ? new globalThis.Request(error.customRequest, { signal: __privateGet(this, _options).signal }) : new globalThis.Request(error.customRequest);
+        __privateMethod(this, _Ky_instances, assignRequest_fn).call(this, managedRequest);
+      }
+      for (const hook of __privateGet(this, _options).hooks.beforeRetry) {
+        const hookResult = yield hook({
+          request: this.request,
+          options: __privateMethod(this, _Ky_instances, getNormalizedOptions_fn).call(this),
+          error,
+          retryCount: __privateGet(this, _retryCount)
+        });
+        if (hookResult instanceof globalThis.Request) {
+          __privateMethod(this, _Ky_instances, assignRequest_fn).call(this, hookResult);
           break;
         }
-        if (result instanceof Response) {
-          return result;
+        if (hookResult instanceof globalThis.Response) {
+          return hookResult;
+        }
+        if (hookResult === stop) {
+          return;
         }
       }
-      const nonRequestOptions = findUnknownOptions(this.request, this._options);
-      this._originalRequest = this.request;
-      this.request = this._originalRequest.clone();
-      if (this._options.timeout === false) {
-        return this._options.fetch(this._originalRequest, nonRequestOptions);
+      return __privateMethod(this, _Ky_instances, retry_fn).call(this, function_);
+    }
+  });
+};
+fetch_fn = function() {
+  return __async(this, null, function* () {
+    var _a;
+    if ((_a = __privateGet(this, _abortController)) == null ? void 0 : _a.signal.aborted) {
+      __privateSet(this, _abortController, new globalThis.AbortController());
+      __privateGet(this, _options).signal = __privateGet(this, _userProvidedAbortSignal) ? AbortSignal.any([__privateGet(this, _userProvidedAbortSignal), __privateGet(this, _abortController).signal]) : __privateGet(this, _abortController).signal;
+      this.request = new globalThis.Request(this.request, { signal: __privateGet(this, _options).signal });
+    }
+    for (const hook of __privateGet(this, _options).hooks.beforeRequest) {
+      const result = yield hook(this.request, __privateMethod(this, _Ky_instances, getNormalizedOptions_fn).call(this), { retryCount: __privateGet(this, _retryCount) });
+      if (result instanceof Response) {
+        return result;
+      }
+      if (result instanceof globalThis.Request) {
+        __privateMethod(this, _Ky_instances, assignRequest_fn).call(this, result);
+        break;
       }
-      return timeout(this._originalRequest, nonRequestOptions, this.abortController, this._options);
-    });
+    }
+    const nonRequestOptions = findUnknownOptions(this.request, __privateGet(this, _options));
+    __privateSet(this, _originalRequest, this.request);
+    this.request = __privateGet(this, _originalRequest).clone();
+    if (__privateGet(this, _options).timeout === false) {
+      return __privateGet(this, _options).fetch(__privateGet(this, _originalRequest), nonRequestOptions);
+    }
+    return timeout(__privateGet(this, _originalRequest), nonRequestOptions, __privateGet(this, _abortController), __privateGet(this, _options));
+  });
+};
+getNormalizedOptions_fn = function() {
+  if (!__privateGet(this, _cachedNormalizedOptions)) {
+    const _a = __privateGet(this, _options), { hooks } = _a, normalizedOptions = __objRest(_a, ["hooks"]);
+    __privateSet(this, _cachedNormalizedOptions, Object.freeze(normalizedOptions));
   }
+  return __privateGet(this, _cachedNormalizedOptions);
 };
-_Ky_static = new WeakSet();
-normalizeSearchParams_fn = function(searchParams) {
-  if (searchParams && typeof searchParams === "object" && !Array.isArray(searchParams) && !(searchParams instanceof URLSearchParams)) {
-    return Object.fromEntries(Object.entries(searchParams).filter(([, value]) => value !== void 0));
+assignRequest_fn = function(request) {
+  __privateSet(this, _cachedNormalizedOptions, void 0);
+  this.request = __privateMethod(this, _Ky_instances, wrapRequestWithUploadProgress_fn).call(this, request);
+};
+wrapRequestWithUploadProgress_fn = function(request, originalBody) {
+  var _a;
+  if (!__privateGet(this, _options).onUploadProgress || !request.body) {
+    return request;
   }
-  return searchParams;
+  return streamRequest(request, __privateGet(this, _options).onUploadProgress, (_a = originalBody != null ? originalBody : __privateGet(this, _options).body) != null ? _a : void 0);
 };
 __privateAdd(_Ky, _Ky_static);
 var Ky = _Ky;
 
-// node_modules/.pnpm/ky@1.11.0/node_modules/ky/distribution/index.js
+// node_modules/.pnpm/ky@1.14.3/node_modules/ky/distribution/index.js
 var createInstance = (defaults) => {
   const ky2 = (input, options) => Ky.create(input, validateAndMerge(defaults, options));
   for (const method of requestMethods) {
@@ -688,29 +941,128 @@ var createInstance = (defaults) => {
     return createInstance(validateAndMerge(defaults, newDefaults));
   };
   ky2.stop = stop;
+  ky2.retry = retry;
   return ky2;
 };
 var ky = createInstance();
 var distribution_default = ky;
 
+// src/email/emails.ts
+var import_render = require("@react-email/render");
+var Emails = class {
+  constructor(zupost) {
+    this.zupost = zupost;
+  }
+  /**
+   * Send an email using template, markdown or HTML content.
+   *
+   * @param options - Email options including recipient, sender, and content.
+   * @returns A promise that resolves to the email response containing emailId.
+   *
+   * @example
+   * ```typescript
+   * const zupost = new Zupost('your-api-key');
+   *
+   * // Send with HTML content
+   * const { emailId } = await zupost.emails.send({
+   *   from: 'sender@example.com',
+   *   to: 'recipient@example.com',
+   *   subject: 'Hello World',
+   *   html: '<h1>Hello!</h1>',
+   * });
+   *
+   * // Send with a template
+   * await zupost.emails.send({
+   *   from: 'sender@example.com',
+   *   to: ['user1@example.com', 'user2@example.com'],
+   *   subject: 'Welcome!',
+   *   templateId: 'welcome-template',
+   *   variables: { name: 'John' },
+   * });
+   *
+   * // Send with markdown
+   * await zupost.emails.send({
+   *   from: 'sender@example.com',
+   *   to: 'recipient@example.com',
+   *   subject: 'Newsletter',
+   *   markdown: '# Hello\n\nThis is **markdown** content.',
+   * });
+   * ```
+   */
+  send(options) {
+    return __async(this, null, function* () {
+      if (options.react) {
+        options.html = yield (0, import_render.render)(options.react, options.reactOptions);
+        delete options.react;
+        delete options.reactOptions;
+      }
+      if (!options.html && !options.markdown && !options.react && !options.templateId) {
+        throw new Error("Either html, markdown, react or templateId must be provided");
+      }
+      if (options.html && options.markdown) {
+        throw new Error("Either html or markdown must be provided");
+      }
+      if (options.react && options.html) {
+        throw new Error("Either react or html must be provided");
+      }
+      return this.zupost.post("email/send", options);
+    });
+  }
+};
+
+// src/campaign/campaigns.ts
+var Campaigns = class {
+  constructor(zupost) {
+    this.zupost = zupost;
+  }
+  /**
+   * Send a campaign to selected audiences.
+   *
+   * @param options - Campaign options including the campaign ID.
+   * @returns A promise that resolves to the campaign response.
+   *
+   * @example
+   * ```typescript
+   * const zupost = new Zupost('your-api-key');
+   *
+   * const { success, message } = await zupost.campaigns.send({
+   *   campaignId: 'campaign_123',
+   * });
+   *
+   * if (success) {
+   *   console.log('Campaign sent:', message);
+   * }
+   * ```
+   */
+  send(options) {
+    return __async(this, null, function* () {
+      return this.zupost.post("campaign/send", options);
+    });
+  }
+};
+
 // src/zupost.ts
 var Zupost = class {
-  constructor(apiKey, apiUrl) {
-    this.apiKey = apiKey;
-    this.apiUrl = apiUrl;
+  constructor(apiKey, options) {
     this.baseUrl = "https://api.zupost.com";
     if (!apiKey) {
       throw new Error("API key is required");
     }
-    if (apiUrl) {
-      this.baseUrl = apiUrl;
+    if (options == null ? void 0 : options.baseUrl) {
+      this.baseUrl = options.baseUrl;
     }
     this.headers = new Headers({
       "Authorization": `Bearer ${apiKey}`,
       "Content-Type": "application/json",
       "User-Agent": `node-sdk@${version}`
     });
+    this.emails = new Emails(this);
+    this.campaigns = new Campaigns(this);
   }
+  /**
+   * @internal
+   * Makes a request to the Zupost API.
+   */
   request(path, method, body) {
     return __async(this, null, function* () {
       return distribution_default(path, {
@@ -718,15 +1070,23 @@ var Zupost = class {
         method,
         retry: 3,
         prefixUrl: this.baseUrl,
-        body
+        json: body
       }).json();
     });
   }
+  /**
+   * @internal
+   * Makes a GET request to the Zupost API.
+   */
   get(path) {
     return __async(this, null, function* () {
       return this.request(path, "GET");
     });
   }
+  /**
+   * @internal
+   * Makes a POST request to the Zupost API.
+   */
   post(path, body) {
     return __async(this, null, function* () {
       return this.request(path, "POST", body);