@zanixongroup/uploader/dist/index.mjs

A simple any file hosting uploader for node.js

var __defProp = Object.defineProperty;
var __export = (target, all) => {
  for (var name in all)
    __defProp(target, name, { get: all[name], enumerable: true });
};

// src/services/catbox.ts
var catbox_exports = {};
__export(catbox_exports, {
  Catbox: () => Catbox,
  default: () => catbox_default
});
import axios from "axios";
import FormData from "form-data";

// src/utils/helper.ts
function FileSize(data) {
  if (!(data instanceof Uint8Array)) throw new Error("Invalid buffer data!");
  return data.length;
}
function MaxFileSize(data) {
  if (!Number.isInteger(data)) throw new Error("Invalid number data!");
  return data * 1024576;
}
async function MimeType(data) {
  if (!(data instanceof Uint8Array)) throw new Error("Invalid buffer data!");
  const { fileTypeFromBuffer } = await import("file-type");
  return fileTypeFromBuffer(data);
}

// src/services/catbox.ts
async function Catbox(data) {
  if (!Buffer.isBuffer(data)) throw new Error("Invalid buffer input!");
  if (FileSize(data) >= MaxFileSize(200)) throw new Error("Max file upload for catbox is only 200MB!");
  const type = await MimeType(data);
  const form = new FormData();
  form.append("fileToUpload", Buffer.from(data), {
    filename: "zxn-" + Date.now() + "." + type?.ext,
    contentType: type?.mime || ""
  });
  form.append("userhash", "");
  form.append("reqtype", "fileupload");
  const raw = await axios.post("https://catbox.moe/user/api.php", form, {
    headers: {
      ...form.getHeaders(),
      "origin": "https://litterbox.catbox.moe",
      "user-agent": "Postify/1.0.0"
    }
  });
  return raw?.data || null;
}
var catbox_default = Catbox;

// src/services/fasturl.ts
var fasturl_exports = {};
__export(fasturl_exports, {
  FastUrl: () => FastUrl,
  default: () => fasturl_default
});
import axios2 from "axios";
import FormData2 from "form-data";
async function FastUrl(data) {
  if (!Buffer.isBuffer(data)) throw new Error("Invalid buffer input!");
  if (FileSize(data) >= MaxFileSize(100)) throw new Error("Max file upload for catbox is only 100MB!");
  const mime = await MimeType(data);
  const form = new FormData2();
  form.append("file", Buffer.from(data), {
    filename: mime ? "zxn-" + Date.now() + "." + mime?.ext : "",
    contentType: mime?.mime || ""
  });
  const raw = await axios2.post("https://api.fasturl.link/downup/uploader-v2", form, {
    headers: {
      ...form.getHeaders()
    }
  });
  return raw?.data?.result || null;
}
var fasturl_default = FastUrl;

// src/services/litterbox.ts
var litterbox_exports = {};
__export(litterbox_exports, {
  Litterbox: () => Litterbox,
  default: () => litterbox_default
});
import axios3 from "axios";
import FormData3 from "form-data";
async function Litterbox(data) {
  if (!Buffer.isBuffer(data)) throw new Error("Invalid buffer input!");
  if (FileSize(data) >= MaxFileSize(1e3)) throw new Error("Max file upload for Litterbox is only 1GB!");
  const type = await MimeType(data);
  const form = new FormData3();
  form.append("fileToUpload", Buffer.from(data), {
    filename: type ? "zxn-" + Date.now() + "." + type?.ext : "",
    contentType: type?.mime || ""
  });
  form.append("userhash", "");
  form.append("reqtype", "fileupload");
  const raw = await axios3.post("https://litterbox.catbox.moe/resources/internals/api.php", form, {
    headers: {
      ...form.getHeaders(),
      "origin": "https://litterbox.Litterbox.moe",
      "user-agent": "Postify/1.0.0"
    }
  });
  return raw?.data || null;
}
var litterbox_default = Litterbox;

// src/services/pomf.ts
var pomf_exports = {};
__export(pomf_exports, {
  Pomf: () => Pomf,
  default: () => pomf_default
});
import axios4 from "axios";
import FormData4 from "form-data";
async function Pomf(data) {
  if (!Buffer.isBuffer(data)) throw new Error("Invalid buffer input!");
  if (FileSize(data) >= MaxFileSize(1e3)) throw new Error("Max file upload for catbox is only 1GB!");
  const mime = await MimeType(data);
  const form = new FormData4();
  form.append("files[]", Buffer.from(data), {
    filename: mime ? "zxn-" + Date.now() + "." + mime?.ext : "",
    contentType: mime?.mime || ""
  });
  const raw = await axios4.post("https://pomf.lain.la/upload.php", form, {
    headers: {
      ...form.getHeaders(),
      "origin": "https://pomf.lain.la",
      "user-agent": "Postify/1.0.0"
    }
  });
  return raw?.data?.files[0]?.url || null;
}
var pomf_default = Pomf;

