@interware/content-generator 0.4.4 → 0.6.0

package/dist/server/index.js

@@ -1,6 +1,6 @@
 "use strict";
-const genai = require("@google/genai");
 const fs = require("fs");
+const genai = require("@google/genai");
 function _interopNamespace(e) {
   if (e && e.__esModule) return e;
   const n = Object.create(null, { [Symbol.toStringTag]: { value: "Module" } });
@@ -20,7 +20,28 @@ function _interopNamespace(e) {
 }
 const fs__namespace = /* @__PURE__ */ _interopNamespace(fs);
 const PLUGIN_ID = "strapi-content-generator-gemini";
-const bootstrap = ({ strapi }) => {
+const FOLDER_UID = "plugin::upload.folder";
+const hasValidPath = (path) => /^(\/\d+)+$/.test(path);
+const repairFolderPaths = async (strapi, name2) => {
+  const query = strapi.db.query(FOLDER_UID);
+  const folders = await query.findMany({ where: { name: name2 }, populate: ["parent"] });
+  const repaired = [];
+  for (const f of folders) {
+    if (hasValidPath(f.path)) continue;
+    const to = `${f.parent?.path ?? ""}/${f.pathId}`;
+    await query.update({ where: { id: f.id }, data: { path: to } });
+    repaired.push({ id: f.id, from: f.path, to });
+  }
+  return repaired;
+};
+const ensureFolder = async (strapi, name2) => {
+  const folders = await strapi.db.query(FOLDER_UID).findMany({ where: { name: name2 }, populate: ["parent"] });
+  const atRoot = folders.find((f) => !f.parent);
+  if (atRoot) return atRoot.id;
+  const created = await strapi.plugin("upload").service("folder").create({ name: name2, parent: null });
+  return created.id;
+};
+const bootstrap = async ({ strapi }) => {
   strapi.admin.services.permission.actionProvider.registerMany([
     {
       section: "plugins",
@@ -29,17 +50,56 @@ const bootstrap = ({ strapi }) => {
       pluginName: PLUGIN_ID
     }
   ]);
+  try {
+    for (const r of await repairFolderPaths(strapi, "Generated")) {
+      strapi.log.info(`[content-generator] path de carpeta ${r.id} corregido: ${r.from} → ${r.to}`);
+    }
+  } catch (err) {
+    strapi.log.warn(`[content-generator] no se pudo revisar el path de «Generated»: ${err.message}`);
+  }
 };
 const destroy = ({ strapi }) => {
 };
 const register = ({ strapi }) => {
 };
-const config$1 = {
+const config$2 = {
   default: {},
   validator() {
   }
 };
-const contentTypes = {};
+const schema = {
+  kind: "collectionType",
+  collectionName: "iw_image_templates",
+  info: {
+    singularName: "template",
+    pluralName: "templates",
+    displayName: "Template de imagen",
+    description: "Templates del Estudio de imágenes (content-generator)"
+  },
+  options: { draftAndPublish: false },
+  pluginOptions: {
+    "content-manager": { visible: false },
+    "content-type-builder": { visible: false }
+  },
+  attributes: {
+    name: { type: "string", required: true, maxLength: 120 },
+    folder: { type: "string", default: "" },
+    width: { type: "integer", required: true },
+    height: { type: "integer", required: true },
+    background: { type: "string", default: "#FFFFFF" },
+    safeMargin: { type: "integer", default: 0 },
+    gridUnit: { type: "integer", default: 60 },
+    layers: { type: "json", required: true },
+    /** Base de la que se copió (origen). */
+    baseId: { type: "string" },
+    /** Si está, esta fila es la versión editada de esa plantilla base (S4.15): una por base. */
+    replacesBase: { type: "string" }
+  }
+};
+const template = { schema };
+const contentTypes = {
+  template
+};
 const controller = ({ strapi }) => {
   const pluginService = () => strapi.plugin("strapi-content-generator-gemini").service("service");
   return {
@@ -94,39 +154,12 @@ const controller = ({ strapi }) => {
         auth: ctx.state.auth
       });
     },
-    async getImages(ctx) {
-      const contentType = strapi.contentType("plugin::upload.file");
-      const files = await pluginService().getImagenes();
-      return await strapi.contentAPI.sanitize.output(files, contentType, {
-        auth: ctx.state.auth
-      });
-    },
-    async deleteImage(ctx) {
-      const contentType = strapi.contentType("plugin::upload.file");
-      await strapi.contentAPI.validate.query(ctx.query, contentType, {
-        auth: ctx.state.auth
-      });
-      const sanitizedQueryParams = await strapi.contentAPI.sanitize.query(
-        ctx.query,
-        contentType,
-        {
-          auth: ctx.state.auth
-        }
-      );
-      const file = await pluginService().eliminarImagen(sanitizedQueryParams);
-      return await strapi.contentAPI.sanitize.output(file, contentType, {
-        auth: ctx.state.auth
-      });
-    },
     async generateArticle(ctx) {
       ctx.body = await pluginService().generateArticle(ctx);
     },
     async generateImageForArticle(ctx) {
       ctx.body = await pluginService().generateImageForArticle(ctx);
     },
-    async generateImage(ctx) {
-      ctx.body = await pluginService().generateImage(ctx);
-    },
     async downloadFile(ctx) {
       await pluginService().downloadFile(ctx);
     },
@@ -138,195 +171,769 @@ const controller = ({ strapi }) => {
     },
     async publishToFacebook(ctx) {
       ctx.body = await pluginService().publishToFacebook(ctx);
-    },
-    async get(ctx) {
-      const pluginStore = strapi.store({
-        type: "plugin",
-        name: "strapi-content-generator-gemini"
-      });
-      const googleGenAI = await pluginStore.get({ key: "GOOGLE_GEN_AI" });
-      const clientURL = await pluginStore.get({ key: "CLIENT_URL" });
-      const previewSecret = await pluginStore.get({ key: "PREVIEW_SECRET" });
-      ctx.body = { googleGenAI, clientURL, previewSecret };
-    },
-    async set(ctx) {
-      const { key1, key2, key3 } = ctx.request.body;
-      const pluginStore = strapi.store({
-        type: "plugin",
-        name: "strapi-content-generator-gemini"
-      });
-      await pluginStore.set({ key: "GOOGLE_GEN_AI", value: key1 });
-      await pluginStore.set({ key: "CLIENT_URL", value: key2 });
-      await pluginStore.set({ key: "PREVIEW_SECRET", value: key3 });
-      ctx.body = { ok: true };
     }
   };
 };
-const config = ({ strapi }) => {
+const maskSecret = (value) => {
+  if (typeof value !== "string" || value.length === 0) {
+    return { configured: false, last4: null };
+  }
+  return { configured: true, last4: value.slice(-4) };
+};
+const VERTEX_KEY = "VERTEX_SERVICE_ACCOUNT";
+const REQUIRED = ["project_id", "client_email", "private_key"];
+const parseServiceAccount = (value) => {
+  if (typeof value !== "string") return { ok: false, message: "El texto no es un JSON válido." };
+  let data;
+  try {
+    const parsed = JSON.parse(value);
+    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) throw new Error();
+    data = parsed;
+  } catch {
+    return { ok: false, message: "El texto no es un JSON válido." };
+  }
+  if (data.type !== "service_account") {
+    return { ok: false, message: "El JSON no es de una cuenta de servicio (type debe ser service_account)." };
+  }
+  const missing = REQUIRED.filter((k) => typeof data[k] !== "string" || data[k].trim() === "");
+  if (missing.length) return { ok: false, message: `El JSON no es de una cuenta de servicio: falta ${missing.join(", ")}.` };
+  return {
+    ok: true,
+    account: { projectId: data.project_id, clientEmail: data.client_email, privateKey: data.private_key }
+  };
+};
+const storedServiceAccount = (account) => JSON.stringify({ type: "service_account", project_id: account.projectId, client_email: account.clientEmail, private_key: account.privateKey });
+const publicServiceAccount = (stored) => {
+  const parsed = parseServiceAccount(stored);
+  if (!("account" in parsed)) return { configured: false, projectId: null, clientEmail: null };
+  return { configured: true, projectId: parsed.account.projectId, clientEmail: parsed.account.clientEmail };
+};
+const CREDENTIALS = {
+  googleGenAI: "GOOGLE_GEN_AI",
+  linkedInAccessToken: "LINKEDIN_ACCESS_TOKEN",
+  linkedInOrganizationId: "LINKEDIN_ORGANIZATION_ID",
+  facebookClientToken: "FACEBOOK_CLIENT_TOKEN",
+  facebookPageId: "FACEBOOK_PAGE_ID"
+};
+const FIELDS$1 = Object.keys(CREDENTIALS);
+const config$1 = ({ strapi }) => {
+  const pluginStore = () => strapi.store({
+    type: "plugin",
+    name: "strapi-content-generator-gemini"
+  });
   return {
+    /**
+     * Devuelve si cada credencial está guardada y sus últimos 4 caracteres, nunca el valor. Para Vertex,
+     * el proyecto y el correo de la cuenta de servicio, nunca la llave privada.
+     */
     async get(ctx) {
-      const pluginStore = strapi.store({
-        type: "plugin",
-        name: "strapi-content-generator-gemini"
-      });
-      const googleGenAI = await pluginStore.get({ key: "GOOGLE_GEN_AI" });
-      const linkedInAccessToken = await pluginStore.get({ key: "LINKEDIN_ACCESS_TOKEN" });
-      const linkedInOrganizationId = await pluginStore.get({ key: "LINKEDIN_ORGANIZATION_ID" });
-      const facebookClientToken = await pluginStore.get({ key: "FACEBOOK_CLIENT_TOKEN" });
-      const facebookPageId = await pluginStore.get({ key: "FACEBOOK_PAGE_ID" });
-      ctx.body = { googleGenAI, linkedInAccessToken, linkedInOrganizationId, facebookClientToken, facebookPageId };
+      const store = pluginStore();
+      const entries = await Promise.all(
+        FIELDS$1.map(async (field) => [field, maskSecret(await store.get({ key: CREDENTIALS[field] }))])
+      );
+      ctx.body = { ...Object.fromEntries(entries), vertex: publicServiceAccount(await store.get({ key: VERTEX_KEY })) };
     },
+    /**
+     * Escribe solo las credenciales conocidas que llegan como texto no vacío. Una cuenta de servicio
+     * inválida rechaza la petición completa (400) antes de escribir nada.
+     */
     async set(ctx) {
-      const { googleGenAI, linkedInAccessToken, linkedInOrganizationId, facebookClientToken, facebookPageId } = ctx.request.body;
-      const pluginStore = strapi.store({
-        type: "plugin",
-        name: "strapi-content-generator-gemini"
-      });
-      await pluginStore.set({ key: "GOOGLE_GEN_AI", value: googleGenAI });
-      await pluginStore.set({ key: "LINKEDIN_ACCESS_TOKEN", value: linkedInAccessToken });
-      await pluginStore.set({ key: "LINKEDIN_ORGANIZATION_ID", value: linkedInOrganizationId });
-      await pluginStore.set({ key: "FACEBOOK_CLIENT_TOKEN", value: facebookClientToken });
-      await pluginStore.set({ key: "FACEBOOK_PAGE_ID", value: facebookPageId });
+      const body = ctx.request.body ?? {};
+      const store = pluginStore();
+      const vertex = typeof body.vertexServiceAccount === "string" && body.vertexServiceAccount.trim() !== "" ? parseServiceAccount(body.vertexServiceAccount) : null;
+      if (vertex && "message" in vertex) {
+        ctx.status = 400;
+        ctx.body = { data: null, error: { status: 400, name: "ValidationError", message: vertex.message } };
+        return;
+      }
+      if (vertex && "account" in vertex) await store.set({ key: VERTEX_KEY, value: storedServiceAccount(vertex.account) });
+      for (const field of FIELDS$1) {
+        const value = body[field];
+        if (typeof value === "string" && value.length > 0) {
+          await store.set({ key: CREDENTIALS[field], value });
+        }
+      }
+      ctx.body = { ok: true };
+    },
+    /** Quita la cuenta de servicio: el plugin vuelve a la llave de la Gemini API (S5.1). */
+    async removeVertex(ctx) {
+      await pluginStore().delete({ key: VERTEX_KEY });
       ctx.body = { ok: true };
     }
   };
 };
-const controllers = {
-  controller,
-  config
+const PEOPLE_CLAUSE = "STRICTLY NO people, NO humans, NO faces, NO hands.";
+const HARM_CATEGORIES = [
+  genai.HarmCategory.HARM_CATEGORY_HARASSMENT,
+  genai.HarmCategory.HARM_CATEGORY_HATE_SPEECH,
+  genai.HarmCategory.HARM_CATEGORY_SEXUALLY_EXPLICIT,
+  genai.HarmCategory.HARM_CATEGORY_DANGEROUS_CONTENT
+];
+const safetySettings = (safety) => HARM_CATEGORIES.map((category) => ({
+  category,
+  threshold: safety ? genai.HarmBlockThreshold.BLOCK_MEDIUM_AND_ABOVE : genai.HarmBlockThreshold.BLOCK_ONLY_HIGH
+}));
+const PEOPLE = {
+  none: "ALLOW_NONE",
+  adults: genai.PersonGeneration.ALLOW_ADULT
 };
-const middlewares = {};
-const policies = {};
-const admin = [
-  {
-    method: "GET",
-    path: "/posts",
-    handler: "controller.getArticles",
-    config: {
-      policies: [],
-      auth: false
-    }
-  },
-  {
-    method: "GET",
-    path: "/categories",
-    handler: "controller.getCategories",
-    config: {
-      policies: [],
-      auth: false
+const imageConfig = ({ aspectRatio, imageSize, allowPeople }, backend = "gemini-api") => ({
+  ...aspectRatio ? { aspectRatio } : {},
+  ...imageSize ? { imageSize } : {},
+  ...backend === "vertex" ? { personGeneration: allowPeople ? PEOPLE.adults : PEOPLE.none } : {}
+});
+const promptPart = (text2, allowPeople, backend = "gemini-api") => ({
+  text: backend === "gemini-api" && !allowPeople ? `${text2} ${PEOPLE_CLAUSE}` : text2
+});
+const searchTool = () => ({ googleSearch: { searchTypes: { webSearch: {}, imageSearch: {} } } });
+const generateConfig = ({ aspectRatio, imageSize, allowPeople, safety, grounding }, backend = "gemini-api") => ({
+  // Con búsqueda el modelo responde texto e imagen.
+  responseModalities: grounding ? [genai.Modality.TEXT, genai.Modality.IMAGE] : [genai.Modality.IMAGE],
+  imageConfig: imageConfig({ aspectRatio, imageSize, allowPeople }, backend),
+  safetySettings: safetySettings(safety),
+  ...grounding ? { tools: [searchTool()] } : {}
+});
+const editConfig = ({ safety, allowPeople, aspectRatio }, backend = "gemini-api") => ({
+  responseModalities: [genai.Modality.IMAGE],
+  imageConfig: imageConfig({ aspectRatio, allowPeople }, backend),
+  safetySettings: safetySettings(safety)
+});
+const inlinePart = (bytes, mimeType) => ({ inlineData: { mimeType, data: bytes.toString("base64") } });
+const RATIOS = ["1:1", "2:3", "3:2", "3:4", "4:3", "4:5", "5:4", "9:16", "16:9", "21:9"];
+const FLASH_RATIOS = [...RATIOS, "1:4", "4:1", "1:8", "8:1"];
+const FLASH = { maxReferences: 6, sizes: ["512", "1K", "2K", "4K"], aspectRatios: FLASH_RATIOS, canEdit: true, grounding: true };
+const FLASH_LITE = { maxReferences: 6, sizes: ["512", "1K"], aspectRatios: RATIOS, canEdit: true, grounding: false };
+const PRO = { maxReferences: 6, sizes: ["1K", "2K", "4K"], aspectRatios: RATIOS, canEdit: true, grounding: false };
+const IMAGE_MODELS = [
+  { id: "gemini-3.1-flash-image", label: "Nano Banana 2", ...FLASH },
+  { id: "gemini-3.1-flash-image-preview", label: "Nano Banana 2 (preview)", ...FLASH },
+  { id: "gemini-3.1-flash-lite-image", label: "Nano Banana 2 Lite", ...FLASH_LITE },
+  { id: "gemini-3.1-flash-lite-image-preview", label: "Nano Banana 2 Lite (preview)", ...FLASH_LITE },
+  { id: "gemini-3-pro-image", label: "Nano Banana Pro", ...PRO },
+  { id: "gemini-3-pro-image-preview", label: "Nano Banana Pro (preview)", ...PRO },
+  { id: "gemini-2.5-flash-image", label: "Nano Banana (legado)", maxReferences: 3, sizes: [], aspectRatios: RATIOS, canEdit: true, grounding: false }
+];
+const findModel = (id) => IMAGE_MODELS.find((m) => m.id === id);
+const availableModels = (listed) => {
+  if (!listed) return { models: IMAGE_MODELS, verified: false };
+  const ids = new Set(listed.map((n) => n.replace(/^(publishers\/google\/)?models\//, "")));
+  const models = IMAGE_MODELS.filter((m) => ids.has(m.id) && !(m.id.endsWith("-preview") && ids.has(m.id.replace(/-preview$/, ""))));
+  return models.length ? { models, verified: true } : { models: IMAGE_MODELS, verified: false };
+};
+const editModelFor = (id) => {
+  const chosen = findModel(id);
+  if (chosen?.canEdit) return chosen;
+  return IMAGE_MODELS.find((m) => m.canEdit);
+};
+const PROMPT_MAX = 2e3;
+const CONTROL = /[\u0000-\u0008\u000B\u000C\u000E-\u001F\u007F-\u009F]/g;
+const INVISIBLE = /[­​-‏‪-‮⁠-⁤⁦-⁩]/g;
+const TAG = /<\/?[a-z][^>]*>/gi;
+const sanitizePrompt = (text2) => text2.normalize("NFC").replace(CONTROL, "").replace(INVISIBLE, "").replace(TAG, "").replace(/\s+/g, " ").trim();
+const PROMPT_LABELS = { label: "El prompt", empty: "Escribe un prompt." };
+const INSTRUCTION_LABELS = { label: "La instrucción", empty: "Describe el cambio que quieres." };
+const checkPrompt = (text2, { label, empty } = PROMPT_LABELS) => {
+  const clean2 = sanitizePrompt(text2);
+  if (!clean2) return { ok: false, error: empty };
+  if ([...clean2].length > PROMPT_MAX) return { ok: false, error: `${label} puede tener hasta ${PROMPT_MAX} caracteres.` };
+  return { ok: true, text: clean2 };
+};
+const cleanPrompt = sanitizePrompt;
+const EXPAND_INSTRUCTION = (concept) => [
+  "Eres experto en prompts para generadores de imágenes con IA.",
+  "Expande y mejora este concepto con sujeto, composición, estilo, iluminación y color.",
+  "Responde solo con el prompt mejorado, en español, sin explicaciones, comillas ni viñetas.",
+  `Concepto: ${concept}`
+].join("\n");
+class BlockedError extends Error {
+}
+const sourceOf = (chunk) => {
+  if (chunk.web?.uri) return { title: chunk.web.title || new URL(chunk.web.uri).hostname, uri: chunk.web.uri };
+  const img = chunk.image;
+  if (img?.sourceUri) return { title: img.title || img.domain || new URL(img.sourceUri).hostname, uri: img.sourceUri };
+  return null;
+};
+const groundingFrom = (res) => {
+  const meta = res.candidates?.[0]?.groundingMetadata;
+  const sources = (meta?.groundingChunks ?? []).map(sourceOf).filter((src) => src !== null).filter((src, i, all3) => all3.findIndex((o) => o.title === src.title) === i);
+  const queries = [.../* @__PURE__ */ new Set([...meta?.webSearchQueries ?? [], ...meta?.imageSearchQueries ?? []])];
+  const suggestions = meta?.searchEntryPoint?.renderedContent;
+  if (!sources.length && !queries.length && !suggestions) return void 0;
+  return { ...suggestions ? { suggestions } : {}, queries, sources };
+};
+const EXPAND_MODEL = "gemini-2.5-flash";
+const BLOCK_REASONS = {
+  SAFETY: "El modelo bloqueó la solicitud por seguridad. Ajusta el prompt o la imagen.",
+  PROHIBITED_CONTENT: "El modelo bloqueó la solicitud por contenido no permitido.",
+  IMAGE_SAFETY: "El modelo bloqueó la imagen resultante por seguridad."
+};
+const imageFrom = (res, model) => {
+  const parts = res.candidates?.[0]?.content?.parts ?? [];
+  const part = parts.find((p) => p.inlineData?.data && (p.inlineData.mimeType ?? "").startsWith("image/"));
+  if (part?.inlineData?.data) return { image: part.inlineData.data, mimeType: part.inlineData.mimeType ?? "image/png", model };
+  const reason = res.promptFeedback?.blockReason ?? res.candidates?.[0]?.finishReason;
+  throw new BlockedError(BLOCK_REASONS[String(reason)] ?? "El modelo no devolvió una imagen. Intenta con otro prompt.");
+};
+const inline = async (file, read) => inlinePart(await read(file.filepath), file.mimetype ?? "image/png");
+const userTurn = (parts) => [{ role: "user", parts }];
+const createImageStudio = (getClient, read = (p) => fs.promises.readFile(p)) => ({
+  async models() {
+    try {
+      const { models: api } = await getClient();
+      const names = [];
+      for await (const m of await api.list({ config: { pageSize: 100 } })) if (m.name) names.push(m.name);
+      return availableModels(names);
+    } catch {
+      return availableModels(null);
     }
   },
-  {
-    method: "GET",
-    path: "/users",
-    handler: "controller.getUsers",
-    config: {
-      policies: [],
-      auth: false
-    }
+  /**
+   * Imagen para un artículo (S4.12): antes usaba Imagen 4, que Google apagó. Usa el primer modelo
+   * disponible del catálogo y ajusta proporción y tamaño a lo que admite. Devuelve base64.
+   */
+  async generateForArticle(prompt, aspectRatio, imageSize) {
+    const [model] = (await this.models()).models;
+    const { image } = await this.generate({
+      prompt,
+      model,
+      aspectRatio: model.aspectRatios.includes(aspectRatio) ? aspectRatio : "16:9",
+      imageSize: model.sizes.includes(imageSize) ? imageSize : void 0,
+      safety: true,
+      // El estilo de marca de los artículos no lleva personas (su JSON ya lo pide); ahora también el parámetro.
+      allowPeople: false,
+      grounding: false,
+      references: []
+    });
+    return image;
   },
-  {
-    method: "GET",
-    path: "/images",
-    handler: "controller.getImages",
-    config: {
-      policies: [],
-      auth: false
-    }
+  async generate(input) {
+    const { models: api, backend } = await getClient();
+    const text2 = cleanPrompt(input.prompt);
+    const { model } = input;
+    const refs = await Promise.all(input.references.map((f) => inline(f, read)));
+    const request = {
+      model: model.id,
+      contents: userTurn([promptPart(text2, input.allowPeople, backend), ...refs]),
+      config: generateConfig(input, backend)
+    };
+    const res = await api.generateContent(request);
+    const image = imageFrom(res, model.id);
+    const grounding = input.grounding ? groundingFrom(res) : void 0;
+    return grounding ? { ...image, grounding } : image;
   },
-  {
-    method: "DELETE",
-    path: "/delete-image",
-    handler: "controller.deleteImage",
-    config: {
-      policies: [],
-      auth: false
-    }
+  async edit(input) {
+    const { models: api, backend } = await getClient();
+    const parts = [
+      await inline(input.image, read),
+      ...await Promise.all(input.references.map((f) => inline(f, read))),
+      promptPart(input.instruction, input.allowPeople, backend)
+    ];
+    const request = { model: input.model.id, contents: userTurn(parts), config: editConfig(input, backend) };
+    const res = await api.generateContent(request);
+    return imageFrom(res, input.model.id);
   },
-  {
-    method: "POST",
-    path: "/download-file",
-    handler: "controller.downloadFile",
-    config: {
-      policies: [],
-      auth: false
+  async expand(prompt) {
+    const { models: api } = await getClient();
+    const res = await api.generateContent({ model: EXPAND_MODEL, contents: EXPAND_INSTRUCTION(cleanPrompt(prompt)) });
+    const text2 = (res.text ?? "").trim().replace(/^["'«“]+|["'»”]+$/g, "").trim();
+    if (!text2) throw new BlockedError("No se pudo expandir la idea. Intenta de nuevo.");
+    return text2;
+  }
+});
+const imageStudio$1 = ({ strapi }) => createImageStudio(async () => {
+  const { ai, backend } = await strapi.plugin("strapi-content-generator-gemini").service("service").geminiClient();
+  return { models: ai.models, backend };
+});
+class InputError extends Error {
+}
+const ALLOWED = ["image/png", "image/jpeg", "image/webp"];
+const MAX_BYTES = 10 * 1024 * 1024;
+const str = (v) => typeof v === "string" ? v : "";
+const bool = (v) => v === true || v === "true";
+const list = (v) => v ? Array.isArray(v) ? v : [v] : [];
+const clean = (text2, labels) => {
+  const r = checkPrompt(text2, labels);
+  if ("error" in r) throw new InputError(r.error);
+  return r.text;
+};
+const checkImage = (f) => {
+  if (!ALLOWED.includes(f.mimetype ?? "")) throw new InputError("Las imágenes deben ser PNG, JPG o WEBP.");
+  if (f.size > MAX_BYTES) throw new InputError("Cada imagen puede pesar hasta 10 MB.");
+  return f;
+};
+const parseGenerateInput = (fields, files) => {
+  const prompt = clean(str(fields.prompt));
+  const model = findModel(str(fields.model));
+  if (!model) throw new InputError("Modelo no disponible.");
+  const aspectRatio = str(fields.aspectRatio) || "1:1";
+  if (!model.aspectRatios.includes(aspectRatio)) throw new InputError(`Proporción no disponible para ${model.label}.`);
+  const references = list(files.references).map(checkImage);
+  if (references.length && model.maxReferences === 0) throw new InputError(`${model.label} no acepta imágenes de referencia.`);
+  if (references.length > model.maxReferences) throw new InputError(`Máximo ${model.maxReferences} imágenes de referencia con ${model.label}.`);
+  const size2 = str(fields.imageSize);
+  return {
+    prompt,
+    model,
+    aspectRatio,
+    imageSize: model.sizes.includes(size2) ? size2 : void 0,
+    safety: fields.safety === void 0 ? true : bool(fields.safety),
+    allowPeople: bool(fields.allowPeople),
+    grounding: model.grounding && bool(fields.grounding),
+    references
+  };
+};
+const parseEditInput = (fields, files) => {
+  const instruction = clean(str(fields.instruction), INSTRUCTION_LABELS);
+  const [image] = list(files.image);
+  if (!image) throw new InputError("Falta la imagen a editar.");
+  const model = editModelFor(str(fields.model) || void 0);
+  const max = Math.max(0, model.maxReferences - 1);
+  const references = list(files.references).map(checkImage);
+  if (references.length > max) throw new InputError(`Máximo ${max} elementos para el cambio con ${model.label}.`);
+  return {
+    instruction,
+    model,
+    image: checkImage(image),
+    references,
+    // Sin los campos (clientes anteriores a S4.13): con seguridad y sin excluir personas, como antes.
+    safety: fields.safety === void 0 ? true : bool(fields.safety),
+    allowPeople: fields.allowPeople === void 0 ? true : bool(fields.allowPeople),
+    aspectRatio: model.aspectRatios.includes(str(fields.aspectRatio)) ? str(fields.aspectRatio) : void 0
+  };
+};
+const fail$2 = (ctx, status, name2, message) => {
+  ctx.status = status;
+  ctx.body = { data: null, error: { status, name: name2, message } };
+};
+const imageStudio = ({ strapi }) => {
+  const studio = () => strapi.plugin("strapi-content-generator-gemini").service("image-studio");
+  const run = async (ctx, work) => {
+    try {
+      ctx.body = await work();
+    } catch (err) {
+      if (err instanceof InputError) return fail$2(ctx, 400, "BadRequestError", err.message);
+      if (err instanceof BlockedError) return fail$2(ctx, 422, "UnprocessableEntityError", err.message);
+      strapi.log.error(`[image-studio] ${err instanceof Error ? err.message : String(err)}`);
+      return fail$2(ctx, 502, "BadGatewayError", "El servicio de imágenes no respondió. Intenta de nuevo en un momento.");
     }
-  },
+  };
+  return {
+    models: (ctx) => run(ctx, () => studio().models()),
+    generate: (ctx) => run(ctx, () => studio().generate(parseGenerateInput(ctx.request.body ?? {}, ctx.request.files ?? {}))),
+    edit: (ctx) => run(ctx, () => studio().edit(parseEditInput(ctx.request.body ?? {}, ctx.request.files ?? {}))),
+    expand: (ctx) => run(ctx, async () => {
+      const raw = typeof ctx.request.body?.prompt === "string" ? ctx.request.body.prompt : "";
+      const prompt = clean(raw, { label: "La idea", empty: "Escribe una idea para expandir." });
+      return { prompt: await studio().expand(prompt) };
+    })
+  };
+};
+const NAVY = "#1F2A44";
+const RED = "#E4002B";
+const TEAL = "#00C7B1";
+const GREY = "#5B6473";
+const PAPER = "#EEF1F5";
+const WHITE = "#FFFFFF";
+const WHITE_75 = "rgba(255,255,255,0.75)";
+const WHITE_60 = "rgba(255,255,255,0.6)";
+const WHITE_20 = "rgba(255,255,255,0.2)";
+const BASE_TEMPLATES = [
   {
-    method: "POST",
-    path: "/generate-article",
-    handler: "controller.generateArticle",
-    config: {
-      policies: [],
-      auth: false
-    }
+    id: "cuadrado_01",
+    name: "Cuadrado 01",
+    category: "Redes sociales",
+    tag: "1:1",
+    width: 1080,
+    height: 1080,
+    background: PAPER,
+    safeMargin: 80,
+    gridUnit: 60,
+    layers: [
+      { id: "logo", type: "logo", label: "Logo", x: 80, y: 80, color: NAVY, logoScale: 1.1 },
+      { id: "titulo", type: "text", label: "Título", x: 80, y: 280, w: 920, content: "Orquestación digital para empresas", fontSize: 90, fontWeight: 800, color: NAVY, font: "display", lineHeight: 1.08, letterSpacing: "-0.02em" },
+      { id: "divider", type: "rect", label: "Divisor", x: 80, y: 530, w: 420, h: 3, color: RED },
+      { id: "cuerpo", type: "text", label: "Cuerpo", x: 80, y: 580, w: 700, content: "29 años integrando, modernizando y operando los sistemas de las empresas en México.", fontSize: 36, fontWeight: 500, color: NAVY, lineHeight: 1.5 }
+    ]
   },
   {
-    method: "POST",
-    path: "/generate-image",
-    handler: "controller.generateImageForArticle",
-    config: {
-      policies: [],
-      auth: false
-    }
+    id: "cuadrado_dark",
+    name: "Cuadrado Dark",
+    category: "Redes sociales",
+    tag: "1:1",
+    width: 1080,
+    height: 1080,
+    background: NAVY,
+    safeMargin: 80,
+    gridUnit: 60,
+    layers: [
+      { id: "accent_top", type: "rect", label: "Acento superior", x: 0, y: 0, w: 1080, h: 6, color: RED },
+      { id: "watermark", type: "logo", label: "Marca de agua", x: 600, y: 700, color: WHITE, logoScale: 2.6, opacity: 0.1 },
+      { id: "logo", type: "logo", label: "Logo", x: 80, y: 86, color: WHITE, logoScale: 1.1 },
+      { id: "titulo", type: "text", label: "Título", x: 80, y: 280, w: 920, content: "Detectamos y resolvemos fallas antes de que lleguen a tu cliente", fontSize: 78, fontWeight: 800, color: WHITE, font: "display", lineHeight: 1.08, letterSpacing: "-0.02em" },
+      { id: "divider", type: "rect", label: "Divisor", x: 80, y: 560, w: 360, h: 3, color: TEAL },
+      { id: "cuerpo", type: "text", label: "Cuerpo", x: 80, y: 610, w: 700, content: "Observabilidad y operación continua para sistemas de misión crítica.", fontSize: 34, fontWeight: 500, color: WHITE_75, lineHeight: 1.5 }
+    ]
   },
   {
-    method: "POST",
-    path: "/generate-image-with-config",
-    handler: "controller.generateImage",
-    config: {
-      policies: [],
-      auth: false
-    }
+    id: "horizontal_01",
+    name: "Horizontal 01",
+    category: "Web / Blog",
+    tag: "16:9",
+    width: 1920,
+    height: 1080,
+    background: PAPER,
+    safeMargin: 100,
+    gridUnit: 80,
+    layers: [
+      { id: "right_panel", type: "rect", label: "Panel derecho", x: 1056, y: 0, w: 864, h: 1080, color: NAVY },
+      { id: "watermark", type: "logo", label: "Marca de agua", x: 1100, y: 200, color: WHITE, logoScale: 8, opacity: 0.08 },
+      { id: "logo", type: "logo", label: "Logo", x: 100, y: 100, color: NAVY, logoScale: 1.3 },
+      { id: "subtitulo", type: "text", label: "Subtítulo", x: 100, y: 600, w: 900, content: "Perspectivas para líderes de TI", fontSize: 28, fontWeight: 700, color: RED, textTransform: "uppercase", letterSpacing: "0.06em" },
+      { id: "titulo", type: "text", label: "Título", x: 100, y: 660, w: 900, content: "Evolución por continuidad", fontSize: 96, fontWeight: 800, color: NAVY, font: "display", lineHeight: 1, letterSpacing: "-0.02em" },
+      { id: "divider", type: "rect", label: "Divisor", x: 100, y: 880, w: 300, h: 4, color: NAVY },
+      { id: "url", type: "text", label: "URL", x: 100, y: 990, w: 800, content: "interware.com.mx", fontSize: 22, fontWeight: 500, color: GREY },
+      { id: "logo_right", type: "logo", label: "Logo derecho", x: 1700, y: 990, color: WHITE_60, logoScale: 1.5 }
+    ]
   },
   {
-    method: "POST",
-    path: "/generate-video-with-scenes",
-    handler: "controller.generateVideo",
-    config: {
-      policies: [],
-      auth: false
-    }
+    id: "story_01",
+    name: "Story / Reels",
+    category: "Redes sociales",
+    tag: "9:16",
+    width: 1080,
+    height: 1920,
+    background: NAVY,
+    safeMargin: 80,
+    gridUnit: 80,
+    layers: [
+      { id: "watermark", type: "logo", label: "Marca de agua", x: 700, y: -40, color: WHITE, logoScale: 7, opacity: 0.06, rotate: -15 },
+      { id: "accent", type: "rect", label: "Acento superior", x: 0, y: 0, w: 1080, h: 8, color: TEAL },
+      { id: "logo", type: "logo", label: "Logo", x: 80, y: 60, color: WHITE, logoScale: 1.1 },
+      { id: "line", type: "rect", label: "Línea", x: 80, y: 672, w: 60, h: 5, color: TEAL },
+      { id: "titulo", type: "text", label: "Título", x: 80, y: 720, w: 920, content: "Tu operación, orquestada", fontSize: 100, fontWeight: 800, color: WHITE, font: "display", lineHeight: 1.05, letterSpacing: "-0.02em" },
+      { id: "cta", type: "badge", label: "CTA", x: 80, y: 1670, content: "Conoce más →", paddingX: 32, paddingY: 16, bg: WHITE, fontSize: 34, fontWeight: 700, color: NAVY }
+    ]
   },
   {
-    method: "POST",
-    path: "/publish-linkedin",
-    handler: "controller.publishToLinkedIn",
-    config: {
-      policies: [],
-      auth: false
-    }
+    id: "blog_hero",
+    name: "Blog Hero",
+    category: "Web / Blog",
+    tag: "~2:1",
+    width: 1200,
+    height: 630,
+    background: PAPER,
+    safeMargin: 72,
+    gridUnit: 60,
+    layers: [
+      { id: "strip", type: "rect", label: "Franja izquierda", x: 0, y: 0, w: 8, h: 630, color: RED },
+      { id: "logo", type: "logo", label: "Logo", x: 80, y: 72, color: NAVY, logoScale: 1 },
+      { id: "categoria", type: "badge", label: "Categoría", x: 900, y: 72, content: "Infraestructura", paddingX: 18, paddingY: 8, bg: NAVY, fontSize: 22, fontWeight: 700, color: WHITE, textTransform: "uppercase", letterSpacing: "0.06em" },
+      { id: "titulo", type: "text", label: "Título", x: 80, y: 300, w: 1040, content: "La deuda técnica también se paga en horas de operación", fontSize: 60, fontWeight: 800, color: NAVY, font: "display", lineHeight: 1.1, letterSpacing: "-0.02em" },
+      { id: "divider", type: "rect", label: "Divisor", x: 80, y: 475, w: 200, h: 3, color: RED },
+      { id: "autor", type: "text", label: "Autor", x: 80, y: 500, w: 800, content: "Por el equipo de InterWare", fontSize: 24, fontWeight: 600, color: GREY }
+    ]
   },
   {
-    method: "POST",
-    path: "/publish-facebook",
-    handler: "controller.publishToFacebook",
-    config: {
-      policies: [],
-      auth: false
-    }
+    id: "linkedin_banner",
+    name: "LinkedIn Banner",
+    category: "LinkedIn",
+    tag: "4:1",
+    width: 1584,
+    height: 396,
+    background: NAVY,
+    safeMargin: 60,
+    gridUnit: 60,
+    layers: [
+      { id: "watermark", type: "logo", label: "Marca de agua", x: 1100, y: -40, color: WHITE, logoScale: 9, opacity: 0.05 },
+      { id: "strip", type: "rect", label: "Franja", x: 0, y: 0, w: 6, h: 396, color: TEAL, gradient: `linear-gradient(to bottom, ${TEAL}, ${NAVY})` },
+      { id: "logo", type: "logo", label: "Logo", x: 60, y: 150, color: WHITE, logoScale: 1.4 },
+      { id: "vdivider", type: "rect", label: "Divisor vertical", x: 320, y: 158, w: 2, h: 80, color: WHITE_20 },
+      { id: "nombre", type: "text", label: "Nombre", x: 360, y: 140, w: 1100, content: "InterWare de México", fontSize: 44, fontWeight: 800, color: WHITE, font: "display", letterSpacing: "-0.01em" },
+      { id: "tagline", type: "text", label: "Tagline", x: 360, y: 200, w: 1100, content: "Orquestación digital para empresas", fontSize: 26, fontWeight: 500, color: WHITE_60 }
+    ]
   }
 ];
-const contentApi = [
-  {
-    method: "GET",
-    path: "/config",
-    handler: "config.get",
-    config: {
-      policies: [],
-      auth: false
+new Set(BASE_TEMPLATES.map((t) => t.id));
+const cleanPath = (path) => path.split("/").map((s) => s.trim()).filter(Boolean).join("/");
+const parentOf = (path) => path.includes("/") ? path.slice(0, path.lastIndexOf("/")) : "";
+const isUnder = (path, base) => path === base || path.startsWith(`${base}/`);
+const renamePath = (path, from, to) => isUnder(path, from) ? to + path.slice(from.length) : path;
+const folderTree = (paths) => {
+  const all3 = /* @__PURE__ */ new Set();
+  for (const p of paths.map(cleanPath).filter(Boolean)) {
+    let cur = p;
+    while (cur) {
+      all3.add(cur);
+      cur = parentOf(cur);
     }
-  },
-  {
-    method: "POST",
-    path: "/config",
-    handler: "config.set",
-    config: {
-      policies: [],
-      auth: false
+  }
+  return [...all3].sort((a, b) => a.localeCompare(b, "es"));
+};
+class TemplateInputError extends Error {
+}
+const LAYER_TYPES = ["text", "list", "quote", "rect", "shape", "badge", "logo", "image", "icon", "avatar", "qr"];
+const MAX_LAYERS = 200;
+const fail$1 = (message) => {
+  throw new TemplateInputError(message);
+};
+const hasDataUrl = (value) => {
+  if (typeof value === "string") return value.startsWith("data:");
+  if (Array.isArray(value)) return value.some(hasDataUrl);
+  if (value && typeof value === "object") return Object.values(value).some(hasDataUrl);
+  return false;
+};
+const name = (v) => {
+  const n = typeof v === "string" ? v.trim() : "";
+  if (!n || n.length > 120) fail$1("El nombre debe tener entre 1 y 120 caracteres.");
+  return n;
+};
+const size = (v) => {
+  if (!Number.isInteger(v) || v < 100 || v > 4e3) fail$1("Las medidas deben ser enteros de 100 a 4000 px.");
+  return v;
+};
+const nonNegative = (v, label) => {
+  if (typeof v !== "number" || !Number.isFinite(v) || v < 0) fail$1(`${label} debe ser un número positivo.`);
+  return v;
+};
+const layers = (v) => {
+  if (!Array.isArray(v) || v.length > MAX_LAYERS) fail$1(`Las capas deben ser una lista de hasta ${MAX_LAYERS}.`);
+  v.forEach((l, i) => {
+    const layer = l ?? {};
+    if (typeof layer.id !== "string" || !layer.id) fail$1(`La capa ${i + 1} no tiene id.`);
+    if (!LAYER_TYPES.includes(layer.type)) fail$1(`La capa ${i + 1} tiene un tipo desconocido.`);
+    if (typeof layer.x !== "number" || typeof layer.y !== "number") fail$1(`La capa ${i + 1} no tiene posición.`);
+  });
+  if (hasDataUrl(v)) fail$1("Las imágenes deben guardarse en la Media Library, no dentro del template.");
+  return v;
+};
+const text = (v, fallback) => typeof v === "string" ? v : fallback;
+const validateTemplate = (input) => {
+  const t = input ?? {};
+  const out = {
+    name: name(t.name),
+    folder: cleanPath(text(t.folder, "")),
+    width: size(t.width),
+    height: size(t.height),
+    background: text(t.background, "#FFFFFF"),
+    safeMargin: nonNegative(t.safeMargin ?? 0, "El margen seguro"),
+    gridUnit: nonNegative(t.gridUnit ?? 60, "La cuadrícula"),
+    layers: layers(t.layers)
+  };
+  if (typeof t.baseId === "string" && t.baseId) out.baseId = t.baseId;
+  return out;
+};
+const validateTemplatePatch = (input) => {
+  const t = input ?? {};
+  const out = {};
+  if ("name" in t) out.name = name(t.name);
+  if ("folder" in t) out.folder = cleanPath(text(t.folder, ""));
+  if ("width" in t) out.width = size(t.width);
+  if ("height" in t) out.height = size(t.height);
+  if ("background" in t) out.background = text(t.background, "#FFFFFF");
+  if ("safeMargin" in t) out.safeMargin = nonNegative(t.safeMargin, "El margen seguro");
+  if ("gridUnit" in t) out.gridUnit = nonNegative(t.gridUnit, "La cuadrícula");
+  if ("layers" in t) out.layers = layers(t.layers);
+  if (!Object.keys(out).length) fail$1("Nada que actualizar.");
+  return out;
+};
+const TEMPLATE_UID = "plugin::strapi-content-generator-gemini.template";
+const FOLDERS_KEY = "TEMPLATE_FOLDERS";
+class TemplateNotFoundError extends Error {
+}
+const FIELDS = ["name", "folder", "width", "height", "background", "safeMargin", "gridUnit", "layers", "baseId", "replacesBase"];
+const BASE_IDS = new Set(BASE_TEMPLATES.map((t) => t.id));
+const checkBaseId = (baseId) => {
+  if (typeof baseId !== "string" || !BASE_IDS.has(baseId)) throw new TemplateInputError("Plantilla base desconocida.");
+  return baseId;
+};
+const toStored = (d) => {
+  const out = { documentId: d.documentId, updatedAt: d.updatedAt };
+  for (const f of FIELDS) if (d[f] !== void 0 && d[f] !== null) out[f] = d[f];
+  out.folder = typeof d.folder === "string" ? d.folder : "";
+  return out;
+};
+const createTemplatesService = (docs, store) => {
+  const all3 = async () => (await docs.findMany({})).map(toStored);
+  const storedFolders = async () => {
+    const v = await store.get({ key: FOLDERS_KEY });
+    return Array.isArray(v) ? v : [];
+  };
+  const saveFolders = (folders) => store.set({ key: FOLDERS_KEY, value: folderTree(folders) });
+  const tree = async () => folderTree([...await storedFolders(), ...(await all3()).map((t) => t.folder)]);
+  const mustExist = async (documentId) => {
+    const d = await docs.findOne({ documentId });
+    if (!d) throw new TemplateNotFoundError("El template no existe o fue eliminado.");
+    return d;
+  };
+  const moveTemplates = async (path, to) => {
+    for (const t of await all3()) {
+      if (isUnder(t.folder, path)) await docs.update({ documentId: t.documentId, data: { folder: to(t.folder) } });
+    }
+  };
+  return {
+    async list() {
+      return (await all3()).sort((a, b) => a.name.localeCompare(b.name, "es", { sensitivity: "base" }));
+    },
+    async findOne(documentId) {
+      return toStored(await mustExist(documentId));
+    },
+    async create(input) {
+      return toStored(await docs.create({ data: validateTemplate(input) }));
+    },
+    async update(documentId, patch) {
+      const data = validateTemplatePatch(patch);
+      await mustExist(documentId);
+      return toStored(await docs.update({ documentId, data }));
+    },
+    async remove(documentId) {
+      await mustExist(documentId);
+      await docs.delete({ documentId });
+    },
+    /**
+     * Guarda la versión editada de una plantilla base (S4.15): la crea la primera vez y después la
+     * actualiza. Vive en la raíz y conserva la base como origen.
+     */
+    async saveBase(baseId, input) {
+      const id = checkBaseId(baseId);
+      const data = { ...validateTemplate(input), folder: "", baseId: id, replacesBase: id };
+      const current = (await all3()).find((t) => t.replacesBase === id);
+      return toStored(current ? await docs.update({ documentId: current.documentId, data }) : await docs.create({ data }));
+    },
+    /** Vuelve a la versión de InterWare: borra la editada, si existe. */
+    async restoreBase(baseId) {
+      const id = checkBaseId(baseId);
+      const current = (await all3()).find((t) => t.replacesBase === id);
+      if (current) await docs.delete({ documentId: current.documentId });
+    },
+    folders: tree,
+    async createFolder(path) {
+      const p = cleanPath(typeof path === "string" ? path : "");
+      if (!p) throw new TemplateInputError("Escribe el nombre de la carpeta.");
+      if ((await tree()).includes(p)) throw new TemplateInputError("Ya existe una carpeta con ese nombre.");
+      await saveFolders([...await storedFolders(), p]);
+      return tree();
+    },
+    async renameFolder(from, to) {
+      const src = cleanPath(typeof from === "string" ? from : "");
+      const dst = cleanPath(typeof to === "string" ? to : "");
+      if (!src || !dst) throw new TemplateInputError("Indica la carpeta y su nombre nuevo.");
+      if (src === dst) return tree();
+      const current = await tree();
+      if (!current.includes(src)) throw new TemplateInputError("La carpeta no existe.");
+      if (current.includes(dst) || isUnder(dst, src)) throw new TemplateInputError("Ya existe una carpeta con ese nombre.");
+      await saveFolders(current.map((p) => renamePath(p, src, dst)));
+      await moveTemplates(src, (f) => renamePath(f, src, dst));
+      return tree();
+    },
+    async deleteFolder(path) {
+      const p = cleanPath(typeof path === "string" ? path : "");
+      if (!p) throw new TemplateInputError("No se puede eliminar la raíz.");
+      const target = parentOf(p);
+      await saveFolders((await tree()).filter((f) => !isUnder(f, p)));
+      await moveTemplates(p, () => target);
+      return tree();
+    }
+  };
+};
+const templates$1 = ({ strapi }) => {
+  const docs = () => strapi.documents(TEMPLATE_UID);
+  const store = () => strapi.store({ type: "plugin", name: "strapi-content-generator-gemini" });
+  return createTemplatesService(
+    {
+      findMany: (p) => docs().findMany(p),
+      findOne: (p) => docs().findOne(p),
+      create: (p) => docs().create(p),
+      update: (p) => docs().update(p),
+      delete: (p) => docs().delete(p)
+    },
+    { get: (p) => store().get(p), set: (p) => store().set(p) }
+  );
+};
+const fail = (ctx, status, name2, message) => {
+  ctx.status = status;
+  ctx.body = { data: null, error: { status, name: name2, message } };
+};
+const templates = ({ strapi }) => {
+  const svc = () => strapi.plugin("strapi-content-generator-gemini").service("templates");
+  const run = async (ctx, work, status = 200) => {
+    try {
+      ctx.body = await work();
+      ctx.status = status;
+    } catch (err) {
+      if (err instanceof TemplateInputError) return fail(ctx, 400, "BadRequestError", err.message);
+      if (err instanceof TemplateNotFoundError) return fail(ctx, 404, "NotFoundError", err.message);
+      strapi.log.error(`[templates] ${err instanceof Error ? err.message : String(err)}`);
+      return fail(ctx, 500, "InternalServerError", "No se pudo completar la operación con los templates.");
     }
+  };
+  const body = (ctx) => ctx.request.body ?? {};
+  return {
+    list: (ctx) => run(ctx, async () => ({ templates: await svc().list() })),
+    create: (ctx) => run(ctx, () => svc().create(body(ctx)), 201),
+    findOne: (ctx) => run(ctx, () => svc().findOne(ctx.params.documentId)),
+    update: (ctx) => run(ctx, () => svc().update(ctx.params.documentId, body(ctx))),
+    remove: (ctx) => run(ctx, async () => {
+      await svc().remove(ctx.params.documentId);
+      return { ok: true };
+    }),
+    saveBase: (ctx) => run(ctx, () => svc().saveBase(ctx.params.baseId, body(ctx))),
+    restoreBase: (ctx) => run(ctx, async () => {
+      await svc().restoreBase(ctx.params.baseId);
+      return { ok: true };
+    }),
+    folders: (ctx) => run(ctx, async () => ({ folders: await svc().folders() })),
+    createFolder: (ctx) => run(ctx, async () => ({ folders: await svc().createFolder(body(ctx).path) })),
+    renameFolder: (ctx) => run(ctx, async () => ({ folders: await svc().renameFolder(body(ctx).from, body(ctx).to) })),
+    deleteFolder: (ctx) => run(ctx, async () => ({ folders: await svc().deleteFolder(body(ctx).path) }))
+  };
+};
+const controllers = {
+  controller,
+  config: config$1,
+  "image-studio": imageStudio,
+  templates
+};
+const middlewares = {};
+const policies = {};
+const ACCESS_ACTION = "plugin::strapi-content-generator-gemini.access";
+const ADMIN_ACCESS_POLICIES = [
+  "admin::isAuthenticatedAdmin",
+  {
+    name: "admin::hasPermissions",
+    config: { actions: [ACCESS_ACTION] }
   }
 ];
+const config = { policies: ADMIN_ACCESS_POLICIES };
+const admin = [
+  { method: "GET", path: "/posts", handler: "controller.getArticles", config },
+  { method: "GET", path: "/categories", handler: "controller.getCategories", config },
+  { method: "GET", path: "/users", handler: "controller.getUsers", config },
+  { method: "POST", path: "/download-file", handler: "controller.downloadFile", config },
+  { method: "POST", path: "/generate-article", handler: "controller.generateArticle", config },
+  { method: "POST", path: "/generate-image", handler: "controller.generateImageForArticle", config },
+  { method: "GET", path: "/image-studio/models", handler: "image-studio.models", config },
+  { method: "POST", path: "/image-studio/generate", handler: "image-studio.generate", config },
+  { method: "POST", path: "/image-studio/edit", handler: "image-studio.edit", config },
+  { method: "POST", path: "/image-studio/expand", handler: "image-studio.expand", config },
+  { method: "POST", path: "/generate-video-with-scenes", handler: "controller.generateVideo", config },
+  { method: "POST", path: "/publish-linkedin", handler: "controller.publishToLinkedIn", config },
+  { method: "POST", path: "/publish-facebook", handler: "controller.publishToFacebook", config },
+  { method: "GET", path: "/templates", handler: "templates.list", config },
+  { method: "POST", path: "/templates", handler: "templates.create", config },
+  { method: "GET", path: "/templates/:documentId", handler: "templates.findOne", config },
+  { method: "PUT", path: "/templates/:documentId", handler: "templates.update", config },
+  { method: "DELETE", path: "/templates/:documentId", handler: "templates.remove", config },
+  { method: "PUT", path: "/templates/base/:baseId", handler: "templates.saveBase", config },
+  { method: "DELETE", path: "/templates/base/:baseId", handler: "templates.restoreBase", config },
+  { method: "GET", path: "/template-folders", handler: "templates.folders", config },
+  { method: "POST", path: "/template-folders", handler: "templates.createFolder", config },
+  { method: "POST", path: "/template-folders/rename", handler: "templates.renameFolder", config },
+  { method: "POST", path: "/template-folders/delete", handler: "templates.deleteFolder", config },
+  { method: "GET", path: "/config", handler: "config.get", config },
+  { method: "POST", path: "/config", handler: "config.set", config },
+  { method: "DELETE", path: "/config/vertex", handler: "config.removeVertex", config }
+];
+const contentApi = [];
 const routes = {
   "content-api": {
     type: "content-api",
@@ -345,9 +952,26 @@ function bind(fn, thisArg) {
 const { toString } = Object.prototype;
 const { getPrototypeOf } = Object;
 const { iterator, toStringTag } = Symbol;
+const hasOwnProperty = (({ hasOwnProperty: hasOwnProperty2 }) => (obj, prop) => hasOwnProperty2.call(obj, prop))(Object.prototype);
+const hasOwnInPrototypeChain = (thing, prop) => {
+  let obj = thing;
+  const seen = [];
+  while (obj != null && obj !== Object.prototype) {
+    if (seen.indexOf(obj) !== -1) {
+      return false;
+    }
+    seen.push(obj);
+    if (hasOwnProperty(obj, prop)) {
+      return true;
+    }
+    obj = getPrototypeOf(obj);
+  }
+  return false;
+};
+const getSafeProp = (obj, prop) => obj != null && hasOwnInPrototypeChain(obj, prop) ? obj[prop] : void 0;
 const kindOf = /* @__PURE__ */ ((cache) => (thing) => {
-  const str = toString.call(thing);
-  return cache[str] || (cache[str] = str.slice(8, -1).toLowerCase());
+  const str2 = toString.call(thing);
+  return cache[str2] || (cache[str2] = str2.slice(8, -1).toLowerCase());
 })(/* @__PURE__ */ Object.create(null));
 const kindOfTest = (type) => {
   type = type.toLowerCase();
@@ -375,11 +999,14 @@ const isNumber = typeOfTest("number");
 const isObject = (thing) => thing !== null && typeof thing === "object";
 const isBoolean = (thing) => thing === true || thing === false;
 const isPlainObject = (val) => {
-  if (kindOf(val) !== "object") {
+  if (!isObject(val)) {
     return false;
   }
   const prototype2 = getPrototypeOf(val);
-  return (prototype2 === null || prototype2 === Object.prototype || Object.getPrototypeOf(prototype2) === null) && !(toStringTag in val) && !(iterator in val);
+  return (prototype2 === null || prototype2 === Object.prototype || getPrototypeOf(prototype2) === null) && // Treat any genuine (non-Object.prototype-polluted) Symbol.toStringTag or
+  // Symbol.iterator as evidence the value is a tagged/iterable type rather
+  // than a plain object, while ignoring keys injected onto Object.prototype.
+  !hasOwnInPrototypeChain(val, toStringTag) && !hasOwnInPrototypeChain(val, iterator);
 };
 const isEmptyObject = (val) => {
   if (!isObject(val) || isBuffer(val)) {
@@ -393,17 +1020,42 @@ const isEmptyObject = (val) => {
 };
 const isDate = kindOfTest("Date");
 const isFile = kindOfTest("File");
+const isReactNativeBlob = (value) => {
+  return !!(value && typeof value.uri !== "undefined");
+};
+const isReactNative = (formData) => formData && typeof formData.getParts !== "undefined";
 const isBlob = kindOfTest("Blob");
 const isFileList = kindOfTest("FileList");
 const isStream = (val) => isObject(val) && isFunction$1(val.pipe);
+function getGlobal() {
+  if (typeof globalThis !== "undefined") return globalThis;
+  if (typeof self !== "undefined") return self;
+  if (typeof window !== "undefined") return window;
+  if (typeof global !== "undefined") return global;
+  return {};
+}
+const G = getGlobal();
+const FormDataCtor = typeof G.FormData !== "undefined" ? G.FormData : void 0;
 const isFormData = (thing) => {
-  let kind;
-  return thing && (typeof FormData === "function" && thing instanceof FormData || isFunction$1(thing.append) && ((kind = kindOf(thing)) === "formdata" || // detect form-data instance
-  kind === "object" && isFunction$1(thing.toString) && thing.toString() === "[object FormData]"));
+  if (!thing) return false;
+  if (FormDataCtor && thing instanceof FormDataCtor) return true;
+  const proto = getPrototypeOf(thing);
+  if (!proto || proto === Object.prototype) return false;
+  if (!isFunction$1(thing.append)) return false;
+  const kind = kindOf(thing);
+  return kind === "formdata" || // detect form-data instance
+  kind === "object" && isFunction$1(thing.toString) && thing.toString() === "[object FormData]";
 };
 const isURLSearchParams = kindOfTest("URLSearchParams");
-const [isReadableStream, isRequest, isResponse, isHeaders] = ["ReadableStream", "Request", "Response", "Headers"].map(kindOfTest);
-const trim = (str) => str.trim ? str.trim() : str.replace(/^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g, "");
+const [isReadableStream, isRequest, isResponse, isHeaders] = [
+  "ReadableStream",
+  "Request",
+  "Response",
+  "Headers"
+].map(kindOfTest);
+const trim = (str2) => {
+  return str2.trim ? str2.trim() : str2.replace(/^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g, "");
+};
 function forEach(obj, fn, { allOwnKeys = false } = {}) {
   if (obj === null || typeof obj === "undefined") {
     return;
@@ -451,13 +1103,17 @@ const _global = (() => {
   return typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : global;
 })();
 const isContextDefined = (context) => !isUndefined(context) && context !== _global;
-function merge() {
+function merge(...objs) {
   const { caseless, skipUndefined } = isContextDefined(this) && this || {};
   const result = {};
   const assignValue = (val, key) => {
-    const targetKey = caseless && findKey(result, key) || key;
-    if (isPlainObject(result[targetKey]) && isPlainObject(val)) {
-      result[targetKey] = merge(result[targetKey], val);
+    if (key === "__proto__" || key === "constructor" || key === "prototype") {
+      return;
+    }
+    const targetKey = caseless && typeof key === "string" && findKey(result, key) || key;
+    const existing = hasOwnProperty(result, targetKey) ? result[targetKey] : void 0;
+    if (isPlainObject(existing) && isPlainObject(val)) {
+      result[targetKey] = merge(existing, val);
     } else if (isPlainObject(val)) {
       result[targetKey] = merge({}, val);
     } else if (isArray(val)) {
@@ -466,19 +1122,51 @@ function merge() {
       result[targetKey] = val;
     }
   };
-  for (let i = 0, l = arguments.length; i < l; i++) {
-    arguments[i] && forEach(arguments[i], assignValue);
+  for (let i = 0, l = objs.length; i < l; i++) {
+    const source = objs[i];
+    if (!source || isBuffer(source)) {
+      continue;
+    }
+    forEach(source, assignValue);
+    if (typeof source !== "object" || isArray(source)) {
+      continue;
+    }
+    const symbols = Object.getOwnPropertySymbols(source);
+    for (let j = 0; j < symbols.length; j++) {
+      const symbol = symbols[j];
+      if (propertyIsEnumerable.call(source, symbol)) {
+        assignValue(source[symbol], symbol);
+      }
+    }
   }
   return result;
 }
 const extend = (a, b, thisArg, { allOwnKeys } = {}) => {
-  forEach(b, (val, key) => {
-    if (thisArg && isFunction$1(val)) {
-      a[key] = bind(val, thisArg);
-    } else {
-      a[key] = val;
-    }
-  }, { allOwnKeys });
+  forEach(
+    b,
+    (val, key) => {
+      if (thisArg && isFunction$1(val)) {
+        Object.defineProperty(a, key, {
+          // Null-proto descriptor so a polluted Object.prototype.get cannot
+          // hijack defineProperty's accessor-vs-data resolution.
+          __proto__: null,
+          value: bind(val, thisArg),
+          writable: true,
+          enumerable: true,
+          configurable: true
+        });
+      } else {
+        Object.defineProperty(a, key, {
+          __proto__: null,
+          value: val,
+          writable: true,
+          enumerable: true,
+          configurable: true
+        });
+      }
+    },
+    { allOwnKeys }
+  );
   return a;
 };
 const stripBOM = (content) => {
@@ -487,10 +1175,17 @@ const stripBOM = (content) => {
   }
   return content;
 };
-const inherits = (constructor, superConstructor, props, descriptors2) => {
-  constructor.prototype = Object.create(superConstructor.prototype, descriptors2);
-  constructor.prototype.constructor = constructor;
+const inherits = (constructor, superConstructor, props, descriptors) => {
+  constructor.prototype = Object.create(superConstructor.prototype, descriptors);
+  Object.defineProperty(constructor.prototype, "constructor", {
+    __proto__: null,
+    value: constructor,
+    writable: true,
+    enumerable: false,
+    configurable: true
+  });
   Object.defineProperty(constructor, "super", {
+    __proto__: null,
     value: superConstructor.prototype
   });
   props && Object.assign(constructor.prototype, props);
@@ -516,13 +1211,13 @@ const toFlatObject = (sourceObj, destObj, filter2, propFilter) => {
   } while (sourceObj && (!filter2 || filter2(sourceObj, destObj)) && sourceObj !== Object.prototype);
   return destObj;
 };
-const endsWith = (str, searchString, position) => {
-  str = String(str);
-  if (position === void 0 || position > str.length) {
-    position = str.length;
+const endsWith = (str2, searchString, position) => {
+  str2 = String(str2);
+  if (position === void 0 || position > str2.length) {
+    position = str2.length;
   }
   position -= searchString.length;
-  const lastIndex = str.indexOf(searchString, position);
+  const lastIndex = str2.indexOf(searchString, position);
   return lastIndex !== -1 && lastIndex === position;
 };
 const toArray = (thing) => {
@@ -550,42 +1245,39 @@ const forEachEntry = (obj, fn) => {
     fn.call(obj, pair[0], pair[1]);
   }
 };
-const matchAll = (regExp, str) => {
+const matchAll = (regExp, str2) => {
   let matches;
   const arr = [];
-  while ((matches = regExp.exec(str)) !== null) {
+  while ((matches = regExp.exec(str2)) !== null) {
     arr.push(matches);
   }
   return arr;
 };
 const isHTMLForm = kindOfTest("HTMLFormElement");
-const toCamelCase = (str) => {
-  return str.toLowerCase().replace(
-    /[-_\s]([a-z\d])(\w*)/g,
-    function replacer(m, p1, p2) {
-      return p1.toUpperCase() + p2;
-    }
-  );
+const toCamelCase = (str2) => {
+  return str2.toLowerCase().replace(/[-_\s]([a-z\d])(\w*)/g, function replacer(m, p1, p2) {
+    return p1.toUpperCase() + p2;
+  });
 };
-const hasOwnProperty = (({ hasOwnProperty: hasOwnProperty2 }) => (obj, prop) => hasOwnProperty2.call(obj, prop))(Object.prototype);
+const { propertyIsEnumerable } = Object.prototype;
 const isRegExp = kindOfTest("RegExp");
 const reduceDescriptors = (obj, reducer) => {
-  const descriptors2 = Object.getOwnPropertyDescriptors(obj);
+  const descriptors = Object.getOwnPropertyDescriptors(obj);
   const reducedDescriptors = {};
-  forEach(descriptors2, (descriptor, name) => {
+  forEach(descriptors, (descriptor, name2) => {
     let ret;
-    if ((ret = reducer(descriptor, name, obj)) !== false) {
-      reducedDescriptors[name] = ret || descriptor;
+    if ((ret = reducer(descriptor, name2, obj)) !== false) {
+      reducedDescriptors[name2] = ret || descriptor;
     }
   });
   Object.defineProperties(obj, reducedDescriptors);
 };
 const freezeMethods = (obj) => {
-  reduceDescriptors(obj, (descriptor, name) => {
-    if (isFunction$1(obj) && ["arguments", "caller", "callee"].indexOf(name) !== -1) {
+  reduceDescriptors(obj, (descriptor, name2) => {
+    if (isFunction$1(obj) && ["arguments", "caller", "callee"].includes(name2)) {
       return false;
     }
-    const value = obj[name];
+    const value = obj[name2];
     if (!isFunction$1(value)) return;
     descriptor.enumerable = false;
     if ("writable" in descriptor) {
@@ -594,7 +1286,7 @@ const freezeMethods = (obj) => {
     }
     if (!descriptor.set) {
       descriptor.set = () => {
-        throw Error("Can not rewrite read-only method '" + name + "'");
+        throw Error("Can not rewrite read-only method '" + name2 + "'");
       };
     }
   });
@@ -618,29 +1310,29 @@ function isSpecCompliantForm(thing) {
   return !!(thing && isFunction$1(thing.append) && thing[toStringTag] === "FormData" && thing[iterator]);
 }
 const toJSONObject = (obj) => {
-  const stack = new Array(10);
-  const visit = (source, i) => {
+  const visited = /* @__PURE__ */ new WeakSet();
+  const visit = (source) => {
     if (isObject(source)) {
-      if (stack.indexOf(source) >= 0) {
+      if (visited.has(source)) {
         return;
       }
       if (isBuffer(source)) {
         return source;
       }
       if (!("toJSON" in source)) {
-        stack[i] = source;
+        visited.add(source);
         const target = isArray(source) ? [] : {};
         forEach(source, (value, key) => {
-          const reducedValue = visit(value, i + 1);
+          const reducedValue = visit(value);
           !isUndefined(reducedValue) && (target[key] = reducedValue);
         });
-        stack[i] = void 0;
+        visited.delete(source);
         return target;
       }
     }
     return source;
   };
-  return visit(obj, 0);
+  return visit(obj);
 };
 const isAsyncFn = kindOfTest("AsyncFunction");
 const isThenable = (thing) => thing && (isObject(thing) || isFunction$1(thing)) && isFunction$1(thing.then) && isFunction$1(thing.catch);
@@ -649,22 +1341,24 @@ const _setImmediate = ((setImmediateSupported, postMessageSupported) => {
     return setImmediate;
   }
   return postMessageSupported ? ((token, callbacks) => {
-    _global.addEventListener("message", ({ source, data }) => {
-      if (source === _global && data === token) {
-        callbacks.length && callbacks.shift()();
-      }
-    }, false);
+    _global.addEventListener(
+      "message",
+      ({ source, data }) => {
+        if (source === _global && data === token) {
+          callbacks.length && callbacks.shift()();
+        }
+      },
+      false
+    );
     return (cb) => {
       callbacks.push(cb);
       _global.postMessage(token, "*");
     };
   })(`axios@${Math.random()}`, []) : (cb) => setTimeout(cb);
-})(
-  typeof setImmediate === "function",
-  isFunction$1(_global.postMessage)
-);
+})(typeof setImmediate === "function", isFunction$1(_global.postMessage));
 const asap = typeof queueMicrotask !== "undefined" ? queueMicrotask.bind(_global) : typeof process !== "undefined" && process.nextTick || _setImmediate;
 const isIterable = (thing) => thing != null && isFunction$1(thing[iterator]);
+const isSafeIterable = (thing) => thing != null && hasOwnInPrototypeChain(thing, iterator) && isIterable(thing);
 const utils$1 = {
   isArray,
   isArrayBuffer,
@@ -684,6 +1378,8 @@ const utils$1 = {
   isUndefined,
   isDate,
   isFile,
+  isReactNativeBlob,
+  isReactNative,
   isBlob,
   isRegExp,
   isFunction: isFunction$1,
@@ -708,6 +1404,8 @@ const utils$1 = {
   hasOwnProperty,
   hasOwnProp: hasOwnProperty,
   // an alias to avoid ESLint no-prototype-builtins detection
+  hasOwnInPrototypeChain,
+  getSafeProp,
   reduceDescriptors,
   freezeMethods,
   toObjectSet,
@@ -723,85 +1421,470 @@ const utils$1 = {
   isThenable,
   setImmediate: _setImmediate,
   asap,
-  isIterable
+  isIterable,
+  isSafeIterable
 };
-function AxiosError$1(message, code, config2, request, response) {
-  Error.call(this);
-  if (Error.captureStackTrace) {
-    Error.captureStackTrace(this, this.constructor);
-  } else {
-    this.stack = new Error().stack;
-  }
-  this.message = message;
-  this.name = "AxiosError";
-  code && (this.code = code);
-  config2 && (this.config = config2);
-  request && (this.request = request);
-  if (response) {
-    this.response = response;
-    this.status = response.status ? response.status : null;
-  }
-}
-utils$1.inherits(AxiosError$1, Error, {
-  toJSON: function toJSON() {
-    return {
-      // Standard
-      message: this.message,
-      name: this.name,
-      // Microsoft
-      description: this.description,
-      number: this.number,
-      // Mozilla
-      fileName: this.fileName,
-      lineNumber: this.lineNumber,
-      columnNumber: this.columnNumber,
-      stack: this.stack,
-      // Axios
-      config: utils$1.toJSONObject(this.config),
-      code: this.code,
-      status: this.status
-    };
-  }
-});
-const prototype$1 = AxiosError$1.prototype;
-const descriptors = {};
-[
-  "ERR_BAD_OPTION_VALUE",
-  "ERR_BAD_OPTION",
-  "ECONNABORTED",
-  "ETIMEDOUT",
-  "ERR_NETWORK",
-  "ERR_FR_TOO_MANY_REDIRECTS",
-  "ERR_DEPRECATED",
-  "ERR_BAD_RESPONSE",
-  "ERR_BAD_REQUEST",
-  "ERR_CANCELED",
-  "ERR_NOT_SUPPORT",
-  "ERR_INVALID_URL"
-  // eslint-disable-next-line func-names
-].forEach((code) => {
-  descriptors[code] = { value: code };
-});
-Object.defineProperties(AxiosError$1, descriptors);
-Object.defineProperty(prototype$1, "isAxiosError", { value: true });
-AxiosError$1.from = (error, code, config2, request, response, customProps) => {
-  const axiosError = Object.create(prototype$1);
-  utils$1.toFlatObject(error, axiosError, function filter2(obj) {
-    return obj !== Error.prototype;
-  }, (prop) => {
-    return prop !== "isAxiosError";
-  });
-  const msg = error && error.message ? error.message : "Error";
-  const errCode = code == null && error ? error.code : code;
-  AxiosError$1.call(axiosError, msg, errCode, config2, request, response);
-  if (error && axiosError.cause == null) {
-    Object.defineProperty(axiosError, "cause", { value: error, configurable: true });
-  }
-  axiosError.name = error && error.name || "Error";
-  customProps && Object.assign(axiosError, customProps);
-  return axiosError;
+const ignoreDuplicateOf = utils$1.toObjectSet([
+  "age",
+  "authorization",
+  "content-length",
+  "content-type",
+  "etag",
+  "expires",
+  "from",
+  "host",
+  "if-modified-since",
+  "if-unmodified-since",
+  "last-modified",
+  "location",
+  "max-forwards",
+  "proxy-authorization",
+  "referer",
+  "retry-after",
+  "user-agent"
+]);
+const parseHeaders = (rawHeaders) => {
+  const parsed = {};
+  let key;
+  let val;
+  let i;
+  rawHeaders && rawHeaders.split("\n").forEach(function parser(line) {
+    i = line.indexOf(":");
+    key = line.substring(0, i).trim().toLowerCase();
+    val = line.substring(i + 1).trim();
+    if (!key || parsed[key] && ignoreDuplicateOf[key]) {
+      return;
+    }
+    if (key === "set-cookie") {
+      if (parsed[key]) {
+        parsed[key].push(val);
+      } else {
+        parsed[key] = [val];
+      }
+    } else {
+      parsed[key] = parsed[key] ? parsed[key] + ", " + val : val;
+    }
+  });
+  return parsed;
+};
+function trimSPorHTAB(str2) {
+  let start = 0;
+  let end = str2.length;
+  while (start < end) {
+    const code = str2.charCodeAt(start);
+    if (code !== 9 && code !== 32) {
+      break;
+    }
+    start += 1;
+  }
+  while (end > start) {
+    const code = str2.charCodeAt(end - 1);
+    if (code !== 9 && code !== 32) {
+      break;
+    }
+    end -= 1;
+  }
+  return start === 0 && end === str2.length ? str2 : str2.slice(start, end);
+}
+const INVALID_UNICODE_HEADER_VALUE_CHARS = new RegExp("[\\u0000-\\u0008\\u000a-\\u001f\\u007f]+", "g");
+const INVALID_BYTE_STRING_HEADER_VALUE_CHARS = new RegExp("[^\\u0009\\u0020-\\u007e\\u0080-\\u00ff]+", "g");
+function sanitizeValue(value, invalidChars) {
+  if (utils$1.isArray(value)) {
+    return value.map((item) => sanitizeValue(item, invalidChars));
+  }
+  return trimSPorHTAB(String(value).replace(invalidChars, ""));
+}
+const sanitizeHeaderValue = (value) => sanitizeValue(value, INVALID_UNICODE_HEADER_VALUE_CHARS);
+const sanitizeByteStringHeaderValue = (value) => sanitizeValue(value, INVALID_BYTE_STRING_HEADER_VALUE_CHARS);
+function toByteStringHeaderObject(headers) {
+  const byteStringHeaders = /* @__PURE__ */ Object.create(null);
+  utils$1.forEach(headers.toJSON(), (value, header) => {
+    byteStringHeaders[header] = sanitizeByteStringHeaderValue(value);
+  });
+  return byteStringHeaders;
+}
+const $internals = Symbol("internals");
+function normalizeHeader(header) {
+  return header && String(header).trim().toLowerCase();
+}
+function normalizeValue(value) {
+  if (value === false || value == null) {
+    return value;
+  }
+  return utils$1.isArray(value) ? value.map(normalizeValue) : sanitizeHeaderValue(String(value));
+}
+function parseTokens(str2) {
+  const tokens = /* @__PURE__ */ Object.create(null);
+  const tokensRE = /([^\s,;=]+)\s*(?:=\s*([^,;]+))?/g;
+  let match;
+  while (match = tokensRE.exec(str2)) {
+    tokens[match[1]] = match[2];
+  }
+  return tokens;
+}
+const isValidHeaderName = (str2) => /^[-_a-zA-Z0-9^`|~,!#$%&'*+.]+$/.test(str2.trim());
+function matchHeaderValue(context, value, header, filter2, isHeaderNameFilter) {
+  if (utils$1.isFunction(filter2)) {
+    return filter2.call(this, value, header);
+  }
+  if (isHeaderNameFilter) {
+    value = header;
+  }
+  if (!utils$1.isString(value)) return;
+  if (utils$1.isString(filter2)) {
+    return value.indexOf(filter2) !== -1;
+  }
+  if (utils$1.isRegExp(filter2)) {
+    return filter2.test(value);
+  }
+}
+function formatHeader(header) {
+  return header.trim().toLowerCase().replace(/([a-z\d])(\w*)/g, (w, char, str2) => {
+    return char.toUpperCase() + str2;
+  });
+}
+function buildAccessors(obj, header) {
+  const accessorName = utils$1.toCamelCase(" " + header);
+  ["get", "set", "has"].forEach((methodName) => {
+    Object.defineProperty(obj, methodName + accessorName, {
+      // Null-proto descriptor so a polluted Object.prototype.get cannot turn
+      // this data descriptor into an accessor descriptor on the way in.
+      __proto__: null,
+      value: function(arg1, arg2, arg3) {
+        return this[methodName].call(this, header, arg1, arg2, arg3);
+      },
+      configurable: true
+    });
+  });
+}
+let AxiosHeaders$1 = class AxiosHeaders {
+  constructor(headers) {
+    headers && this.set(headers);
+  }
+  set(header, valueOrRewrite, rewrite) {
+    const self2 = this;
+    function setHeader(_value, _header, _rewrite) {
+      const lHeader = normalizeHeader(_header);
+      if (!lHeader) {
+        return;
+      }
+      const key = utils$1.findKey(self2, lHeader);
+      if (!key || self2[key] === void 0 || _rewrite === true || _rewrite === void 0 && self2[key] !== false) {
+        self2[key || _header] = normalizeValue(_value);
+      }
+    }
+    const setHeaders = (headers, _rewrite) => utils$1.forEach(headers, (_value, _header) => setHeader(_value, _header, _rewrite));
+    if (utils$1.isPlainObject(header) || header instanceof this.constructor) {
+      setHeaders(header, valueOrRewrite);
+    } else if (utils$1.isString(header) && (header = header.trim()) && !isValidHeaderName(header)) {
+      setHeaders(parseHeaders(header), valueOrRewrite);
+    } else if (utils$1.isObject(header) && utils$1.isSafeIterable(header)) {
+      let obj = /* @__PURE__ */ Object.create(null), dest, key;
+      for (const entry of header) {
+        if (!utils$1.isArray(entry)) {
+          throw new TypeError("Object iterator must return a key-value pair");
+        }
+        key = entry[0];
+        if (utils$1.hasOwnProp(obj, key)) {
+          dest = obj[key];
+          obj[key] = utils$1.isArray(dest) ? [...dest, entry[1]] : [dest, entry[1]];
+        } else {
+          obj[key] = entry[1];
+        }
+      }
+      setHeaders(obj, valueOrRewrite);
+    } else {
+      header != null && setHeader(valueOrRewrite, header, rewrite);
+    }
+    return this;
+  }
+  get(header, parser) {
+    header = normalizeHeader(header);
+    if (header) {
+      const key = utils$1.findKey(this, header);
+      if (key) {
+        const value = this[key];
+        if (!parser) {
+          return value;
+        }
+        if (parser === true) {
+          return parseTokens(value);
+        }
+        if (utils$1.isFunction(parser)) {
+          return parser.call(this, value, key);
+        }
+        if (utils$1.isRegExp(parser)) {
+          return parser.exec(value);
+        }
+        throw new TypeError("parser must be boolean|regexp|function");
+      }
+    }
+  }
+  has(header, matcher) {
+    header = normalizeHeader(header);
+    if (header) {
+      const key = utils$1.findKey(this, header);
+      return !!(key && this[key] !== void 0 && (!matcher || matchHeaderValue(this, this[key], key, matcher)));
+    }
+    return false;
+  }
+  delete(header, matcher) {
+    const self2 = this;
+    let deleted = false;
+    function deleteHeader(_header) {
+      _header = normalizeHeader(_header);
+      if (_header) {
+        const key = utils$1.findKey(self2, _header);
+        if (key && (!matcher || matchHeaderValue(self2, self2[key], key, matcher))) {
+          delete self2[key];
+          deleted = true;
+        }
+      }
+    }
+    if (utils$1.isArray(header)) {
+      header.forEach(deleteHeader);
+    } else {
+      deleteHeader(header);
+    }
+    return deleted;
+  }
+  clear(matcher) {
+    const keys = Object.keys(this);
+    let i = keys.length;
+    let deleted = false;
+    while (i--) {
+      const key = keys[i];
+      if (!matcher || matchHeaderValue(this, this[key], key, matcher, true)) {
+        delete this[key];
+        deleted = true;
+      }
+    }
+    return deleted;
+  }
+  normalize(format) {
+    const self2 = this;
+    const headers = {};
+    utils$1.forEach(this, (value, header) => {
+      const key = utils$1.findKey(headers, header);
+      if (key) {
+        self2[key] = normalizeValue(value);
+        delete self2[header];
+        return;
+      }
+      const normalized = format ? formatHeader(header) : String(header).trim();
+      if (normalized !== header) {
+        delete self2[header];
+      }
+      self2[normalized] = normalizeValue(value);
+      headers[normalized] = true;
+    });
+    return this;
+  }
+  concat(...targets) {
+    return this.constructor.concat(this, ...targets);
+  }
+  toJSON(asStrings) {
+    const obj = /* @__PURE__ */ Object.create(null);
+    utils$1.forEach(this, (value, header) => {
+      value != null && value !== false && (obj[header] = asStrings && utils$1.isArray(value) ? value.join(", ") : value);
+    });
+    return obj;
+  }
+  [Symbol.iterator]() {
+    return Object.entries(this.toJSON())[Symbol.iterator]();
+  }
+  toString() {
+    return Object.entries(this.toJSON()).map(([header, value]) => header + ": " + value).join("\n");
+  }
+  getSetCookie() {
+    return this.get("set-cookie") || [];
+  }
+  get [Symbol.toStringTag]() {
+    return "AxiosHeaders";
+  }
+  static from(thing) {
+    return thing instanceof this ? thing : new this(thing);
+  }
+  static concat(first, ...targets) {
+    const computed = new this(first);
+    targets.forEach((target) => computed.set(target));
+    return computed;
+  }
+  static accessor(header) {
+    const internals = this[$internals] = this[$internals] = {
+      accessors: {}
+    };
+    const accessors = internals.accessors;
+    const prototype2 = this.prototype;
+    function defineAccessor(_header) {
+      const lHeader = normalizeHeader(_header);
+      if (!accessors[lHeader]) {
+        buildAccessors(prototype2, _header);
+        accessors[lHeader] = true;
+      }
+    }
+    utils$1.isArray(header) ? header.forEach(defineAccessor) : defineAccessor(header);
+    return this;
+  }
 };
+AxiosHeaders$1.accessor([
+  "Content-Type",
+  "Content-Length",
+  "Accept",
+  "Accept-Encoding",
+  "User-Agent",
+  "Authorization"
+]);
+utils$1.reduceDescriptors(AxiosHeaders$1.prototype, ({ value }, key) => {
+  let mapped = key[0].toUpperCase() + key.slice(1);
+  return {
+    get: () => value,
+    set(headerValue) {
+      this[mapped] = headerValue;
+    }
+  };
+});
+utils$1.freezeMethods(AxiosHeaders$1);
+const REDACTED = "[REDACTED ****]";
+function hasOwnOrPrototypeToJSON(source) {
+  if (utils$1.hasOwnProp(source, "toJSON")) {
+    return true;
+  }
+  let prototype2 = Object.getPrototypeOf(source);
+  while (prototype2 && prototype2 !== Object.prototype) {
+    if (utils$1.hasOwnProp(prototype2, "toJSON")) {
+      return true;
+    }
+    prototype2 = Object.getPrototypeOf(prototype2);
+  }
+  return false;
+}
+function redactConfig(config2, redactKeys) {
+  const lowerKeys = new Set(redactKeys.map((k) => String(k).toLowerCase()));
+  const seen = [];
+  const visit = (source) => {
+    if (source === null || typeof source !== "object") return source;
+    if (utils$1.isBuffer(source)) return source;
+    if (seen.indexOf(source) !== -1) return void 0;
+    if (source instanceof AxiosHeaders$1) {
+      source = source.toJSON();
+    }
+    seen.push(source);
+    let result;
+    if (utils$1.isArray(source)) {
+      result = [];
+      source.forEach((v, i) => {
+        const reducedValue = visit(v);
+        if (!utils$1.isUndefined(reducedValue)) {
+          result[i] = reducedValue;
+        }
+      });
+    } else {
+      if (!utils$1.isPlainObject(source) && hasOwnOrPrototypeToJSON(source)) {
+        seen.pop();
+        return source;
+      }
+      result = /* @__PURE__ */ Object.create(null);
+      for (const [key, value] of Object.entries(source)) {
+        const reducedValue = lowerKeys.has(key.toLowerCase()) ? REDACTED : visit(value);
+        if (!utils$1.isUndefined(reducedValue)) {
+          result[key] = reducedValue;
+        }
+      }
+    }
+    seen.pop();
+    return result;
+  };
+  return visit(config2);
+}
+let AxiosError$1 = class AxiosError extends Error {
+  static from(error, code, config2, request, response, customProps) {
+    const axiosError = new AxiosError(error.message, code || error.code, config2, request, response);
+    Object.defineProperty(axiosError, "cause", {
+      __proto__: null,
+      value: error,
+      writable: true,
+      enumerable: false,
+      configurable: true
+    });
+    axiosError.name = error.name;
+    if (error.status != null && axiosError.status == null) {
+      axiosError.status = error.status;
+    }
+    customProps && Object.assign(axiosError, customProps);
+    return axiosError;
+  }
+  /**
+   * Create an Error with the specified message, config, error code, request and response.
+   *
+   * @param {string} message The error message.
+   * @param {string} [code] The error code (for example, 'ECONNABORTED').
+   * @param {Object} [config] The config.
+   * @param {Object} [request] The request.
+   * @param {Object} [response] The response.
+   *
+   * @returns {Error} The created error.
+   */
+  constructor(message, code, config2, request, response) {
+    super(message);
+    Object.defineProperty(this, "message", {
+      // Null-proto descriptor so a polluted Object.prototype.get cannot turn
+      // this data descriptor into an accessor descriptor on the way in.
+      __proto__: null,
+      value: message,
+      enumerable: true,
+      writable: true,
+      configurable: true
+    });
+    this.name = "AxiosError";
+    this.isAxiosError = true;
+    code && (this.code = code);
+    config2 && (this.config = config2);
+    request && (this.request = request);
+    if (response) {
+      this.response = response;
+      this.status = response.status;
+    }
+  }
+  toJSON() {
+    const config2 = this.config;
+    const redactKeys = config2 && utils$1.hasOwnProp(config2, "redact") ? config2.redact : void 0;
+    const serializedConfig = utils$1.isArray(redactKeys) && redactKeys.length > 0 ? redactConfig(config2, redactKeys) : utils$1.toJSONObject(config2);
+    return {
+      // Standard
+      message: this.message,
+      name: this.name,
+      // Microsoft
+      description: this.description,
+      number: this.number,
+      // Mozilla
+      fileName: this.fileName,
+      lineNumber: this.lineNumber,
+      columnNumber: this.columnNumber,
+      stack: this.stack,
+      // Axios
+      config: serializedConfig,
+      code: this.code,
+      status: this.status
+    };
+  }
+};
+AxiosError$1.ERR_BAD_OPTION_VALUE = "ERR_BAD_OPTION_VALUE";
+AxiosError$1.ERR_BAD_OPTION = "ERR_BAD_OPTION";
+AxiosError$1.ECONNABORTED = "ECONNABORTED";
+AxiosError$1.ETIMEDOUT = "ETIMEDOUT";
+AxiosError$1.ECONNREFUSED = "ECONNREFUSED";
+AxiosError$1.ERR_NETWORK = "ERR_NETWORK";
+AxiosError$1.ERR_FR_TOO_MANY_REDIRECTS = "ERR_FR_TOO_MANY_REDIRECTS";
+AxiosError$1.ERR_DEPRECATED = "ERR_DEPRECATED";
+AxiosError$1.ERR_BAD_RESPONSE = "ERR_BAD_RESPONSE";
+AxiosError$1.ERR_BAD_REQUEST = "ERR_BAD_REQUEST";
+AxiosError$1.ERR_CANCELED = "ERR_CANCELED";
+AxiosError$1.ERR_NOT_SUPPORT = "ERR_NOT_SUPPORT";
+AxiosError$1.ERR_INVALID_URL = "ERR_INVALID_URL";
+AxiosError$1.ERR_FORM_DATA_DEPTH_EXCEEDED = "ERR_FORM_DATA_DEPTH_EXCEEDED";
 const httpAdapter = null;
+const DEFAULT_FORM_DATA_MAX_DEPTH = 100;
 function isVisitable(thing) {
   return utils$1.isPlainObject(thing) || utils$1.isArray(thing);
 }
@@ -826,19 +1909,26 @@ function toFormData$1(obj, formData, options) {
     throw new TypeError("target must be an object");
   }
   formData = formData || new FormData();
-  options = utils$1.toFlatObject(options, {
-    metaTokens: true,
-    dots: false,
-    indexes: false
-  }, false, function defined(option, source) {
-    return !utils$1.isUndefined(source[option]);
-  });
+  options = utils$1.toFlatObject(
+    options,
+    {
+      metaTokens: true,
+      dots: false,
+      indexes: false
+    },
+    false,
+    function defined(option, source) {
+      return !utils$1.isUndefined(source[option]);
+    }
+  );
   const metaTokens = options.metaTokens;
   const visitor = options.visitor || defaultVisitor;
   const dots = options.dots;
   const indexes = options.indexes;
   const _Blob = options.Blob || typeof Blob !== "undefined" && Blob;
+  const maxDepth = options.maxDepth === void 0 ? DEFAULT_FORM_DATA_MAX_DEPTH : options.maxDepth;
   const useBlob = _Blob && utils$1.isSpecCompliantForm(formData);
+  const stack = [];
   if (!utils$1.isFunction(visitor)) {
     throw new TypeError("visitor must be a function");
   }
@@ -854,16 +1944,51 @@ function toFormData$1(obj, formData, options) {
       throw new AxiosError$1("Blob is not supported. Use a Buffer instead.");
     }
     if (utils$1.isArrayBuffer(value) || utils$1.isTypedArray(value)) {
-      return useBlob && typeof Blob === "function" ? new Blob([value]) : Buffer.from(value);
+      if (useBlob && typeof _Blob === "function") {
+        return new _Blob([value]);
+      }
+      if (typeof Buffer !== "undefined") {
+        return Buffer.from(value);
+      }
+      throw new AxiosError$1("Blob is not supported. Use a Buffer instead.", AxiosError$1.ERR_NOT_SUPPORT);
     }
     return value;
   }
+  function throwIfMaxDepthExceeded(depth) {
+    if (depth > maxDepth) {
+      throw new AxiosError$1(
+        "Object is too deeply nested (" + depth + " levels). Max depth: " + maxDepth,
+        AxiosError$1.ERR_FORM_DATA_DEPTH_EXCEEDED
+      );
+    }
+  }
+  function stringifyWithDepthLimit(value, depth) {
+    if (maxDepth === Infinity) {
+      return JSON.stringify(value);
+    }
+    const ancestors = [];
+    return JSON.stringify(value, function limitDepth(_key, currentValue) {
+      if (!utils$1.isObject(currentValue)) {
+        return currentValue;
+      }
+      while (ancestors.length && ancestors[ancestors.length - 1] !== this) {
+        ancestors.pop();
+      }
+      ancestors.push(currentValue);
+      throwIfMaxDepthExceeded(depth + ancestors.length - 1);
+      return currentValue;
+    });
+  }
   function defaultVisitor(value, key, path) {
     let arr = value;
+    if (utils$1.isReactNative(formData) && utils$1.isReactNativeBlob(value)) {
+      formData.append(renderKey(path, key, dots), convertValue(value));
+      return false;
+    }
     if (value && !path && typeof value === "object") {
       if (utils$1.endsWith(key, "{}")) {
         key = metaTokens ? key : key.slice(0, -2);
-        value = JSON.stringify(value);
+        value = stringifyWithDepthLimit(value, 1);
       } else if (utils$1.isArray(value) && isFlatArray(value) || (utils$1.isFileList(value) || utils$1.endsWith(key, "[]")) && (arr = utils$1.toArray(value))) {
         key = removeBrackets(key);
         arr.forEach(function each(el, index2) {
@@ -882,28 +2007,22 @@ function toFormData$1(obj, formData, options) {
     formData.append(renderKey(path, key, dots), convertValue(value));
     return false;
   }
-  const stack = [];
   const exposedHelpers = Object.assign(predicates, {
     defaultVisitor,
     convertValue,
     isVisitable
   });
-  function build(value, path) {
+  function build(value, path, depth = 0) {
     if (utils$1.isUndefined(value)) return;
+    throwIfMaxDepthExceeded(depth);
     if (stack.indexOf(value) !== -1) {
-      throw Error("Circular reference detected in " + path.join("."));
+      throw new Error("Circular reference detected in " + path.join("."));
     }
     stack.push(value);
     utils$1.forEach(value, function each(el, key) {
-      const result = !(utils$1.isUndefined(el) || el === null) && visitor.call(
-        formData,
-        el,
-        utils$1.isString(key) ? key.trim() : key,
-        path,
-        exposedHelpers
-      );
+      const result = !(utils$1.isUndefined(el) || el === null) && visitor.call(formData, el, utils$1.isString(key) ? key.trim() : key, path, exposedHelpers);
       if (result === true) {
-        build(el, path ? path.concat(key) : [key]);
+        build(el, path ? path.concat(key) : [key], depth + 1);
       }
     });
     stack.pop();
@@ -914,17 +2033,16 @@ function toFormData$1(obj, formData, options) {
   build(obj);
   return formData;
 }
-function encode$1(str) {
+function encode$1(str2) {
   const charMap = {
     "!": "%21",
     "'": "%27",
     "(": "%28",
     ")": "%29",
     "~": "%7E",
-    "%20": "+",
-    "%00": "\0"
+    "%20": "+"
   };
-  return encodeURIComponent(str).replace(/[!'()~]|%20|%00/g, function replacer(match) {
+  return encodeURIComponent(str2).replace(/[!'()~]|%20/g, function replacer(match) {
     return charMap[match];
   });
 }
@@ -933,13 +2051,11 @@ function AxiosURLSearchParams(params, options) {
   params && toFormData$1(params, this, options);
 }
 const prototype = AxiosURLSearchParams.prototype;
-prototype.append = function append(name, value) {
-  this._pairs.push([name, value]);
+prototype.append = function append(name2, value) {
+  this._pairs.push([name2, value]);
 };
 prototype.toString = function toString2(encoder) {
-  const _encode = encoder ? function(value) {
-    return encoder.call(this, value, encode$1);
-  } : encode$1;
+  const _encode = encoder ? (value) => encoder.call(this, value, encode$1) : encode$1;
   return this._pairs.map(function each(pair) {
     return _encode(pair[0]) + "=" + _encode(pair[1]);
   }, "").join("&");
@@ -951,18 +2067,17 @@ function buildURL(url, params, options) {
   if (!params) {
     return url;
   }
-  const _encode = options && options.encode || encode;
-  if (utils$1.isFunction(options)) {
-    options = {
-      serialize: options
-    };
-  }
-  const serializeFn = options && options.serialize;
+  url = url || "";
+  const _options = utils$1.isFunction(options) ? {
+    serialize: options
+  } : options;
+  const _encode = utils$1.getSafeProp(_options, "encode") || encode;
+  const serializeFn = utils$1.getSafeProp(_options, "serialize");
   let serializedParams;
   if (serializeFn) {
-    serializedParams = serializeFn(params, options);
+    serializedParams = serializeFn(params, _options);
   } else {
-    serializedParams = utils$1.isURLSearchParams(params) ? params.toString() : new AxiosURLSearchParams(params, options).toString(_encode);
+    serializedParams = utils$1.isURLSearchParams(params) ? params.toString() : new AxiosURLSearchParams(params, _options).toString(_encode);
   }
   if (serializedParams) {
     const hashmarkIndex = url.indexOf("#");
@@ -982,6 +2097,7 @@ class InterceptorManager {
    *
    * @param {Function} fulfilled The function to handle `then` for a `Promise`
    * @param {Function} rejected The function to handle `reject` for a `Promise`
+   * @param {Object} options The options for the interceptor, synchronous and runWhen
    *
    * @return {Number} An ID used to remove interceptor later
    */
@@ -999,7 +2115,7 @@ class InterceptorManager {
    *
    * @param {Number} id The ID that was returned by `use`
    *
-   * @returns {Boolean} `true` if the interceptor was removed, `false` otherwise
+   * @returns {void}
    */
   eject(id) {
     if (this.handlers[id]) {
@@ -1037,7 +2153,10 @@ class InterceptorManager {
 const transitionalDefaults = {
   silentJSONParsing: true,
   forcedJSONParsing: true,
-  clarifyTimeoutError: false
+  clarifyTimeoutError: false,
+  legacyInterceptorReqResOrdering: true,
+  advertiseZstdAcceptEncoding: false,
+  validateStatusUndefinedResolves: true
 };
 const URLSearchParams$1 = typeof URLSearchParams !== "undefined" ? URLSearchParams : AxiosURLSearchParams;
 const FormData$1 = typeof FormData !== "undefined" ? FormData : null;
@@ -1058,456 +2177,210 @@ const hasStandardBrowserWebWorkerEnv = (() => {
   return typeof WorkerGlobalScope !== "undefined" && // eslint-disable-next-line no-undef
   self instanceof WorkerGlobalScope && typeof self.importScripts === "function";
 })();
-const origin = hasBrowserEnv && window.location.href || "http://localhost";
-const utils = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
-  __proto__: null,
-  hasBrowserEnv,
-  hasStandardBrowserEnv,
-  hasStandardBrowserWebWorkerEnv,
-  navigator: _navigator,
-  origin
-}, Symbol.toStringTag, { value: "Module" }));
-const platform = {
-  ...utils,
-  ...platform$1
-};
-function toURLEncodedForm(data, options) {
-  return toFormData$1(data, new platform.classes.URLSearchParams(), {
-    visitor: function(value, key, path, helpers) {
-      if (platform.isNode && utils$1.isBuffer(value)) {
-        this.append(key, value.toString("base64"));
-        return false;
-      }
-      return helpers.defaultVisitor.apply(this, arguments);
-    },
-    ...options
-  });
-}
-function parsePropPath(name) {
-  return utils$1.matchAll(/\w+|\[(\w*)]/g, name).map((match) => {
-    return match[0] === "[]" ? "" : match[1] || match[0];
-  });
-}
-function arrayToObject(arr) {
-  const obj = {};
-  const keys = Object.keys(arr);
-  let i;
-  const len = keys.length;
-  let key;
-  for (i = 0; i < len; i++) {
-    key = keys[i];
-    obj[key] = arr[key];
-  }
-  return obj;
-}
-function formDataToJSON(formData) {
-  function buildPath(path, value, target, index2) {
-    let name = path[index2++];
-    if (name === "__proto__") return true;
-    const isNumericKey = Number.isFinite(+name);
-    const isLast = index2 >= path.length;
-    name = !name && utils$1.isArray(target) ? target.length : name;
-    if (isLast) {
-      if (utils$1.hasOwnProp(target, name)) {
-        target[name] = [target[name], value];
-      } else {
-        target[name] = value;
-      }
-      return !isNumericKey;
-    }
-    if (!target[name] || !utils$1.isObject(target[name])) {
-      target[name] = [];
-    }
-    const result = buildPath(path, value, target[name], index2);
-    if (result && utils$1.isArray(target[name])) {
-      target[name] = arrayToObject(target[name]);
-    }
-    return !isNumericKey;
-  }
-  if (utils$1.isFormData(formData) && utils$1.isFunction(formData.entries)) {
-    const obj = {};
-    utils$1.forEachEntry(formData, (name, value) => {
-      buildPath(parsePropPath(name), value, obj, 0);
-    });
-    return obj;
-  }
-  return null;
-}
-function stringifySafely(rawValue, parser, encoder) {
-  if (utils$1.isString(rawValue)) {
-    try {
-      (parser || JSON.parse)(rawValue);
-      return utils$1.trim(rawValue);
-    } catch (e) {
-      if (e.name !== "SyntaxError") {
-        throw e;
-      }
-    }
-  }
-  return (encoder || JSON.stringify)(rawValue);
-}
-const defaults = {
-  transitional: transitionalDefaults,
-  adapter: ["xhr", "http", "fetch"],
-  transformRequest: [function transformRequest(data, headers) {
-    const contentType = headers.getContentType() || "";
-    const hasJSONContentType = contentType.indexOf("application/json") > -1;
-    const isObjectPayload = utils$1.isObject(data);
-    if (isObjectPayload && utils$1.isHTMLForm(data)) {
-      data = new FormData(data);
-    }
-    const isFormData2 = utils$1.isFormData(data);
-    if (isFormData2) {
-      return hasJSONContentType ? JSON.stringify(formDataToJSON(data)) : data;
-    }
-    if (utils$1.isArrayBuffer(data) || utils$1.isBuffer(data) || utils$1.isStream(data) || utils$1.isFile(data) || utils$1.isBlob(data) || utils$1.isReadableStream(data)) {
-      return data;
-    }
-    if (utils$1.isArrayBufferView(data)) {
-      return data.buffer;
-    }
-    if (utils$1.isURLSearchParams(data)) {
-      headers.setContentType("application/x-www-form-urlencoded;charset=utf-8", false);
-      return data.toString();
-    }
-    let isFileList2;
-    if (isObjectPayload) {
-      if (contentType.indexOf("application/x-www-form-urlencoded") > -1) {
-        return toURLEncodedForm(data, this.formSerializer).toString();
-      }
-      if ((isFileList2 = utils$1.isFileList(data)) || contentType.indexOf("multipart/form-data") > -1) {
-        const _FormData = this.env && this.env.FormData;
-        return toFormData$1(
-          isFileList2 ? { "files[]": data } : data,
-          _FormData && new _FormData(),
-          this.formSerializer
-        );
-      }
-    }
-    if (isObjectPayload || hasJSONContentType) {
-      headers.setContentType("application/json", false);
-      return stringifySafely(data);
-    }
-    return data;
-  }],
-  transformResponse: [function transformResponse(data) {
-    const transitional2 = this.transitional || defaults.transitional;
-    const forcedJSONParsing = transitional2 && transitional2.forcedJSONParsing;
-    const JSONRequested = this.responseType === "json";
-    if (utils$1.isResponse(data) || utils$1.isReadableStream(data)) {
-      return data;
-    }
-    if (data && utils$1.isString(data) && (forcedJSONParsing && !this.responseType || JSONRequested)) {
-      const silentJSONParsing = transitional2 && transitional2.silentJSONParsing;
-      const strictJSONParsing = !silentJSONParsing && JSONRequested;
-      try {
-        return JSON.parse(data, this.parseReviver);
-      } catch (e) {
-        if (strictJSONParsing) {
-          if (e.name === "SyntaxError") {
-            throw AxiosError$1.from(e, AxiosError$1.ERR_BAD_RESPONSE, this, null, this.response);
-          }
-          throw e;
-        }
-      }
-    }
-    return data;
-  }],
-  /**
-   * A timeout in milliseconds to abort a request. If set to 0 (default) a
-   * timeout is not created.
-   */
-  timeout: 0,
-  xsrfCookieName: "XSRF-TOKEN",
-  xsrfHeaderName: "X-XSRF-TOKEN",
-  maxContentLength: -1,
-  maxBodyLength: -1,
-  env: {
-    FormData: platform.classes.FormData,
-    Blob: platform.classes.Blob
-  },
-  validateStatus: function validateStatus(status) {
-    return status >= 200 && status < 300;
-  },
-  headers: {
-    common: {
-      "Accept": "application/json, text/plain, */*",
-      "Content-Type": void 0
-    }
-  }
-};
-utils$1.forEach(["delete", "get", "head", "post", "put", "patch"], (method) => {
-  defaults.headers[method] = {};
-});
-const ignoreDuplicateOf = utils$1.toObjectSet([
-  "age",
-  "authorization",
-  "content-length",
-  "content-type",
-  "etag",
-  "expires",
-  "from",
-  "host",
-  "if-modified-since",
-  "if-unmodified-since",
-  "last-modified",
-  "location",
-  "max-forwards",
-  "proxy-authorization",
-  "referer",
-  "retry-after",
-  "user-agent"
-]);
-const parseHeaders = (rawHeaders) => {
-  const parsed = {};
-  let key;
-  let val;
-  let i;
-  rawHeaders && rawHeaders.split("\n").forEach(function parser(line) {
-    i = line.indexOf(":");
-    key = line.substring(0, i).trim().toLowerCase();
-    val = line.substring(i + 1).trim();
-    if (!key || parsed[key] && ignoreDuplicateOf[key]) {
-      return;
-    }
-    if (key === "set-cookie") {
-      if (parsed[key]) {
-        parsed[key].push(val);
-      } else {
-        parsed[key] = [val];
-      }
-    } else {
-      parsed[key] = parsed[key] ? parsed[key] + ", " + val : val;
-    }
-  });
-  return parsed;
-};
-const $internals = Symbol("internals");
-function normalizeHeader(header) {
-  return header && String(header).trim().toLowerCase();
-}
-function normalizeValue(value) {
-  if (value === false || value == null) {
-    return value;
-  }
-  return utils$1.isArray(value) ? value.map(normalizeValue) : String(value);
-}
-function parseTokens(str) {
-  const tokens = /* @__PURE__ */ Object.create(null);
-  const tokensRE = /([^\s,;=]+)\s*(?:=\s*([^,;]+))?/g;
-  let match;
-  while (match = tokensRE.exec(str)) {
-    tokens[match[1]] = match[2];
-  }
-  return tokens;
-}
-const isValidHeaderName = (str) => /^[-_a-zA-Z0-9^`|~,!#$%&'*+.]+$/.test(str.trim());
-function matchHeaderValue(context, value, header, filter2, isHeaderNameFilter) {
-  if (utils$1.isFunction(filter2)) {
-    return filter2.call(this, value, header);
-  }
-  if (isHeaderNameFilter) {
-    value = header;
-  }
-  if (!utils$1.isString(value)) return;
-  if (utils$1.isString(filter2)) {
-    return value.indexOf(filter2) !== -1;
-  }
-  if (utils$1.isRegExp(filter2)) {
-    return filter2.test(value);
-  }
-}
-function formatHeader(header) {
-  return header.trim().toLowerCase().replace(/([a-z\d])(\w*)/g, (w, char, str) => {
-    return char.toUpperCase() + str;
-  });
-}
-function buildAccessors(obj, header) {
-  const accessorName = utils$1.toCamelCase(" " + header);
-  ["get", "set", "has"].forEach((methodName) => {
-    Object.defineProperty(obj, methodName + accessorName, {
-      value: function(arg1, arg2, arg3) {
-        return this[methodName].call(this, header, arg1, arg2, arg3);
-      },
-      configurable: true
-    });
-  });
-}
-let AxiosHeaders$1 = class AxiosHeaders {
-  constructor(headers) {
-    headers && this.set(headers);
-  }
-  set(header, valueOrRewrite, rewrite) {
-    const self2 = this;
-    function setHeader(_value, _header, _rewrite) {
-      const lHeader = normalizeHeader(_header);
-      if (!lHeader) {
-        throw new Error("header name must be a non-empty string");
-      }
-      const key = utils$1.findKey(self2, lHeader);
-      if (!key || self2[key] === void 0 || _rewrite === true || _rewrite === void 0 && self2[key] !== false) {
-        self2[key || _header] = normalizeValue(_value);
-      }
-    }
-    const setHeaders = (headers, _rewrite) => utils$1.forEach(headers, (_value, _header) => setHeader(_value, _header, _rewrite));
-    if (utils$1.isPlainObject(header) || header instanceof this.constructor) {
-      setHeaders(header, valueOrRewrite);
-    } else if (utils$1.isString(header) && (header = header.trim()) && !isValidHeaderName(header)) {
-      setHeaders(parseHeaders(header), valueOrRewrite);
-    } else if (utils$1.isObject(header) && utils$1.isIterable(header)) {
-      let obj = {}, dest, key;
-      for (const entry of header) {
-        if (!utils$1.isArray(entry)) {
-          throw TypeError("Object iterator must return a key-value pair");
-        }
-        obj[key = entry[0]] = (dest = obj[key]) ? utils$1.isArray(dest) ? [...dest, entry[1]] : [dest, entry[1]] : entry[1];
-      }
-      setHeaders(obj, valueOrRewrite);
-    } else {
-      header != null && setHeader(valueOrRewrite, header, rewrite);
-    }
-    return this;
-  }
-  get(header, parser) {
-    header = normalizeHeader(header);
-    if (header) {
-      const key = utils$1.findKey(this, header);
-      if (key) {
-        const value = this[key];
-        if (!parser) {
-          return value;
-        }
-        if (parser === true) {
-          return parseTokens(value);
-        }
-        if (utils$1.isFunction(parser)) {
-          return parser.call(this, value, key);
-        }
-        if (utils$1.isRegExp(parser)) {
-          return parser.exec(value);
-        }
-        throw new TypeError("parser must be boolean|regexp|function");
+const origin = hasBrowserEnv && window.location.href || "http://localhost";
+const utils = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  hasBrowserEnv,
+  hasStandardBrowserEnv,
+  hasStandardBrowserWebWorkerEnv,
+  navigator: _navigator,
+  origin
+}, Symbol.toStringTag, { value: "Module" }));
+const platform = {
+  ...utils,
+  ...platform$1
+};
+function toURLEncodedForm(data, options) {
+  return toFormData$1(data, new platform.classes.URLSearchParams(), {
+    visitor: function(value, key, path, helpers) {
+      if (platform.isNode && utils$1.isBuffer(value)) {
+        this.append(key, value.toString("base64"));
+        return false;
       }
-    }
+      return helpers.defaultVisitor.apply(this, arguments);
+    },
+    ...options
+  });
+}
+const MAX_DEPTH = DEFAULT_FORM_DATA_MAX_DEPTH;
+function throwIfDepthExceeded(index2) {
+  if (index2 > MAX_DEPTH) {
+    throw new AxiosError$1(
+      "FormData field is too deeply nested (" + index2 + " levels). Max depth: " + MAX_DEPTH,
+      AxiosError$1.ERR_FORM_DATA_DEPTH_EXCEEDED
+    );
   }
-  has(header, matcher) {
-    header = normalizeHeader(header);
-    if (header) {
-      const key = utils$1.findKey(this, header);
-      return !!(key && this[key] !== void 0 && (!matcher || matchHeaderValue(this, this[key], key, matcher)));
-    }
-    return false;
+}
+function parsePropPath(name2) {
+  const path = [];
+  const pattern = /\w+|\[(\w*)]/g;
+  let match;
+  while ((match = pattern.exec(name2)) !== null) {
+    throwIfDepthExceeded(path.length);
+    path.push(match[0] === "[]" ? "" : match[1] || match[0]);
   }
-  delete(header, matcher) {
-    const self2 = this;
-    let deleted = false;
-    function deleteHeader(_header) {
-      _header = normalizeHeader(_header);
-      if (_header) {
-        const key = utils$1.findKey(self2, _header);
-        if (key && (!matcher || matchHeaderValue(self2, self2[key], key, matcher))) {
-          delete self2[key];
-          deleted = true;
-        }
+  return path;
+}
+function arrayToObject(arr) {
+  const obj = {};
+  const keys = Object.keys(arr);
+  let i;
+  const len = keys.length;
+  let key;
+  for (i = 0; i < len; i++) {
+    key = keys[i];
+    obj[key] = arr[key];
+  }
+  return obj;
+}
+function formDataToJSON(formData) {
+  function buildPath(path, value, target, index2) {
+    throwIfDepthExceeded(index2);
+    let name2 = path[index2++];
+    if (name2 === "__proto__") return true;
+    const isNumericKey = Number.isFinite(+name2);
+    const isLast = index2 >= path.length;
+    name2 = !name2 && utils$1.isArray(target) ? target.length : name2;
+    if (isLast) {
+      if (utils$1.hasOwnProp(target, name2)) {
+        target[name2] = utils$1.isArray(target[name2]) ? target[name2].concat(value) : [target[name2], value];
+      } else {
+        target[name2] = value;
       }
+      return !isNumericKey;
     }
-    if (utils$1.isArray(header)) {
-      header.forEach(deleteHeader);
-    } else {
-      deleteHeader(header);
+    if (!utils$1.hasOwnProp(target, name2) || !utils$1.isObject(target[name2])) {
+      target[name2] = [];
     }
-    return deleted;
-  }
-  clear(matcher) {
-    const keys = Object.keys(this);
-    let i = keys.length;
-    let deleted = false;
-    while (i--) {
-      const key = keys[i];
-      if (!matcher || matchHeaderValue(this, this[key], key, matcher, true)) {
-        delete this[key];
-        deleted = true;
-      }
+    const result = buildPath(path, value, target[name2], index2);
+    if (result && utils$1.isArray(target[name2])) {
+      target[name2] = arrayToObject(target[name2]);
     }
-    return deleted;
-  }
-  normalize(format) {
-    const self2 = this;
-    const headers = {};
-    utils$1.forEach(this, (value, header) => {
-      const key = utils$1.findKey(headers, header);
-      if (key) {
-        self2[key] = normalizeValue(value);
-        delete self2[header];
-        return;
-      }
-      const normalized = format ? formatHeader(header) : String(header).trim();
-      if (normalized !== header) {
-        delete self2[header];
-      }
-      self2[normalized] = normalizeValue(value);
-      headers[normalized] = true;
-    });
-    return this;
-  }
-  concat(...targets) {
-    return this.constructor.concat(this, ...targets);
+    return !isNumericKey;
   }
-  toJSON(asStrings) {
-    const obj = /* @__PURE__ */ Object.create(null);
-    utils$1.forEach(this, (value, header) => {
-      value != null && value !== false && (obj[header] = asStrings && utils$1.isArray(value) ? value.join(", ") : value);
+  if (utils$1.isFormData(formData) && utils$1.isFunction(formData.entries)) {
+    const obj = {};
+    utils$1.forEachEntry(formData, (name2, value) => {
+      buildPath(parsePropPath(name2), value, obj, 0);
     });
     return obj;
   }
-  [Symbol.iterator]() {
-    return Object.entries(this.toJSON())[Symbol.iterator]();
-  }
-  toString() {
-    return Object.entries(this.toJSON()).map(([header, value]) => header + ": " + value).join("\n");
-  }
-  getSetCookie() {
-    return this.get("set-cookie") || [];
-  }
-  get [Symbol.toStringTag]() {
-    return "AxiosHeaders";
-  }
-  static from(thing) {
-    return thing instanceof this ? thing : new this(thing);
-  }
-  static concat(first, ...targets) {
-    const computed = new this(first);
-    targets.forEach((target) => computed.set(target));
-    return computed;
+  return null;
+}
+const own = (obj, key) => obj != null && utils$1.hasOwnProp(obj, key) ? obj[key] : void 0;
+function stringifySafely(rawValue, parser, encoder) {
+  if (utils$1.isString(rawValue)) {
+    try {
+      (parser || JSON.parse)(rawValue);
+      return utils$1.trim(rawValue);
+    } catch (e) {
+      if (e.name !== "SyntaxError") {
+        throw e;
+      }
+    }
   }
-  static accessor(header) {
-    const internals = this[$internals] = this[$internals] = {
-      accessors: {}
-    };
-    const accessors = internals.accessors;
-    const prototype2 = this.prototype;
-    function defineAccessor(_header) {
-      const lHeader = normalizeHeader(_header);
-      if (!accessors[lHeader]) {
-        buildAccessors(prototype2, _header);
-        accessors[lHeader] = true;
+  return (encoder || JSON.stringify)(rawValue);
+}
+const defaults = {
+  transitional: transitionalDefaults,
+  adapter: ["xhr", "http", "fetch"],
+  transformRequest: [
+    function transformRequest(data, headers) {
+      const contentType = headers.getContentType() || "";
+      const hasJSONContentType = contentType.indexOf("application/json") > -1;
+      const isObjectPayload = utils$1.isObject(data);
+      if (isObjectPayload && utils$1.isHTMLForm(data)) {
+        data = new FormData(data);
+      }
+      const isFormData2 = utils$1.isFormData(data);
+      if (isFormData2) {
+        return hasJSONContentType ? JSON.stringify(formDataToJSON(data)) : data;
+      }
+      if (utils$1.isArrayBuffer(data) || utils$1.isBuffer(data) || utils$1.isStream(data) || utils$1.isFile(data) || utils$1.isBlob(data) || utils$1.isReadableStream(data)) {
+        return data;
       }
+      if (utils$1.isArrayBufferView(data)) {
+        return data.buffer;
+      }
+      if (utils$1.isURLSearchParams(data)) {
+        headers.setContentType("application/x-www-form-urlencoded;charset=utf-8", false);
+        return data.toString();
+      }
+      let isFileList2;
+      if (isObjectPayload) {
+        const formSerializer = own(this, "formSerializer");
+        if (contentType.indexOf("application/x-www-form-urlencoded") > -1) {
+          return toURLEncodedForm(data, formSerializer).toString();
+        }
+        if ((isFileList2 = utils$1.isFileList(data)) || contentType.indexOf("multipart/form-data") > -1) {
+          const env = own(this, "env");
+          const _FormData = env && env.FormData;
+          return toFormData$1(
+            isFileList2 ? { "files[]": data } : data,
+            _FormData && new _FormData(),
+            formSerializer
+          );
+        }
+      }
+      if (isObjectPayload || hasJSONContentType) {
+        headers.setContentType("application/json", false);
+        return stringifySafely(data);
+      }
+      return data;
+    }
+  ],
+  transformResponse: [
+    function transformResponse(data) {
+      const transitional2 = own(this, "transitional") || defaults.transitional;
+      const forcedJSONParsing = transitional2 && transitional2.forcedJSONParsing;
+      const responseType = own(this, "responseType");
+      const JSONRequested = responseType === "json";
+      if (utils$1.isResponse(data) || utils$1.isReadableStream(data)) {
+        return data;
+      }
+      if (data && utils$1.isString(data) && (forcedJSONParsing && !responseType || JSONRequested)) {
+        const silentJSONParsing = transitional2 && transitional2.silentJSONParsing;
+        const strictJSONParsing = !silentJSONParsing && JSONRequested;
+        try {
+          return JSON.parse(data, own(this, "parseReviver"));
+        } catch (e) {
+          if (strictJSONParsing) {
+            if (e.name === "SyntaxError") {
+              throw AxiosError$1.from(e, AxiosError$1.ERR_BAD_RESPONSE, this, null, own(this, "response"));
+            }
+            throw e;
+          }
+        }
+      }
+      return data;
+    }
+  ],
+  /**
+   * A timeout in milliseconds to abort a request. If set to 0 (default) a
+   * timeout is not created.
+   */
+  timeout: 0,
+  xsrfCookieName: "XSRF-TOKEN",
+  xsrfHeaderName: "X-XSRF-TOKEN",
+  maxContentLength: -1,
+  maxBodyLength: -1,
+  env: {
+    FormData: platform.classes.FormData,
+    Blob: platform.classes.Blob
+  },
+  validateStatus: function validateStatus(status) {
+    return status >= 200 && status < 300;
+  },
+  headers: {
+    common: {
+      Accept: "application/json, text/plain, */*",
+      "Content-Type": void 0
     }
-    utils$1.isArray(header) ? header.forEach(defineAccessor) : defineAccessor(header);
-    return this;
   }
 };
-AxiosHeaders$1.accessor(["Content-Type", "Content-Length", "Accept", "Accept-Encoding", "User-Agent", "Authorization"]);
-utils$1.reduceDescriptors(AxiosHeaders$1.prototype, ({ value }, key) => {
-  let mapped = key[0].toUpperCase() + key.slice(1);
-  return {
-    get: () => value,
-    set(headerValue) {
-      this[mapped] = headerValue;
-    }
-  };
+utils$1.forEach(["delete", "get", "head", "post", "put", "patch", "query"], (method) => {
+  defaults.headers[method] = {};
 });
-utils$1.freezeMethods(AxiosHeaders$1);
 function transformData(fns, response) {
   const config2 = this || defaults;
   const context = response || config2;
@@ -1522,13 +2395,22 @@ function transformData(fns, response) {
 function isCancel$1(value) {
   return !!(value && value.__CANCEL__);
 }
-function CanceledError$1(message, config2, request) {
-  AxiosError$1.call(this, message == null ? "canceled" : message, AxiosError$1.ERR_CANCELED, config2, request);
-  this.name = "CanceledError";
-}
-utils$1.inherits(CanceledError$1, AxiosError$1, {
-  __CANCEL__: true
-});
+let CanceledError$1 = class CanceledError extends AxiosError$1 {
+  /**
+   * A `CanceledError` is an object that is thrown when an operation is canceled.
+   *
+   * @param {string=} message The message.
+   * @param {Object=} config The config.
+   * @param {Object=} request The request.
+   *
+   * @returns {CanceledError} The created error.
+   */
+  constructor(message, config2, request) {
+    super(message == null ? "canceled" : message, AxiosError$1.ERR_CANCELED, config2, request);
+    this.name = "CanceledError";
+    this.__CANCEL__ = true;
+  }
+};
 function settle(resolve, reject, response) {
   const validateStatus2 = response.config.validateStatus;
   if (!response.status || !validateStatus2 || validateStatus2(response.status)) {
@@ -1536,7 +2418,7 @@ function settle(resolve, reject, response) {
   } else {
     reject(new AxiosError$1(
       "Request failed with status code " + response.status,
-      [AxiosError$1.ERR_BAD_REQUEST, AxiosError$1.ERR_BAD_RESPONSE][Math.floor(response.status / 100) - 4],
+      response.status >= 400 && response.status < 500 ? AxiosError$1.ERR_BAD_REQUEST : AxiosError$1.ERR_BAD_RESPONSE,
       response.config,
       response.request,
       response
@@ -1544,7 +2426,7 @@ function settle(resolve, reject, response) {
   }
 }
 function parseProtocol(url) {
-  const match = /^([-+\w]{1,25})(:?\/\/|:)/.exec(url);
+  const match = /^([-+\w]{1,25}):(?:\/\/)?/.exec(url);
   return match && match[1] || "";
 }
 function speedometer(samplesCount, min) {
@@ -1616,19 +2498,22 @@ const progressEventReducer = (listener, isDownloadStream, freq = 3) => {
   let bytesNotified = 0;
   const _speedometer = speedometer(50, 250);
   return throttle((e) => {
-    const loaded = e.loaded;
+    if (!e || typeof e.loaded !== "number") {
+      return;
+    }
+    const rawLoaded = e.loaded;
     const total = e.lengthComputable ? e.total : void 0;
-    const progressBytes = loaded - bytesNotified;
+    const loaded = total != null ? Math.min(rawLoaded, total) : rawLoaded;
+    const progressBytes = Math.max(0, loaded - bytesNotified);
     const rate = _speedometer(progressBytes);
-    const inRange = loaded <= total;
-    bytesNotified = loaded;
+    bytesNotified = Math.max(bytesNotified, loaded);
     const data = {
       loaded,
       total,
       progress: total ? loaded / total : void 0,
       bytes: progressBytes,
       rate: rate ? rate : void 0,
-      estimated: rate && total && inRange ? (total - loaded) / rate : void 0,
+      estimated: rate && total ? (total - loaded) / rate : void 0,
       event: e,
       lengthComputable: total != null,
       [isDownloadStream ? "download" : "upload"]: true
@@ -1638,11 +2523,14 @@ const progressEventReducer = (listener, isDownloadStream, freq = 3) => {
 };
 const progressEventDecorator = (total, throttled) => {
   const lengthComputable = total != null;
-  return [(loaded) => throttled[0]({
-    lengthComputable,
-    total,
-    loaded
-  }), throttled[1]];
+  return [
+    (loaded) => throttled[0]({
+      lengthComputable,
+      total,
+      loaded
+    }),
+    throttled[1]
+  ];
 };
 const asyncDecorator = (fn) => (...args) => utils$1.asap(() => fn(...args));
 const isURLSameOrigin = platform.hasStandardBrowserEnv ? /* @__PURE__ */ ((origin2, isMSIE) => (url) => {
@@ -1655,20 +2543,44 @@ const isURLSameOrigin = platform.hasStandardBrowserEnv ? /* @__PURE__ */ ((origi
 const cookies = platform.hasStandardBrowserEnv ? (
   // Standard browser envs support document.cookie
   {
-    write(name, value, expires, path, domain, secure) {
-      const cookie = [name + "=" + encodeURIComponent(value)];
-      utils$1.isNumber(expires) && cookie.push("expires=" + new Date(expires).toGMTString());
-      utils$1.isString(path) && cookie.push("path=" + path);
-      utils$1.isString(domain) && cookie.push("domain=" + domain);
-      secure === true && cookie.push("secure");
+    write(name2, value, expires, path, domain, secure, sameSite) {
+      if (typeof document === "undefined") return;
+      const cookie = [`${name2}=${encodeURIComponent(value)}`];
+      if (utils$1.isNumber(expires)) {
+        cookie.push(`expires=${new Date(expires).toUTCString()}`);
+      }
+      if (utils$1.isString(path)) {
+        cookie.push(`path=${path}`);
+      }
+      if (utils$1.isString(domain)) {
+        cookie.push(`domain=${domain}`);
+      }
+      if (secure === true) {
+        cookie.push("secure");
+      }
+      if (utils$1.isString(sameSite)) {
+        cookie.push(`SameSite=${sameSite}`);
+      }
       document.cookie = cookie.join("; ");
     },
-    read(name) {
-      const match = document.cookie.match(new RegExp("(^|;\\s*)(" + name + ")=([^;]*)"));
-      return match ? decodeURIComponent(match[3]) : null;
+    read(name2) {
+      if (typeof document === "undefined") return null;
+      const cookies2 = document.cookie.split(";");
+      for (let i = 0; i < cookies2.length; i++) {
+        const cookie = cookies2[i].replace(/^\s+/, "");
+        const eq = cookie.indexOf("=");
+        if (eq !== -1 && cookie.slice(0, eq) === name2) {
+          try {
+            return decodeURIComponent(cookie.slice(eq + 1));
+          } catch (e) {
+            return cookie.slice(eq + 1);
+          }
+        }
+      }
+      return null;
     },
-    remove(name) {
-      this.write(name, "", Date.now() - 864e5);
+    remove(name2) {
+      this.write(name2, "", Date.now() - 864e5, "/");
     }
   }
 ) : (
@@ -1684,22 +2596,58 @@ const cookies = platform.hasStandardBrowserEnv ? (
   }
 );
 function isAbsoluteURL(url) {
+  if (typeof url !== "string") {
+    return false;
+  }
   return /^([a-z][a-z\d+\-.]*:)?\/\//i.test(url);
 }
 function combineURLs(baseURL, relativeURL) {
   return relativeURL ? baseURL.replace(/\/?\/$/, "") + "/" + relativeURL.replace(/^\/+/, "") : baseURL;
 }
-function buildFullPath(baseURL, requestedURL, allowAbsoluteUrls) {
+const malformedHttpProtocol = /^https?:(?!\/\/)/i;
+const httpProtocolControlCharacters = /[\t\n\r]/g;
+function stripLeadingC0ControlOrSpace(url) {
+  let i = 0;
+  while (i < url.length && url.charCodeAt(i) <= 32) {
+    i++;
+  }
+  return url.slice(i);
+}
+function normalizeURLForProtocolCheck(url) {
+  return stripLeadingC0ControlOrSpace(url).replace(httpProtocolControlCharacters, "");
+}
+function assertValidHttpProtocolURL(url, config2) {
+  if (typeof url === "string" && malformedHttpProtocol.test(normalizeURLForProtocolCheck(url))) {
+    throw new AxiosError$1(
+      'Invalid URL: missing "//" after protocol',
+      AxiosError$1.ERR_INVALID_URL,
+      config2
+    );
+  }
+}
+function buildFullPath(baseURL, requestedURL, allowAbsoluteUrls, config2) {
+  assertValidHttpProtocolURL(requestedURL, config2);
   let isRelativeUrl = !isAbsoluteURL(requestedURL);
-  if (baseURL && (isRelativeUrl || allowAbsoluteUrls == false)) {
+  if (baseURL && (isRelativeUrl || allowAbsoluteUrls === false)) {
+    assertValidHttpProtocolURL(baseURL, config2);
     return combineURLs(baseURL, requestedURL);
   }
   return requestedURL;
 }
 const headersToObject = (thing) => thing instanceof AxiosHeaders$1 ? { ...thing } : thing;
 function mergeConfig$1(config1, config2) {
+  config1 = config1 || {};
   config2 = config2 || {};
-  const config3 = {};
+  const config3 = /* @__PURE__ */ Object.create(null);
+  Object.defineProperty(config3, "hasOwnProperty", {
+    // Null-proto descriptor so a polluted Object.prototype.get cannot turn
+    // this data descriptor into an accessor descriptor on the way in.
+    __proto__: null,
+    value: Object.prototype.hasOwnProperty,
+    enumerable: false,
+    writable: true,
+    configurable: true
+  });
   function getMergedValue(target, source, prop, caseless) {
     if (utils$1.isPlainObject(target) && utils$1.isPlainObject(source)) {
       return utils$1.merge.call({ caseless }, target, source);
@@ -1729,10 +2677,27 @@ function mergeConfig$1(config1, config2) {
       return getMergedValue(void 0, a);
     }
   }
+  function getMergedTransitionalOption(prop) {
+    const transitional2 = utils$1.hasOwnProp(config2, "transitional") ? config2.transitional : void 0;
+    if (!utils$1.isUndefined(transitional2)) {
+      if (utils$1.isPlainObject(transitional2)) {
+        if (utils$1.hasOwnProp(transitional2, prop)) {
+          return transitional2[prop];
+        }
+      } else {
+        return void 0;
+      }
+    }
+    const transitional1 = utils$1.hasOwnProp(config1, "transitional") ? config1.transitional : void 0;
+    if (utils$1.isPlainObject(transitional1) && utils$1.hasOwnProp(transitional1, prop)) {
+      return transitional1[prop];
+    }
+    return void 0;
+  }
   function mergeDirectKeys(a, b, prop) {
-    if (prop in config2) {
+    if (utils$1.hasOwnProp(config2, prop)) {
       return getMergedValue(a, b);
-    } else if (prop in config1) {
+    } else if (utils$1.hasOwnProp(config1, prop)) {
       return getMergedValue(void 0, a);
     }
   }
@@ -1763,44 +2728,87 @@ function mergeConfig$1(config1, config2) {
     httpsAgent: defaultToConfig2,
     cancelToken: defaultToConfig2,
     socketPath: defaultToConfig2,
+    allowedSocketPaths: defaultToConfig2,
     responseEncoding: defaultToConfig2,
     validateStatus: mergeDirectKeys,
     headers: (a, b, prop) => mergeDeepProperties(headersToObject(a), headersToObject(b), prop, true)
   };
   utils$1.forEach(Object.keys({ ...config1, ...config2 }), function computeConfigValue(prop) {
-    const merge2 = mergeMap[prop] || mergeDeepProperties;
-    const configValue = merge2(config1[prop], config2[prop], prop);
+    if (prop === "__proto__" || prop === "constructor" || prop === "prototype") return;
+    const merge2 = utils$1.hasOwnProp(mergeMap, prop) ? mergeMap[prop] : mergeDeepProperties;
+    const a = utils$1.hasOwnProp(config1, prop) ? config1[prop] : void 0;
+    const b = utils$1.hasOwnProp(config2, prop) ? config2[prop] : void 0;
+    const configValue = merge2(a, b, prop);
     utils$1.isUndefined(configValue) && merge2 !== mergeDirectKeys || (config3[prop] = configValue);
   });
+  if (utils$1.hasOwnProp(config2, "validateStatus") && utils$1.isUndefined(config2.validateStatus) && getMergedTransitionalOption("validateStatusUndefinedResolves") === false) {
+    if (utils$1.hasOwnProp(config1, "validateStatus")) {
+      config3.validateStatus = getMergedValue(void 0, config1.validateStatus);
+    } else {
+      delete config3.validateStatus;
+    }
+  }
   return config3;
 }
-const resolveConfig = (config2) => {
+const FORM_DATA_CONTENT_HEADERS = ["content-type", "content-length"];
+function setFormDataHeaders(headers, formHeaders, policy) {
+  if (policy !== "content-only") {
+    headers.set(formHeaders);
+    return;
+  }
+  Object.entries(formHeaders || {}).forEach(([key, val]) => {
+    if (FORM_DATA_CONTENT_HEADERS.includes(key.toLowerCase())) {
+      headers.set(key, val);
+    }
+  });
+}
+const encodeUTF8$1 = (str2) => encodeURIComponent(str2).replace(
+  /%([0-9A-F]{2})/gi,
+  (_, hex) => String.fromCharCode(parseInt(hex, 16))
+);
+function resolveConfig(config2) {
   const newConfig = mergeConfig$1({}, config2);
-  let { data, withXSRFToken, xsrfHeaderName, xsrfCookieName, headers, auth } = newConfig;
+  const own2 = (key) => utils$1.hasOwnProp(newConfig, key) ? newConfig[key] : void 0;
+  const data = own2("data");
+  let withXSRFToken = own2("withXSRFToken");
+  const xsrfHeaderName = own2("xsrfHeaderName");
+  const xsrfCookieName = own2("xsrfCookieName");
+  let headers = own2("headers");
+  const auth = own2("auth");
+  const baseURL = own2("baseURL");
+  const allowAbsoluteUrls = own2("allowAbsoluteUrls");
+  const url = own2("url");
   newConfig.headers = headers = AxiosHeaders$1.from(headers);
-  newConfig.url = buildURL(buildFullPath(newConfig.baseURL, newConfig.url, newConfig.allowAbsoluteUrls), config2.params, config2.paramsSerializer);
+  newConfig.url = buildURL(
+    buildFullPath(baseURL, url, allowAbsoluteUrls, newConfig),
+    own2("params"),
+    own2("paramsSerializer")
+  );
   if (auth) {
-    headers.set(
-      "Authorization",
-      "Basic " + btoa((auth.username || "") + ":" + (auth.password ? unescape(encodeURIComponent(auth.password)) : ""))
-    );
+    const username = utils$1.getSafeProp(auth, "username") || "";
+    const password = utils$1.getSafeProp(auth, "password") || "";
+    try {
+      headers.set(
+        "Authorization",
+        "Basic " + btoa(username + ":" + (password ? encodeUTF8$1(password) : ""))
+      );
+    } catch (e) {
+      throw AxiosError$1.from(e, AxiosError$1.ERR_BAD_OPTION_VALUE, config2);
+    }
   }
   if (utils$1.isFormData(data)) {
-    if (platform.hasStandardBrowserEnv || platform.hasStandardBrowserWebWorkerEnv) {
+    if (platform.hasStandardBrowserEnv || platform.hasStandardBrowserWebWorkerEnv || utils$1.isReactNative(data)) {
       headers.setContentType(void 0);
     } else if (utils$1.isFunction(data.getHeaders)) {
-      const formHeaders = data.getHeaders();
-      const allowedHeaders = ["content-type", "content-length"];
-      Object.entries(formHeaders).forEach(([key, val]) => {
-        if (allowedHeaders.includes(key.toLowerCase())) {
-          headers.set(key, val);
-        }
-      });
+      setFormDataHeaders(headers, data.getHeaders(), own2("formDataHeaderPolicy"));
     }
   }
   if (platform.hasStandardBrowserEnv) {
-    withXSRFToken && utils$1.isFunction(withXSRFToken) && (withXSRFToken = withXSRFToken(newConfig));
-    if (withXSRFToken || withXSRFToken !== false && isURLSameOrigin(newConfig.url)) {
+    if (utils$1.isFunction(withXSRFToken)) {
+      withXSRFToken = withXSRFToken(newConfig);
+    }
+    const shouldSendXSRF = withXSRFToken === true || withXSRFToken == null && isURLSameOrigin(newConfig.url);
+    if (shouldSendXSRF) {
       const xsrfValue = xsrfHeaderName && xsrfCookieName && cookies.read(xsrfCookieName);
       if (xsrfValue) {
         headers.set(xsrfHeaderName, xsrfValue);
@@ -1808,7 +2816,7 @@ const resolveConfig = (config2) => {
     }
   }
   return newConfig;
-};
+}
 const isXHRAdapterSupported = typeof XMLHttpRequest !== "undefined";
 const xhrAdapter = isXHRAdapterSupported && function(config2) {
   return new Promise(function dispatchXhrRequest(resolve, reject) {
@@ -1844,13 +2852,17 @@ const xhrAdapter = isXHRAdapterSupported && function(config2) {
         config: config2,
         request
       };
-      settle(function _resolve(value) {
-        resolve(value);
-        done();
-      }, function _reject(err) {
-        reject(err);
-        done();
-      }, response);
+      settle(
+        function _resolve(value) {
+          resolve(value);
+          done();
+        },
+        function _reject(err) {
+          reject(err);
+          done();
+        },
+        response
+      );
       request = null;
     }
     if ("onloadend" in request) {
@@ -1860,7 +2872,7 @@ const xhrAdapter = isXHRAdapterSupported && function(config2) {
         if (!request || request.readyState !== 4) {
           return;
         }
-        if (request.status === 0 && !(request.responseURL && request.responseURL.indexOf("file:") === 0)) {
+        if (request.status === 0 && !(request.responseURL && request.responseURL.startsWith("file:"))) {
           return;
         }
         setTimeout(onloadend);
@@ -1871,6 +2883,7 @@ const xhrAdapter = isXHRAdapterSupported && function(config2) {
         return;
       }
       reject(new AxiosError$1("Request aborted", AxiosError$1.ECONNABORTED, config2, request));
+      done();
       request = null;
     };
     request.onerror = function handleError(event) {
@@ -1878,6 +2891,7 @@ const xhrAdapter = isXHRAdapterSupported && function(config2) {
       const err = new AxiosError$1(msg, AxiosError$1.ERR_NETWORK, config2, request);
       err.event = event || null;
       reject(err);
+      done();
       request = null;
     };
     request.ontimeout = function handleTimeout() {
@@ -1886,17 +2900,20 @@ const xhrAdapter = isXHRAdapterSupported && function(config2) {
       if (_config.timeoutErrorMessage) {
         timeoutErrorMessage = _config.timeoutErrorMessage;
       }
-      reject(new AxiosError$1(
-        timeoutErrorMessage,
-        transitional2.clarifyTimeoutError ? AxiosError$1.ETIMEDOUT : AxiosError$1.ECONNABORTED,
-        config2,
-        request
-      ));
+      reject(
+        new AxiosError$1(
+          timeoutErrorMessage,
+          transitional2.clarifyTimeoutError ? AxiosError$1.ETIMEDOUT : AxiosError$1.ECONNABORTED,
+          config2,
+          request
+        )
+      );
+      done();
       request = null;
     };
     requestData === void 0 && requestHeaders.setContentType(null);
     if ("setRequestHeader" in request) {
-      utils$1.forEach(requestHeaders.toJSON(), function setRequestHeader(val, key) {
+      utils$1.forEach(toByteStringHeaderObject(requestHeaders), function setRequestHeader(val, key) {
         request.setRequestHeader(key, val);
       });
     }
@@ -1922,6 +2939,7 @@ const xhrAdapter = isXHRAdapterSupported && function(config2) {
         }
         reject(!cancel || cancel.type ? new CanceledError$1(null, config2, request) : cancel);
         request.abort();
+        done();
         request = null;
       };
       _config.cancelToken && _config.cancelToken.subscribe(onCanceled);
@@ -1930,45 +2948,56 @@ const xhrAdapter = isXHRAdapterSupported && function(config2) {
       }
     }
     const protocol = parseProtocol(_config.url);
-    if (protocol && platform.protocols.indexOf(protocol) === -1) {
-      reject(new AxiosError$1("Unsupported protocol " + protocol + ":", AxiosError$1.ERR_BAD_REQUEST, config2));
+    if (protocol && !platform.protocols.includes(protocol)) {
+      reject(
+        new AxiosError$1(
+          "Unsupported protocol " + protocol + ":",
+          AxiosError$1.ERR_BAD_REQUEST,
+          config2
+        )
+      );
+      done();
       return;
     }
     request.send(requestData || null);
   });
 };
 const composeSignals = (signals, timeout) => {
-  const { length } = signals = signals ? signals.filter(Boolean) : [];
-  if (timeout || length) {
-    let controller2 = new AbortController();
-    let aborted;
-    const onabort = function(reason) {
-      if (!aborted) {
-        aborted = true;
-        unsubscribe();
-        const err = reason instanceof Error ? reason : this.reason;
-        controller2.abort(err instanceof AxiosError$1 ? err : new CanceledError$1(err instanceof Error ? err.message : err));
-      }
-    };
-    let timer = timeout && setTimeout(() => {
-      timer = null;
-      onabort(new AxiosError$1(`timeout ${timeout} of ms exceeded`, AxiosError$1.ETIMEDOUT));
-    }, timeout);
-    const unsubscribe = () => {
-      if (signals) {
-        timer && clearTimeout(timer);
-        timer = null;
-        signals.forEach((signal2) => {
-          signal2.unsubscribe ? signal2.unsubscribe(onabort) : signal2.removeEventListener("abort", onabort);
-        });
-        signals = null;
-      }
-    };
-    signals.forEach((signal2) => signal2.addEventListener("abort", onabort));
-    const { signal } = controller2;
-    signal.unsubscribe = () => utils$1.asap(unsubscribe);
-    return signal;
+  signals = signals ? signals.filter(Boolean) : [];
+  if (!timeout && !signals.length) {
+    return;
   }
+  const controller2 = new AbortController();
+  let aborted = false;
+  const onabort = function(reason) {
+    if (!aborted) {
+      aborted = true;
+      unsubscribe();
+      const err = reason instanceof Error ? reason : this.reason;
+      controller2.abort(
+        err instanceof AxiosError$1 ? err : new CanceledError$1(err instanceof Error ? err.message : err)
+      );
+    }
+  };
+  let timer = timeout && setTimeout(() => {
+    timer = null;
+    onabort(new AxiosError$1(`timeout of ${timeout}ms exceeded`, AxiosError$1.ETIMEDOUT));
+  }, timeout);
+  const unsubscribe = () => {
+    if (!signals) {
+      return;
+    }
+    timer && clearTimeout(timer);
+    timer = null;
+    signals.forEach((signal2) => {
+      signal2.unsubscribe ? signal2.unsubscribe(onabort) : signal2.removeEventListener("abort", onabort);
+    });
+    signals = null;
+  };
+  signals.forEach((signal2) => signal2.addEventListener("abort", onabort, { once: true }));
+  const { signal } = controller2;
+  signal.unsubscribe = () => utils$1.asap(unsubscribe);
+  return signal;
 };
 const streamChunk = function* (chunk, chunkSize) {
   let len = chunk.byteLength;
@@ -2017,44 +3046,127 @@ const trackStream = (stream, chunkSize, onProgress, onFinish) => {
       onFinish && onFinish(e);
     }
   };
-  return new ReadableStream({
-    async pull(controller2) {
-      try {
-        const { done: done2, value } = await iterator2.next();
-        if (done2) {
-          _onFinish();
-          controller2.close();
-          return;
-        }
-        let len = value.byteLength;
-        if (onProgress) {
-          let loadedBytes = bytes += len;
-          onProgress(loadedBytes);
+  return new ReadableStream(
+    {
+      async pull(controller2) {
+        try {
+          const { done: done2, value } = await iterator2.next();
+          if (done2) {
+            _onFinish();
+            controller2.close();
+            return;
+          }
+          let len = value.byteLength;
+          if (onProgress) {
+            let loadedBytes = bytes += len;
+            onProgress(loadedBytes);
+          }
+          controller2.enqueue(new Uint8Array(value));
+        } catch (err) {
+          _onFinish(err);
+          throw err;
         }
-        controller2.enqueue(new Uint8Array(value));
-      } catch (err) {
-        _onFinish(err);
-        throw err;
+      },
+      cancel(reason) {
+        _onFinish(reason);
+        return iterator2.return();
       }
     },
-    cancel(reason) {
-      _onFinish(reason);
-      return iterator2.return();
+    {
+      highWaterMark: 2
     }
-  }, {
-    highWaterMark: 2
-  });
+  );
 };
+const isHexDigit = (charCode) => charCode >= 48 && charCode <= 57 || charCode >= 65 && charCode <= 70 || charCode >= 97 && charCode <= 102;
+const isPercentEncodedByte = (str2, i, len) => i + 2 < len && isHexDigit(str2.charCodeAt(i + 1)) && isHexDigit(str2.charCodeAt(i + 2));
+function estimateDataURLDecodedBytes(url) {
+  if (!url || typeof url !== "string") return 0;
+  if (!url.startsWith("data:")) return 0;
+  const comma = url.indexOf(",");
+  if (comma < 0) return 0;
+  const meta = url.slice(5, comma);
+  const body = url.slice(comma + 1);
+  const isBase64 = /;base64/i.test(meta);
+  if (isBase64) {
+    let effectiveLen = body.length;
+    const len = body.length;
+    for (let i = 0; i < len; i++) {
+      if (body.charCodeAt(i) === 37 && i + 2 < len) {
+        const a = body.charCodeAt(i + 1);
+        const b = body.charCodeAt(i + 2);
+        const isHex = isHexDigit(a) && isHexDigit(b);
+        if (isHex) {
+          effectiveLen -= 2;
+          i += 2;
+        }
+      }
+    }
+    let pad = 0;
+    let idx = len - 1;
+    const tailIsPct3D = (j) => j >= 2 && body.charCodeAt(j - 2) === 37 && // '%'
+    body.charCodeAt(j - 1) === 51 && // '3'
+    (body.charCodeAt(j) === 68 || body.charCodeAt(j) === 100);
+    if (idx >= 0) {
+      if (body.charCodeAt(idx) === 61) {
+        pad++;
+        idx--;
+      } else if (tailIsPct3D(idx)) {
+        pad++;
+        idx -= 3;
+      }
+    }
+    if (pad === 1 && idx >= 0) {
+      if (body.charCodeAt(idx) === 61) {
+        pad++;
+      } else if (tailIsPct3D(idx)) {
+        pad++;
+      }
+    }
+    const groups = Math.floor(effectiveLen / 4);
+    const bytes2 = groups * 3 - (pad || 0);
+    return bytes2 > 0 ? bytes2 : 0;
+  }
+  let bytes = 0;
+  for (let i = 0, len = body.length; i < len; i++) {
+    const c = body.charCodeAt(i);
+    if (c === 37 && isPercentEncodedByte(body, i, len)) {
+      bytes += 1;
+      i += 2;
+    } else if (c < 128) {
+      bytes += 1;
+    } else if (c < 2048) {
+      bytes += 2;
+    } else if (c >= 55296 && c <= 56319 && i + 1 < len) {
+      const next = body.charCodeAt(i + 1);
+      if (next >= 56320 && next <= 57343) {
+        bytes += 4;
+        i++;
+      } else {
+        bytes += 3;
+      }
+    } else {
+      bytes += 3;
+    }
+  }
+  return bytes;
+}
+const VERSION$1 = "1.18.1";
 const DEFAULT_CHUNK_SIZE = 64 * 1024;
 const { isFunction } = utils$1;
-const globalFetchAPI = (({ Request, Response }) => ({
-  Request,
-  Response
-}))(utils$1.global);
-const {
-  ReadableStream: ReadableStream$1,
-  TextEncoder
-} = utils$1.global;
+const encodeUTF8 = (str2) => encodeURIComponent(str2).replace(
+  /%([0-9A-F]{2})/gi,
+  (_, hex) => String.fromCharCode(parseInt(hex, 16))
+);
+const decodeURIComponentSafe = (value) => {
+  if (!utils$1.isString(value)) {
+    return value;
+  }
+  try {
+    return decodeURIComponent(value);
+  } catch (error) {
+    return value;
+  }
+};
 const test = (fn, ...args) => {
   try {
     return !!fn(...args);
@@ -2062,10 +3174,27 @@ const test = (fn, ...args) => {
     return false;
   }
 };
+const maybeWithAuthCredentials = (url) => {
+  const protocolIndex = url.indexOf("://");
+  let urlToCheck = url;
+  if (protocolIndex !== -1) {
+    urlToCheck = urlToCheck.slice(protocolIndex + 3);
+  }
+  return urlToCheck.includes("@") || urlToCheck.includes(":");
+};
 const factory = (env) => {
-  env = utils$1.merge.call({
-    skipUndefined: true
-  }, globalFetchAPI, env);
+  const globalObject = utils$1.global !== void 0 && utils$1.global !== null ? utils$1.global : globalThis;
+  const { ReadableStream: ReadableStream2, TextEncoder } = globalObject;
+  env = utils$1.merge.call(
+    {
+      skipUndefined: true
+    },
+    {
+      Request: globalObject.Request,
+      Response: globalObject.Response
+    },
+    env
+  );
   const { fetch: envFetch, Request, Response } = env;
   const isFetchSupported = envFetch ? isFunction(envFetch) : typeof fetch === "function";
   const isRequestSupported = isFunction(Request);
@@ -2073,18 +3202,22 @@ const factory = (env) => {
   if (!isFetchSupported) {
     return false;
   }
-  const isReadableStreamSupported = isFetchSupported && isFunction(ReadableStream$1);
-  const encodeText = isFetchSupported && (typeof TextEncoder === "function" ? /* @__PURE__ */ ((encoder) => (str) => encoder.encode(str))(new TextEncoder()) : async (str) => new Uint8Array(await new Request(str).arrayBuffer()));
+  const isReadableStreamSupported = isFetchSupported && isFunction(ReadableStream2);
+  const encodeText = isFetchSupported && (typeof TextEncoder === "function" ? /* @__PURE__ */ ((encoder) => (str2) => encoder.encode(str2))(new TextEncoder()) : async (str2) => new Uint8Array(await new Request(str2).arrayBuffer()));
   const supportsRequestStream = isRequestSupported && isReadableStreamSupported && test(() => {
     let duplexAccessed = false;
-    const hasContentType = new Request(platform.origin, {
-      body: new ReadableStream$1(),
+    const request = new Request(platform.origin, {
+      body: new ReadableStream2(),
       method: "POST",
       get duplex() {
         duplexAccessed = true;
         return "half";
       }
-    }).headers.has("Content-Type");
+    });
+    const hasContentType = request.headers.has("Content-Type");
+    if (request.body != null) {
+      request.body.cancel();
+    }
     return duplexAccessed && !hasContentType;
   });
   const supportsResponseStream = isResponseSupported && isReadableStreamSupported && test(() => utils$1.isReadableStream(new Response("").body));
@@ -2098,7 +3231,11 @@ const factory = (env) => {
         if (method) {
           return method.call(res);
         }
-        throw new AxiosError$1(`Response type '${type}' is not supported`, AxiosError$1.ERR_NOT_SUPPORT, config2);
+        throw new AxiosError$1(
+          `Response type '${type}' is not supported`,
+          AxiosError$1.ERR_NOT_SUPPORT,
+          config2
+        );
       });
     });
   })();
@@ -2143,63 +3280,189 @@ const factory = (env) => {
       responseType,
       headers,
       withCredentials = "same-origin",
-      fetchOptions
+      fetchOptions,
+      maxContentLength,
+      maxBodyLength
     } = resolveConfig(config2);
+    const hasMaxContentLength = utils$1.isNumber(maxContentLength) && maxContentLength > -1;
+    const hasMaxBodyLength = utils$1.isNumber(maxBodyLength) && maxBodyLength > -1;
+    const own2 = (key) => utils$1.hasOwnProp(config2, key) ? config2[key] : void 0;
     let _fetch = envFetch || fetch;
     responseType = responseType ? (responseType + "").toLowerCase() : "text";
-    let composedSignal = composeSignals([signal, cancelToken && cancelToken.toAbortSignal()], timeout);
+    let composedSignal = composeSignals(
+      [signal, cancelToken && cancelToken.toAbortSignal()],
+      timeout
+    );
     let request = null;
     const unsubscribe = composedSignal && composedSignal.unsubscribe && (() => {
       composedSignal.unsubscribe();
     });
     let requestContentLength;
+    let pendingBodyError = null;
+    const maxBodyLengthError = () => new AxiosError$1(
+      "Request body larger than maxBodyLength limit",
+      AxiosError$1.ERR_BAD_REQUEST,
+      config2,
+      request
+    );
     try {
-      if (onUploadProgress && supportsRequestStream && method !== "get" && method !== "head" && (requestContentLength = await resolveBodyLength(headers, data)) !== 0) {
-        let _request = new Request(url, {
-          method: "POST",
-          body: data,
-          duplex: "half"
-        });
-        let contentTypeHeader;
-        if (utils$1.isFormData(data) && (contentTypeHeader = _request.headers.get("content-type"))) {
-          headers.setContentType(contentTypeHeader);
+      let auth = void 0;
+      const configAuth = own2("auth");
+      if (configAuth) {
+        const username = utils$1.getSafeProp(configAuth, "username") || "";
+        const password = utils$1.getSafeProp(configAuth, "password") || "";
+        auth = {
+          username,
+          password
+        };
+      }
+      if (maybeWithAuthCredentials(url)) {
+        const parsedURL = new URL(url, platform.origin);
+        if (!auth && (parsedURL.username || parsedURL.password)) {
+          const urlUsername = decodeURIComponentSafe(parsedURL.username);
+          const urlPassword = decodeURIComponentSafe(parsedURL.password);
+          auth = {
+            username: urlUsername,
+            password: urlPassword
+          };
         }
-        if (_request.body) {
-          const [onProgress, flush] = progressEventDecorator(
-            requestContentLength,
-            progressEventReducer(asyncDecorator(onUploadProgress))
+        if (parsedURL.username || parsedURL.password) {
+          parsedURL.username = "";
+          parsedURL.password = "";
+          url = parsedURL.href;
+        }
+      }
+      if (auth) {
+        headers.delete("authorization");
+        headers.set(
+          "Authorization",
+          "Basic " + btoa(encodeUTF8((auth.username || "") + ":" + (auth.password || "")))
+        );
+      }
+      if (hasMaxContentLength && typeof url === "string" && url.startsWith("data:")) {
+        const estimated = estimateDataURLDecodedBytes(url);
+        if (estimated > maxContentLength) {
+          throw new AxiosError$1(
+            "maxContentLength size of " + maxContentLength + " exceeded",
+            AxiosError$1.ERR_BAD_RESPONSE,
+            config2,
+            request
           );
-          data = trackStream(_request.body, DEFAULT_CHUNK_SIZE, onProgress, flush);
         }
       }
+      if (hasMaxBodyLength && method !== "get" && method !== "head") {
+        const outboundLength = await getBodyLength(data);
+        if (typeof outboundLength === "number" && isFinite(outboundLength)) {
+          requestContentLength = outboundLength;
+          if (outboundLength > maxBodyLength) {
+            throw maxBodyLengthError();
+          }
+        }
+      }
+      const mustEnforceStreamBody = hasMaxBodyLength && (utils$1.isReadableStream(data) || utils$1.isStream(data));
+      const trackRequestStream = (stream, onProgress, flush) => trackStream(
+        stream,
+        DEFAULT_CHUNK_SIZE,
+        (loadedBytes) => {
+          if (hasMaxBodyLength && loadedBytes > maxBodyLength) {
+            throw pendingBodyError = maxBodyLengthError();
+          }
+          onProgress && onProgress(loadedBytes);
+        },
+        flush
+      );
+      if (supportsRequestStream && method !== "get" && method !== "head" && (onUploadProgress || mustEnforceStreamBody)) {
+        requestContentLength = requestContentLength == null ? await resolveBodyLength(headers, data) : requestContentLength;
+        if (requestContentLength !== 0 || mustEnforceStreamBody) {
+          let _request = new Request(url, {
+            method: "POST",
+            body: data,
+            duplex: "half"
+          });
+          let contentTypeHeader;
+          if (utils$1.isFormData(data) && (contentTypeHeader = _request.headers.get("content-type"))) {
+            headers.setContentType(contentTypeHeader);
+          }
+          if (_request.body) {
+            const [onProgress, flush] = onUploadProgress && progressEventDecorator(
+              requestContentLength,
+              progressEventReducer(asyncDecorator(onUploadProgress))
+            ) || [];
+            data = trackRequestStream(_request.body, onProgress, flush);
+          }
+        }
+      } else if (mustEnforceStreamBody && !isRequestSupported && isReadableStreamSupported && method !== "get" && method !== "head") {
+        data = trackRequestStream(data);
+      } else if (mustEnforceStreamBody && isRequestSupported && !supportsRequestStream && method !== "get" && method !== "head") {
+        throw new AxiosError$1(
+          "Stream request bodies are not supported by the current fetch implementation",
+          AxiosError$1.ERR_NOT_SUPPORT,
+          config2,
+          request
+        );
+      }
       if (!utils$1.isString(withCredentials)) {
         withCredentials = withCredentials ? "include" : "omit";
       }
       const isCredentialsSupported = isRequestSupported && "credentials" in Request.prototype;
+      if (utils$1.isFormData(data)) {
+        const contentType = headers.getContentType();
+        if (contentType && /^multipart\/form-data/i.test(contentType) && !/boundary=/i.test(contentType)) {
+          headers.delete("content-type");
+        }
+      }
+      headers.set("User-Agent", "axios/" + VERSION$1, false);
       const resolvedOptions = {
         ...fetchOptions,
         signal: composedSignal,
         method: method.toUpperCase(),
-        headers: headers.normalize().toJSON(),
+        headers: toByteStringHeaderObject(headers.normalize()),
         body: data,
         duplex: "half",
         credentials: isCredentialsSupported ? withCredentials : void 0
       };
       request = isRequestSupported && new Request(url, resolvedOptions);
       let response = await (isRequestSupported ? _fetch(request, fetchOptions) : _fetch(url, resolvedOptions));
+      const responseHeaders = AxiosHeaders$1.from(response.headers);
+      if (hasMaxContentLength) {
+        const declaredLength = utils$1.toFiniteNumber(responseHeaders.getContentLength());
+        if (declaredLength != null && declaredLength > maxContentLength) {
+          throw new AxiosError$1(
+            "maxContentLength size of " + maxContentLength + " exceeded",
+            AxiosError$1.ERR_BAD_RESPONSE,
+            config2,
+            request
+          );
+        }
+      }
       const isStreamResponse = supportsResponseStream && (responseType === "stream" || responseType === "response");
-      if (supportsResponseStream && (onDownloadProgress || isStreamResponse && unsubscribe)) {
+      if (supportsResponseStream && response.body && (onDownloadProgress || hasMaxContentLength || isStreamResponse && unsubscribe)) {
         const options = {};
         ["status", "statusText", "headers"].forEach((prop) => {
           options[prop] = response[prop];
         });
-        const responseContentLength = utils$1.toFiniteNumber(response.headers.get("content-length"));
+        const responseContentLength = utils$1.toFiniteNumber(responseHeaders.getContentLength());
         const [onProgress, flush] = onDownloadProgress && progressEventDecorator(
           responseContentLength,
           progressEventReducer(asyncDecorator(onDownloadProgress), true)
         ) || [];
+        let bytesRead = 0;
+        const onChunkProgress = (loadedBytes) => {
+          if (hasMaxContentLength) {
+            bytesRead = loadedBytes;
+            if (bytesRead > maxContentLength) {
+              throw new AxiosError$1(
+                "maxContentLength size of " + maxContentLength + " exceeded",
+                AxiosError$1.ERR_BAD_RESPONSE,
+                config2,
+                request
+              );
+            }
+          }
+          onProgress && onProgress(loadedBytes);
+        };
         response = new Response(
-          trackStream(response.body, DEFAULT_CHUNK_SIZE, onProgress, () => {
+          trackStream(response.body, DEFAULT_CHUNK_SIZE, onChunkProgress, () => {
             flush && flush();
             unsubscribe && unsubscribe();
           }),
@@ -2207,7 +3470,30 @@ const factory = (env) => {
         );
       }
       responseType = responseType || "text";
-      let responseData = await resolvers[utils$1.findKey(resolvers, responseType) || "text"](response, config2);
+      let responseData = await resolvers[utils$1.findKey(resolvers, responseType) || "text"](
+        response,
+        config2
+      );
+      if (hasMaxContentLength && !supportsResponseStream && !isStreamResponse) {
+        let materializedSize;
+        if (responseData != null) {
+          if (typeof responseData.byteLength === "number") {
+            materializedSize = responseData.byteLength;
+          } else if (typeof responseData.size === "number") {
+            materializedSize = responseData.size;
+          } else if (typeof responseData === "string") {
+            materializedSize = typeof TextEncoder === "function" ? new TextEncoder().encode(responseData).byteLength : responseData.length;
+          }
+        }
+        if (typeof materializedSize === "number" && materializedSize > maxContentLength) {
+          throw new AxiosError$1(
+            "maxContentLength size of " + maxContentLength + " exceeded",
+            AxiosError$1.ERR_BAD_RESPONSE,
+            config2,
+            request
+          );
+        }
+      }
       !isStreamResponse && unsubscribe && unsubscribe();
       return await new Promise((resolve, reject) => {
         settle(resolve, reject, {
@@ -2221,27 +3507,55 @@ const factory = (env) => {
       });
     } catch (err) {
       unsubscribe && unsubscribe();
+      if (composedSignal && composedSignal.aborted && composedSignal.reason instanceof AxiosError$1) {
+        const canceledError = composedSignal.reason;
+        canceledError.config = config2;
+        request && (canceledError.request = request);
+        if (err !== canceledError) {
+          Object.defineProperty(canceledError, "cause", {
+            __proto__: null,
+            value: err,
+            writable: true,
+            enumerable: false,
+            configurable: true
+          });
+        }
+        throw canceledError;
+      }
+      if (pendingBodyError) {
+        request && !pendingBodyError.request && (pendingBodyError.request = request);
+        throw pendingBodyError;
+      }
+      if (err instanceof AxiosError$1) {
+        request && !err.request && (err.request = request);
+        throw err;
+      }
       if (err && err.name === "TypeError" && /Load failed|fetch/i.test(err.message)) {
-        throw Object.assign(
-          new AxiosError$1("Network Error", AxiosError$1.ERR_NETWORK, config2, request),
-          {
-            cause: err.cause || err
-          }
+        const networkError = new AxiosError$1(
+          "Network Error",
+          AxiosError$1.ERR_NETWORK,
+          config2,
+          request,
+          err && err.response
         );
+        Object.defineProperty(networkError, "cause", {
+          __proto__: null,
+          value: err.cause || err,
+          writable: true,
+          enumerable: false,
+          configurable: true
+        });
+        throw networkError;
       }
-      throw AxiosError$1.from(err, err && err.code, config2, request);
+      throw AxiosError$1.from(err, err && err.code, config2, request, err && err.response);
     }
   };
 };
 const seedCache = /* @__PURE__ */ new Map();
 const getFetch = (config2) => {
-  let env = config2 ? config2.env : {};
+  let env = config2 && config2.env || {};
   const { fetch: fetch2, Request, Response } = env;
-  const seeds = [
-    Request,
-    Response,
-    fetch2
-  ];
+  const seeds = [Request, Response, fetch2];
   let len = seeds.length, i = len, seed, target, map = seedCache;
   while (i--) {
     seed = seeds[i];
@@ -2262,48 +3576,57 @@ const knownAdapters = {
 utils$1.forEach(knownAdapters, (fn, value) => {
   if (fn) {
     try {
-      Object.defineProperty(fn, "name", { value });
+      Object.defineProperty(fn, "name", { __proto__: null, value });
     } catch (e) {
     }
-    Object.defineProperty(fn, "adapterName", { value });
+    Object.defineProperty(fn, "adapterName", { __proto__: null, value });
   }
 });
 const renderReason = (reason) => `- ${reason}`;
 const isResolvedHandle = (adapter) => utils$1.isFunction(adapter) || adapter === null || adapter === false;
-const adapters = {
-  getAdapter: (adapters2, config2) => {
-    adapters2 = utils$1.isArray(adapters2) ? adapters2 : [adapters2];
-    const { length } = adapters2;
-    let nameOrAdapter;
-    let adapter;
-    const rejectedReasons = {};
-    for (let i = 0; i < length; i++) {
-      nameOrAdapter = adapters2[i];
-      let id;
-      adapter = nameOrAdapter;
-      if (!isResolvedHandle(nameOrAdapter)) {
-        adapter = knownAdapters[(id = String(nameOrAdapter)).toLowerCase()];
-        if (adapter === void 0) {
-          throw new AxiosError$1(`Unknown adapter '${id}'`);
-        }
-      }
-      if (adapter && (utils$1.isFunction(adapter) || (adapter = adapter.get(config2)))) {
-        break;
+function getAdapter$1(adapters2, config2) {
+  adapters2 = utils$1.isArray(adapters2) ? adapters2 : [adapters2];
+  const { length } = adapters2;
+  let nameOrAdapter;
+  let adapter;
+  const rejectedReasons = {};
+  for (let i = 0; i < length; i++) {
+    nameOrAdapter = adapters2[i];
+    let id;
+    adapter = nameOrAdapter;
+    if (!isResolvedHandle(nameOrAdapter)) {
+      adapter = knownAdapters[(id = String(nameOrAdapter)).toLowerCase()];
+      if (adapter === void 0) {
+        throw new AxiosError$1(`Unknown adapter '${id}'`);
       }
-      rejectedReasons[id || "#" + i] = adapter;
     }
-    if (!adapter) {
-      const reasons = Object.entries(rejectedReasons).map(
-        ([id, state]) => `adapter ${id} ` + (state === false ? "is not supported by the environment" : "is not available in the build")
-      );
-      let s = length ? reasons.length > 1 ? "since :\n" + reasons.map(renderReason).join("\n") : " " + renderReason(reasons[0]) : "as no adapter specified";
-      throw new AxiosError$1(
-        `There is no suitable adapter to dispatch the request ` + s,
-        "ERR_NOT_SUPPORT"
-      );
+    if (adapter && (utils$1.isFunction(adapter) || (adapter = adapter.get(config2)))) {
+      break;
     }
-    return adapter;
-  },
+    rejectedReasons[id || "#" + i] = adapter;
+  }
+  if (!adapter) {
+    const reasons = Object.entries(rejectedReasons).map(
+      ([id, state]) => `adapter ${id} ` + (state === false ? "is not supported by the environment" : "is not available in the build")
+    );
+    let s = length ? reasons.length > 1 ? "since :\n" + reasons.map(renderReason).join("\n") : " " + renderReason(reasons[0]) : "as no adapter specified";
+    throw new AxiosError$1(
+      `There is no suitable adapter to dispatch the request ` + s,
+      AxiosError$1.ERR_NOT_SUPPORT
+    );
+  }
+  return adapter;
+}
+const adapters = {
+  /**
+   * Resolve an adapter from a list of adapter names or functions.
+   * @type {Function}
+   */
+  getAdapter: getAdapter$1,
+  /**
+   * Exposes all known adapters
+   * @type {Object<string, Function|Object>}
+   */
   adapters: knownAdapters
 };
 function throwIfCancellationRequested(config2) {
@@ -2317,39 +3640,44 @@ function throwIfCancellationRequested(config2) {
 function dispatchRequest(config2) {
   throwIfCancellationRequested(config2);
   config2.headers = AxiosHeaders$1.from(config2.headers);
-  config2.data = transformData.call(
-    config2,
-    config2.transformRequest
-  );
+  config2.data = transformData.call(config2, config2.transformRequest);
   if (["post", "put", "patch"].indexOf(config2.method) !== -1) {
     config2.headers.setContentType("application/x-www-form-urlencoded", false);
   }
   const adapter = adapters.getAdapter(config2.adapter || defaults.adapter, config2);
-  return adapter(config2).then(function onAdapterResolution(response) {
-    throwIfCancellationRequested(config2);
-    response.data = transformData.call(
-      config2,
-      config2.transformResponse,
-      response
-    );
-    response.headers = AxiosHeaders$1.from(response.headers);
-    return response;
-  }, function onAdapterRejection(reason) {
-    if (!isCancel$1(reason)) {
+  return adapter(config2).then(
+    function onAdapterResolution(response) {
       throwIfCancellationRequested(config2);
-      if (reason && reason.response) {
-        reason.response.data = transformData.call(
-          config2,
-          config2.transformResponse,
-          reason.response
-        );
-        reason.response.headers = AxiosHeaders$1.from(reason.response.headers);
+      config2.response = response;
+      try {
+        response.data = transformData.call(config2, config2.transformResponse, response);
+      } finally {
+        delete config2.response;
+      }
+      response.headers = AxiosHeaders$1.from(response.headers);
+      return response;
+    },
+    function onAdapterRejection(reason) {
+      if (!isCancel$1(reason)) {
+        throwIfCancellationRequested(config2);
+        if (reason && reason.response) {
+          config2.response = reason.response;
+          try {
+            reason.response.data = transformData.call(
+              config2,
+              config2.transformResponse,
+              reason.response
+            );
+          } finally {
+            delete config2.response;
+          }
+          reason.response.headers = AxiosHeaders$1.from(reason.response.headers);
+        }
       }
+      return Promise.reject(reason);
     }
-    return Promise.reject(reason);
-  });
+  );
 }
-const VERSION$1 = "1.12.2";
 const validators$1 = {};
 ["object", "boolean", "number", "function", "string", "symbol"].forEach((type, i) => {
   validators$1[type] = function validator2(thing) {
@@ -2386,20 +3714,23 @@ validators$1.spelling = function spelling(correctSpelling) {
     return true;
   };
 };
-function assertOptions(options, schema, allowUnknown) {
-  if (typeof options !== "object") {
+function assertOptions(options, schema2, allowUnknown) {
+  if (typeof options !== "object" || options === null) {
     throw new AxiosError$1("options must be an object", AxiosError$1.ERR_BAD_OPTION_VALUE);
   }
   const keys = Object.keys(options);
   let i = keys.length;
   while (i-- > 0) {
     const opt = keys[i];
-    const validator2 = schema[opt];
+    const validator2 = Object.prototype.hasOwnProperty.call(schema2, opt) ? schema2[opt] : void 0;
     if (validator2) {
       const value = options[opt];
       const result = value === void 0 || validator2(value, opt, options);
       if (result !== true) {
-        throw new AxiosError$1("option " + opt + " must be " + result, AxiosError$1.ERR_BAD_OPTION_VALUE);
+        throw new AxiosError$1(
+          "option " + opt + " must be " + result,
+          AxiosError$1.ERR_BAD_OPTION_VALUE
+        );
       }
       continue;
     }
@@ -2436,12 +3767,23 @@ let Axios$1 = class Axios {
       if (err instanceof Error) {
         let dummy = {};
         Error.captureStackTrace ? Error.captureStackTrace(dummy) : dummy = new Error();
-        const stack = dummy.stack ? dummy.stack.replace(/^.+\n/, "") : "";
+        const stack = (() => {
+          if (!dummy.stack) {
+            return "";
+          }
+          const firstNewlineIndex = dummy.stack.indexOf("\n");
+          return firstNewlineIndex === -1 ? "" : dummy.stack.slice(firstNewlineIndex + 1);
+        })();
         try {
           if (!err.stack) {
             err.stack = stack;
-          } else if (stack && !String(err.stack).endsWith(stack.replace(/^.+\n.+\n/, ""))) {
-            err.stack += "\n" + stack;
+          } else if (stack) {
+            const firstNewlineIndex = stack.indexOf("\n");
+            const secondNewlineIndex = firstNewlineIndex === -1 ? -1 : stack.indexOf("\n", firstNewlineIndex + 1);
+            const stackWithoutTwoTopLines = secondNewlineIndex === -1 ? "" : stack.slice(secondNewlineIndex + 1);
+            if (!String(err.stack).endsWith(stackWithoutTwoTopLines)) {
+              err.stack += "\n" + stack;
+            }
           }
         } catch (e) {
         }
@@ -2459,11 +3801,18 @@ let Axios$1 = class Axios {
     config2 = mergeConfig$1(this.defaults, config2);
     const { transitional: transitional2, paramsSerializer, headers } = config2;
     if (transitional2 !== void 0) {
-      validator.assertOptions(transitional2, {
-        silentJSONParsing: validators.transitional(validators.boolean),
-        forcedJSONParsing: validators.transitional(validators.boolean),
-        clarifyTimeoutError: validators.transitional(validators.boolean)
-      }, false);
+      validator.assertOptions(
+        transitional2,
+        {
+          silentJSONParsing: validators.transitional(validators.boolean),
+          forcedJSONParsing: validators.transitional(validators.boolean),
+          clarifyTimeoutError: validators.transitional(validators.boolean),
+          legacyInterceptorReqResOrdering: validators.transitional(validators.boolean),
+          advertiseZstdAcceptEncoding: validators.transitional(validators.boolean),
+          validateStatusUndefinedResolves: validators.transitional(validators.boolean)
+        },
+        false
+      );
     }
     if (paramsSerializer != null) {
       if (utils$1.isFunction(paramsSerializer)) {
@@ -2471,10 +3820,14 @@ let Axios$1 = class Axios {
           serialize: paramsSerializer
         };
       } else {
-        validator.assertOptions(paramsSerializer, {
-          encode: validators.function,
-          serialize: validators.function
-        }, true);
+        validator.assertOptions(
+          paramsSerializer,
+          {
+            encode: validators.function,
+            serialize: validators.function
+          },
+          true
+        );
       }
     }
     if (config2.allowAbsoluteUrls !== void 0) ;
@@ -2483,21 +3836,19 @@ let Axios$1 = class Axios {
     } else {
       config2.allowAbsoluteUrls = true;
     }
-    validator.assertOptions(config2, {
-      baseUrl: validators.spelling("baseURL"),
-      withXsrfToken: validators.spelling("withXSRFToken")
-    }, true);
-    config2.method = (config2.method || this.defaults.method || "get").toLowerCase();
-    let contextHeaders = headers && utils$1.merge(
-      headers.common,
-      headers[config2.method]
-    );
-    headers && utils$1.forEach(
-      ["delete", "get", "head", "post", "put", "patch", "common"],
-      (method) => {
-        delete headers[method];
-      }
+    validator.assertOptions(
+      config2,
+      {
+        baseUrl: validators.spelling("baseURL"),
+        withXsrfToken: validators.spelling("withXSRFToken")
+      },
+      true
     );
+    config2.method = (config2.method || this.defaults.method || "get").toLowerCase();
+    let contextHeaders = headers && utils$1.merge(headers.common, headers[config2.method]);
+    headers && utils$1.forEach(["delete", "get", "head", "post", "put", "patch", "query", "common"], (method) => {
+      delete headers[method];
+    });
     config2.headers = AxiosHeaders$1.concat(contextHeaders, headers);
     const requestInterceptorChain = [];
     let synchronousRequestInterceptors = true;
@@ -2506,7 +3857,13 @@ let Axios$1 = class Axios {
         return;
       }
       synchronousRequestInterceptors = synchronousRequestInterceptors && interceptor.synchronous;
-      requestInterceptorChain.unshift(interceptor.fulfilled, interceptor.rejected);
+      const transitional3 = config2.transitional || transitionalDefaults;
+      const legacyInterceptorReqResOrdering = transitional3 && transitional3.legacyInterceptorReqResOrdering;
+      if (legacyInterceptorReqResOrdering) {
+        requestInterceptorChain.unshift(interceptor.fulfilled, interceptor.rejected);
+      } else {
+        requestInterceptorChain.push(interceptor.fulfilled, interceptor.rejected);
+      }
     });
     const responseInterceptorChain = [];
     this.interceptors.response.forEach(function pushResponseInterceptors(interceptor) {
@@ -2552,34 +3909,40 @@ let Axios$1 = class Axios {
   }
   getUri(config2) {
     config2 = mergeConfig$1(this.defaults, config2);
-    const fullPath = buildFullPath(config2.baseURL, config2.url, config2.allowAbsoluteUrls);
+    const fullPath = buildFullPath(config2.baseURL, config2.url, config2.allowAbsoluteUrls, config2);
     return buildURL(fullPath, config2.params, config2.paramsSerializer);
   }
 };
 utils$1.forEach(["delete", "get", "head", "options"], function forEachMethodNoData(method) {
   Axios$1.prototype[method] = function(url, config2) {
-    return this.request(mergeConfig$1(config2 || {}, {
-      method,
-      url,
-      data: (config2 || {}).data
-    }));
+    return this.request(
+      mergeConfig$1(config2 || {}, {
+        method,
+        url,
+        data: config2 && utils$1.hasOwnProp(config2, "data") ? config2.data : void 0
+      })
+    );
   };
 });
-utils$1.forEach(["post", "put", "patch"], function forEachMethodWithData(method) {
+utils$1.forEach(["post", "put", "patch", "query"], function forEachMethodWithData(method) {
   function generateHTTPMethod(isForm) {
     return function httpMethod(url, data, config2) {
-      return this.request(mergeConfig$1(config2 || {}, {
-        method,
-        headers: isForm ? {
-          "Content-Type": "multipart/form-data"
-        } : {},
-        url,
-        data
-      }));
+      return this.request(
+        mergeConfig$1(config2 || {}, {
+          method,
+          headers: isForm ? {
+            "Content-Type": "multipart/form-data"
+          } : {},
+          url,
+          data
+        })
+      );
     };
   }
   Axios$1.prototype[method] = generateHTTPMethod();
-  Axios$1.prototype[method + "Form"] = generateHTTPMethod(true);
+  if (method !== "query") {
+    Axios$1.prototype[method + "Form"] = generateHTTPMethod(true);
+  }
 });
 let CancelToken$1 = class CancelToken {
   constructor(executor) {
@@ -2747,7 +4110,13 @@ const HttpStatusCode$1 = {
   InsufficientStorage: 507,
   LoopDetected: 508,
   NotExtended: 510,
-  NetworkAuthenticationRequired: 511
+  NetworkAuthenticationRequired: 511,
+  WebServerIsDown: 521,
+  ConnectionTimedOut: 522,
+  OriginIsUnreachable: 523,
+  TimeoutOccurred: 524,
+  SslHandshakeFailed: 525,
+  InvalidSslCertificate: 526
 };
 Object.entries(HttpStatusCode$1).forEach(([key, value]) => {
   HttpStatusCode$1[value] = key;
@@ -2757,7 +4126,7 @@ function createInstance(defaultConfig) {
   const instance = bind(Axios$1.prototype.request, context);
   utils$1.extend(instance, Axios$1.prototype, context, { allOwnKeys: true });
   utils$1.extend(instance, context, null, { allOwnKeys: true });
-  instance.create = function create(instanceConfig) {
+  instance.create = function create2(instanceConfig) {
     return createInstance(mergeConfig$1(defaultConfig, instanceConfig));
   };
   return instance;
@@ -2784,8 +4153,8 @@ axios.HttpStatusCode = HttpStatusCode$1;
 axios.default = axios;
 const {
   Axios: Axios2,
-  AxiosError,
-  CanceledError,
+  AxiosError: AxiosError2,
+  CanceledError: CanceledError2,
   isCancel,
   CancelToken: CancelToken2,
   VERSION,
@@ -2798,27 +4167,46 @@ const {
   HttpStatusCode,
   formToJSON,
   getAdapter,
-  mergeConfig
+  mergeConfig,
+  create
 } = axios;
+const VERTEX_LOCATION = "global";
+const SCOPES = ["https://www.googleapis.com/auth/cloud-platform"];
+const createGeminiClient = ({ serviceAccount, apiKey, allowVertex = true }, Ctor = genai.GoogleGenAI) => {
+  const parsed = allowVertex && serviceAccount ? parseServiceAccount(serviceAccount) : null;
+  if (parsed && "account" in parsed) {
+    const { projectId, clientEmail, privateKey } = parsed.account;
+    const ai = new Ctor({
+      vertexai: true,
+      project: projectId,
+      location: VERTEX_LOCATION,
+      googleAuthOptions: { credentials: { client_email: clientEmail, private_key: privateKey }, scopes: SCOPES }
+    });
+    return { ai, backend: "vertex" };
+  }
+  if (typeof apiKey === "string" && apiKey) return { ai: new Ctor({ apiKey }), backend: "gemini-api" };
+  throw new Error(
+    allowVertex ? "Configura la cuenta de servicio de Vertex AI o la llave de Gemini en Ajustes del plugin." : "El video necesita la llave de Gemini en Ajustes del plugin."
+  );
+};
 const service = ({ strapi }) => {
   return {
     // ───────────────────────────────
     // 🤖 AI Configuration
     // ───────────────────────────────
+    /**
+     * Cliente de Google y su backend (S5.1): con la cuenta de servicio de Ajustes, Vertex AI en `global`; si
+     * no, la llave (`GOOGLE_API_KEY` del entorno gana a la del store, como antes; D10). El video pide
+     * `allowVertex: false` (D7).
+     */
+    async geminiClient({ allowVertex = true } = {}) {
+      const pluginStore = strapi.store({ type: "plugin", name: "strapi-content-generator-gemini" });
+      const [serviceAccount, storedKey] = await Promise.all([pluginStore.get({ key: VERTEX_KEY }), pluginStore.get({ key: "GOOGLE_GEN_AI" })]);
+      return createGeminiClient({ serviceAccount, apiKey: process.env.GOOGLE_API_KEY || storedKey, allowVertex });
+    },
+    /** Atajo para los usos que solo necesitan el cliente (artículos). */
     async geminiConfig() {
-      const pluginStore = strapi.store({
-        type: "plugin",
-        name: "strapi-content-generator-gemini"
-      });
-      const googleGenAI = await pluginStore.get({ key: "GOOGLE_GEN_AI" });
-      const geminiApiKey = process.env.GOOGLE_API_KEY || googleGenAI;
-      if (!geminiApiKey) {
-        throw new Error(
-          "La variable de entorno GOOGLE_API_KEY o GOOGLE_GEN_AI no está configurada."
-        );
-      }
-      const ai = new genai.GoogleGenAI({ apiKey: geminiApiKey });
-      return ai;
+      return (await this.geminiClient()).ai;
     },
     async getArticulos(sanitizedQueryParams) {
       return await strapi.entityService.findMany("api::articulo.articulo", sanitizedQueryParams);
@@ -2829,29 +4217,6 @@ const service = ({ strapi }) => {
     async getUsuarios(sanitizedQueryParams) {
       return await strapi.documents("plugin::users-permissions.user").findMany(sanitizedQueryParams);
     },
-    async getImagenes() {
-      const existingFolders = await strapi.documents("plugin::upload.folder").findMany({
-        filters: {
-          name: "Generated"
-        }
-      });
-      if (existingFolders) {
-        return await strapi.documents("plugin::upload.file").findMany({
-          filters: {
-            folder: {
-              id: {
-                $eq: existingFolders[0].id
-              }
-            }
-          },
-          sort: ["createdAt:desc"]
-        });
-      }
-      return [];
-    },
-    async eliminarImagen(sanitizedQueryParams) {
-      return await strapi.documents("plugin::upload.file").delete(sanitizedQueryParams);
-    },
     // ───────────────────────────────
     // 📥 Proxy File Download (bypasses browser CORS)
     // ───────────────────────────────
@@ -2889,27 +4254,7 @@ const service = ({ strapi }) => {
     // 🏞️ Internal File Upload Helper
     // ───────────────────────────────
     async _uploadGeneratedFile(file, filename, mimeType, folderName = "Generated") {
-      const existingFolders = await strapi.documents("plugin::upload.folder").findMany({
-        filters: { name: folderName }
-      });
-      let folderId;
-      if (!existingFolders || existingFolders.length === 0) {
-        const lastFolder = await strapi.documents("plugin::upload.folder").findMany({
-          sort: { pathId: "desc" },
-          limit: 1
-        });
-        const pathId = Array.isArray(lastFolder) && lastFolder.length > 0 ? lastFolder[0].pathId + 1 : 1;
-        const createdFolder = await strapi.documents("plugin::upload.folder").create({
-          data: {
-            name: folderName,
-            path: `/${folderName.toLowerCase()}`,
-            pathId
-          }
-        });
-        folderId = createdFolder.id;
-      } else {
-        folderId = existingFolders[0].id;
-      }
+      const folderId = await ensureFolder(strapi, folderName);
       let fileSize = 0;
       if (typeof file === "string") {
         const stats = fs__namespace.statSync(file);
@@ -3144,15 +4489,7 @@ const service = ({ strapi }) => {
           output_format: "image/png"
         };
         const promptText = JSON.stringify(promptJson);
-        const generatedBase64Image = await this._callGeminiImageGeneration(
-          promptText,
-          aspectRatio || "16:9",
-          // Use provided aspectRatio or default
-          imageSize || "1K",
-          // Use provided imageSize or default
-          []
-          // No reference images for article generation
-        );
+        const generatedBase64Image = await strapi.plugin("strapi-content-generator-gemini").service("image-studio").generateForArticle(promptText, aspectRatio || "16:9", imageSize || "1K");
         const buffer = Buffer.from(generatedBase64Image, "base64");
         const uploadedFile = await this._uploadGeneratedFile(buffer, `article-${articleId}.png`, "image/png");
         const articleModel = await strapi.getModel("api::articulo.articulo");
@@ -3175,134 +4512,10 @@ const service = ({ strapi }) => {
         throw new Error("Error al generar la imagen para el artículo.");
       }
     },
-    // ───────────────────────────────
-    // 🖼️ Internal Image Generation Helper
-    // Imagen 4 cuando no hay imágenes de referencia (mejor calidad y adherencia al prompt)
-    // Gemini 2.5 Flash como fallback cuando se proporcionan imágenes de referencia
-    // ───────────────────────────────
-    async _callGeminiImageGeneration(promptText, aspectRatio, imageSizeLabel, referenceImages) {
-      const ai = await this.geminiConfig();
-      const cleanPrompt = promptText.replace(/\r\n/g, " ").replace(/\n/g, " ").replace(/\s+/g, " ").trim();
-      if (referenceImages.length === 0) {
-        const response = await ai.models.generateImages({
-          model: "imagen-4.0-generate-001",
-          prompt: cleanPrompt,
-          config: {
-            numberOfImages: 1,
-            aspectRatio,
-            outputMimeType: "image/png"
-          }
-        });
-        const imageBytes = response.generatedImages?.[0]?.image?.imageBytes;
-        if (!imageBytes) {
-          throw new Error("Imagen 4 no devolvió imagen. Verifica el prompt o el modelo.");
-        }
-        return imageBytes;
-      }
-      const imageParts = referenceImages.map((img) => ({
-        inlineData: {
-          mimeType: img.mimeType,
-          data: img.buffer.toString("base64")
-        }
-      }));
-      const result = await ai.models.generateContent({
-        model: "gemini-2.5-flash-image",
-        contents: [{ text: cleanPrompt }, ...imageParts],
-        config: {
-          responseModalities: [genai.Modality.IMAGE],
-          imageConfig: { aspectRatio, imageSize: imageSizeLabel }
-        }
-      });
-      const parts = result?.candidates?.[0]?.content?.parts;
-      if (!Array.isArray(parts)) {
-        throw new Error("Respuesta inválida del modelo (parts no encontrado)");
-      }
-      const imagePart = parts.find(
-        (p) => p?.inlineData?.data && typeof p.inlineData.data === "string" && p.inlineData.mimeType?.startsWith("image/")
-      );
-      if (!imagePart) {
-        throw new Error("No se encontró ninguna imagen en la respuesta del modelo");
-      }
-      return imagePart.inlineData.data;
-    },
-    // ───────────────────────────────
-    // 🖼️ Generate Image (Standalone)
-    // ───────────────────────────────
-    async generateImage(ctx) {
-      const { prompt, aspectRatio, imageSize } = ctx.request.body;
-      if (!prompt) {
-        throw new Error("Se requiere 'prompt' para generar el contenido visual.");
-      }
-      const promptJson = {
-        label: `standalone-image-${Date.now()}`,
-        task: "generate_image",
-        canvas: {
-          resolution: imageSize || "1K",
-          aspect_ratio: aspectRatio || "16:9"
-        },
-        style: {
-          type: "architectural software engineering visualization",
-          aesthetic: "high-end technical 3D render / octane style",
-          background: "view of a bright white minimalist architectural gallery, sun-drenched space, white polished floors and tall glass windows",
-          lighting: "intense natural daylight, soft global illumination, clean diffused light with subtle volumetric rays from windows"
-        },
-        concept_brief: prompt,
-        subject: [
-          "apply the concept brief above as the main subject — rendered as a sophisticated 3D holographic or architectural structure floating inside the gallery",
-          "materials: frosted glass, white matte ceramic, polished metal accents",
-          "brand accent colors red #E4002B and teal #00C7B1 on glowing energy filaments, highlights, and data connections",
-          "the structure casts a sharp, clean reflection on the white polished gallery floor",
-          "STRICTLY NO people, NO humans, NO hands, NO chairs",
-          "STRICTLY NO text, NO labels, NO words, NO letters, NO numbers, NO logos",
-          "high-end 3D render, architectural photography style, 4k quality"
-        ],
-        camera: {
-          perspective: "three-quarter wide shot, slightly elevated, showing both the subject and the gallery environment",
-          depth_of_field: "main subject in sharp focus, gallery background beautifully blurred"
-        },
-        render: {
-          engine: "Octane or Cinema 4D",
-          effects: "bloom on glowing elements, ray-traced reflections on the white polished floor, subsurface scattering on frosted glass, volumetric light rays from gallery windows",
-          quality: "masterpiece, hyper-detailed"
-        },
-        output_format: "image/png"
-      };
-      const basePrompt = JSON.stringify(promptJson);
-      const files = ctx.request.files ?? {};
-      const referenceImages = Object.entries(files).filter(([key]) => key.startsWith("referenceImages")).map(([, file]) => file);
-      if (referenceImages.length > 5) {
-        throw new Error("Máximo 5 imágenes de referencia permitidas.");
-      }
-      const imageBuffers = referenceImages.map((file) => {
-        const typedFile = file;
-        return {
-          buffer: typedFile.buffer ?? fs__namespace.readFileSync(typedFile.filepath),
-          mimeType: typedFile.mimetype
-        };
-      });
-      try {
-        const generatedBase64Image = await this._callGeminiImageGeneration(
-          basePrompt,
-          aspectRatio || "16:9",
-          imageSize || "1K",
-          imageBuffers
-        );
-        const buffer = Buffer.from(generatedBase64Image, "base64");
-        const filename = `generated-image-${Date.now()}.png`;
-        const uploadedFile = await this._uploadGeneratedFile(buffer, filename, "image/png");
-        return {
-          message: `Imagen generada y subida correctamente.`,
-          file: uploadedFile
-        };
-      } catch (err) {
-        console.error("🚀 ~ generateImage ~ err:", err);
-        throw new Error(`Error al generar la imagen.`);
-      }
-    },
     // 🎞️ Internal Veo Video Generation / Extension Helper
     async _callVeoVideoGeneration(promptText, aspectRatio, durationSeconds, sceneRefs, previousVideo) {
-      const ai = await this.geminiConfig();
-      const cleanPrompt = promptText.replace(/\s+/g, " ").trim();
+      const { ai } = await this.geminiClient({ allowVertex: false });
+      const cleanPrompt2 = promptText.replace(/\s+/g, " ").trim();
       const referenceImages = sceneRefs.map((img) => ({
         image: {
           imageBytes: img.buffer.toString("base64"),
@@ -3319,7 +4532,7 @@ const service = ({ strapi }) => {
       };
       const operationParams = {
         model: "veo-3.1-generate-preview",
-        prompt: cleanPrompt,
+        prompt: cleanPrompt2,
         config: config2
       };
       if (previousVideo) {
@@ -3371,7 +4584,7 @@ const service = ({ strapi }) => {
         throw new Error("No se generó ningún video.");
       }
       const finalVideoPath = `/tmp/video-${Date.now()}.mp4`;
-      const ai = await this.geminiConfig();
+      const { ai } = await this.geminiClient({ allowVertex: false });
       await ai.files.download({ file: previousVideo, downloadPath: finalVideoPath });
       const uploadedFile = await this._uploadGeneratedFile(
         finalVideoPath,
@@ -3551,13 +4764,15 @@ ${hashtags}`,
   };
 };
 const services = {
-  service
+  service,
+  "image-studio": imageStudio$1,
+  templates: templates$1
 };
 const index = {
   register,
   bootstrap,
   destroy,
-  config: config$1,
+  config: config$2,
   controllers,
   routes,
   services,