@zanixongroup/uploader/dist/index.cjs

A simple any file hosting uploader for node.js

"use strict";
var __create = Object.create;
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __getProtoOf = Object.getPrototypeOf;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __export = (target, all) => {
  for (var name in all)
    __defProp(target, name, { get: all[name], enumerable: true });
};
var __copyProps = (to, from, except, desc) => {
  if (from && typeof from === "object" || typeof from === "function") {
    for (let key of __getOwnPropNames(from))
      if (!__hasOwnProp.call(to, key) && key !== except)
        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
  }
  return to;
};
var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
  // If the importer is in node compatibility mode or this is not an ESM
  // file that has been converted to a CommonJS file using a Babel-
  // compatible transform (i.e. "__esModule" has not been set), then set
  // "default" to the CommonJS "module.exports" for node compatibility.
  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
  mod
));
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);

// src/index.ts
var index_exports = {};
__export(index_exports, {
  Catbox: () => Catbox,
  Cloudku: () => Cloudku,
  Litterbox: () => Litterbox,
  Picsur: () => Picsur,
  Pomf: () => Pomf,
  Quax: () => Quax,
  Ryzumi: () => Ryzumi,
  Uguu: () => Uguu,
  Videy: () => Videy,
  default: () => index_default
});
module.exports = __toCommonJS(index_exports);

// src/services/catbox.ts
var catbox_exports = {};
__export(catbox_exports, {
  Catbox: () => Catbox,
  default: () => catbox_default
});
var import_axios = __toESM(require("axios"));
var import_form_data = __toESM(require("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 import_form_data.default();
  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 import_axios.default.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/litterbox.ts
var litterbox_exports = {};
__export(litterbox_exports, {
  Litterbox: () => Litterbox,
  default: () => litterbox_default
});
var import_axios2 = __toESM(require("axios"));
var import_form_data2 = __toESM(require("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 import_form_data2.default();
  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 import_axios2.default.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
});
var import_axios3 = __toESM(require("axios"));
var import_form_data3 = __toESM(require("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 import_form_data3.default();
  form.append("files[]", Buffer.from(data), {
    filename: mime ? "zxn-" + Date.now() + "." + mime?.ext : "",
    contentType: mime?.mime || ""
  });
  const raw = await import_axios3.default.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
});
var import_axios4 = __toESM(require("axios"));
var import_form_data4 = __toESM(require("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 import_form_data4.default();
  form.append("files[]", Buffer.from(data), {
    filename: mime ? "zxn-" + Date.now() + "." + mime?.ext : "",
    contentType: mime?.mime || ""
  });
  const raw = await import_axios4.default.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
});
var import_axios5 = __toESM(require("axios"));
var import_form_data5 = __toESM(require("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 import_form_data5.default();
  form.append("file", Buffer.from(data), {
    filename: mime ? "zxn-" + Date.now() + "." + mime?.ext : "",
    contentType: mime?.mime || ""
  });
  const raw = await import_axios5.default.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
});
var import_axios6 = __toESM(require("axios"));
var import_form_data6 = __toESM(require("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 import_form_data6.default();
  form.append("files[]", Buffer.from(data), {
    filename: type ? "uguu-" + Date.now() + "." + type.ext : "",
    contentType: type?.mime || ""
  });
  const raw = await import_axios6.default.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
});
var import_axios7 = __toESM(require("axios"));
var import_form_data7 = __toESM(require("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 import_form_data7.default();
  form.append("file", Buffer.from(data), {
    filename: mime ? "zxn-" + Date.now() + "." + mime.ext : "",
    contentType: mime?.mime || ""
  });
  const raw = await import_axios7.default.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
});
var import_axios8 = __toESM(require("axios"));
var import_form_data8 = __toESM(require("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 import_form_data8.default();
  form.append("file", Buffer.from(data), {
    filename: mime ? "zxn-" + Date.now() + "." + mime?.ext : "",
    contentType: mime?.mime || ""
  });
  const raw = await import_axios8.default.post("https://cloudkuimages.guru/upload.php", form, {
    headers: {
      ...form.getHeaders(),
      "origin": "https://cloudkuimages.guru",
      "user-agent": "Postify/1.0.0"
    }
  });
  return raw?.data?.data?.url || null;
}
var cloudku_default = Cloudku;

// src/services/picsur.ts
var picsur_exports = {};
__export(picsur_exports, {
  Picsur: () => Picsur,
  default: () => picsur_default
});
var import_axios9 = __toESM(require("axios"));
var import_form_data9 = __toESM(require("form-data"));
async function Picsur(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 import_form_data9.default();
  form.append("image", Buffer.from(data), {
    filename: mime ? "zxn-" + Date.now() + "." + mime?.ext : "",
    contentType: mime?.mime || ""
  });
  const raw = await import_axios9.default.post("https://picsur.org/api/image/upload", form, {
    headers: {
      ...form.getHeaders(),
      "origin": "https://picsur.org",
      "user-agent": "Postify/1.0.0"
    }
  });
  if (!raw?.data?.success) throw new Error(raw.data);
  return "https://picsur.org/i/" + raw?.data?.data?.id + "." + mime?.ext || null;
}
var picsur_default = Picsur;

// src/index.ts
var index_default = {
  Catbox: catbox_exports,
  Litterbox: litterbox_exports,
  Pomf: pomf_exports,
  Quax: quax_exports,
  Ryzumi: ryzumi_exports,
  Uguu: uguu_exports,
  Videy: videy_exports,
  Cloudku: cloudku_exports,
  Picsur: picsur_exports
};
// Annotate the CommonJS export names for ESM import in node:
0 && (module.exports = {
  Catbox,
  Cloudku,
  Litterbox,
  Picsur,
  Pomf,
  Quax,
  Ryzumi,
  Uguu,
  Videy
});