// src/services/quax.ts
var quax_exports = {};
__export(quax_exports, {
  Quax: () => Quax,
  default: () => quax_default
});
import axios5 from "axios";
import FormData5 from "form-data";
async function Quax(data) {
  if (!Buffer.isBuffer(data)) throw new Error("Invalid buffer input!");
  if (FileSize(data) >= MaxFileSize(256)) throw new Error("Max file upload for catbox is only 256MB!");
  const mime = await MimeType(data);
  const form = new FormData5();
  form.append("files[]", Buffer.from(data), {
    filename: mime ? "zxn-" + Date.now() + "." + mime?.ext : "",
    contentType: mime?.mime || ""
  });
  const raw = await axios5.post("https://qu.ax/upload.php", form, {
    headers: {
      ...form.getHeaders(),
      "origin": "https://qu.ax",
      "user-agent": "Postify/1.0.0"
    }
  });
  return raw?.data?.files[0]?.url || null;
}
var quax_default = Quax;

// src/services/ryzumi.ts
var ryzumi_exports = {};
__export(ryzumi_exports, {
  Ryzumi: () => Ryzumi,
  default: () => ryzumi_default
});
import axios6 from "axios";
import FormData6 from "form-data";
async function Ryzumi(data) {
  if (!Buffer.isBuffer(data)) throw new Error("Invalid buffer input!");
  if (FileSize(data) >= MaxFileSize(100)) throw new Error("Max file upload for catbox is only 100MB!");
  const mime = await MimeType(data);
  const form = new FormData6();
  form.append("file", Buffer.from(data), {
    filename: mime ? "zxn-" + Date.now() + "." + mime?.ext : "",
    contentType: mime?.mime || ""
  });
  const raw = await axios6.post("https://api.ryzumi.vip/api/uploader/ryzencdn", form, {
    headers: {
      ...form.getHeaders()
    }
  });
  return raw?.data?.url || null;
}
var ryzumi_default = Ryzumi;

// src/services/uguu.ts
var uguu_exports = {};
__export(uguu_exports, {
  Uguu: () => Uguu,
  default: () => uguu_default
});
import axios7 from "axios";
import FormData7 from "form-data";
async function Uguu(data) {
  if (!Buffer.isBuffer(data)) throw new Error("Invalid buffer input!");
  if (FileSize(data) >= MaxFileSize(100)) throw new Error("Max file upload for catbox is only 100MB!");
  const type = await MimeType(data);
  const form = new FormData7();
  form.append("files[]", Buffer.from(data), {
    filename: type ? "uguu-" + Date.now() + "." + type.ext : "",
    contentType: type?.mime || ""
  });
  const raw = await axios7.post("https://uguu.se/upload", form, {
    headers: {
      ...form.getHeaders(),
      "origin": "https://uguu.se",
      "user-agent": "UguuUploader/1.0.0"
    }
  });
  return raw?.data.files[0].url || null;
}
var uguu_default = Uguu;

// src/services/videy.ts
var videy_exports = {};
__export(videy_exports, {
  Videy: () => Videy,
  default: () => videy_default
});
import axios8 from "axios";
import FormData8 from "form-data";
async function Videy(data) {
  if (!Buffer.isBuffer(data)) throw new Error("Invalid buffer input!");
  if (FileSize(data) >= MaxFileSize(1e3)) throw Error("Max size upload for VideyCDN is only 1GB!");
  const mime = await MimeType(data);
  if (!mime || !["mp4", "mov"].includes(mime?.ext)) throw Error("Wrong filetype, please select an .mp4 or .mov");
  const form = new FormData8();
  form.append("file", Buffer.from(data), {
    filename: mime ? "zxn-" + Date.now() + "." + mime.ext : "",
    contentType: mime?.mime || ""
  });
  const raw = await axios8.post("https://videy.co/api/upload", form, {
    headers: {
      ...form.getHeaders()
    }
  });
  return "https://cdn.videy.co/" + raw?.data?.id + "." + mime?.ext || null;
}
var videy_default = Videy;

// src/services/cloudku.ts
var cloudku_exports = {};
__export(cloudku_exports, {
  Cloudku: () => Cloudku,
  default: () => cloudku_default
});
import axios9 from "axios";
import FormData9 from "form-data";
async function Cloudku(data) {
  if (!Buffer.isBuffer(data)) throw new Error("Invalid buffer input!");
  if (FileSize(data) >= MaxFileSize(1e4)) throw new Error("Max file upload for catbox is only 10GB!");
  const mime = await MimeType(data);
  const form = new FormData9();
  form.append("file", Buffer.from(data), {
    filename: mime ? "zxn-" + Date.now() + "." + mime?.ext : "",
    contentType: mime?.mime || ""
  });
  const raw = await axios9.post("https://cloudkuimages.com/upload.php", form, {
    headers: {
      ...form.getHeaders(),
      "origin": "https://cloudkuimages.com",
      "user-agent": "Postify/1.0.0"
    }
  });
  return raw?.data?.result?.url || null;
}
var cloudku_default = Cloudku;

// src/index.ts
var index_default = {
  Catbox: catbox_exports,
  FastUrl: fasturl_exports,
  Litterbox: litterbox_exports,
  Pomf: pomf_exports,
  Quax: quax_exports,
  Ryzumi: ryzumi_exports,
  Uguu: uguu_exports,
  Videy: videy_exports,
  Cloudku: cloudku_exports
};
export {
  Catbox,
  Cloudku,
  FastUrl,
  Litterbox,
  Pomf,
  Quax,
  Ryzumi,
  Uguu,
  Videy,
  index_default as default
};