@useupup/core 3.3.0

package/dist/chunk-FMURBCZ7.js

@@ -0,0 +1,120 @@
+// src/steps/animated-image.ts
+function ascii(bytes, start, length) {
+  let out = "";
+  for (let i = start; i < start + length; i += 1) {
+    const byte = bytes[i];
+    if (byte === void 0) return out;
+    out += String.fromCharCode(byte);
+  }
+  return out;
+}
+function byteAt(bytes, index) {
+  return bytes[index] ?? 0;
+}
+function skipSubBlocks(bytes, start) {
+  let offset = start;
+  while (offset < bytes.length) {
+    const size = byteAt(bytes, offset);
+    offset += 1;
+    if (size === 0) return offset;
+    offset += size;
+  }
+  return bytes.length;
+}
+function isAnimatedGif(bytes) {
+  if (bytes.length < 13) return false;
+  if (ascii(bytes, 0, 3) !== "GIF") return false;
+  const screenPacked = byteAt(bytes, 10);
+  let offset = 13;
+  if ((screenPacked & 128) !== 0) {
+    offset += 3 * (1 << (screenPacked & 7) + 1);
+  }
+  let frames = 0;
+  while (offset < bytes.length) {
+    const block = byteAt(bytes, offset);
+    if (block === 59) return false;
+    if (block === 33) {
+      const label = byteAt(bytes, offset + 1);
+      offset += 2;
+      if (label === 255) {
+        const identifier = ascii(
+          bytes,
+          offset + 1,
+          byteAt(bytes, offset)
+        );
+        if (identifier === "NETSCAPE2.0" || identifier === "ANIMEXTS1.0") {
+          return true;
+        }
+      }
+      offset = skipSubBlocks(bytes, offset);
+      continue;
+    }
+    if (block === 44) {
+      frames += 1;
+      if (frames > 1) return true;
+      const imagePacked = byteAt(bytes, offset + 9);
+      offset += 10;
+      if ((imagePacked & 128) !== 0) {
+        offset += 3 * (1 << (imagePacked & 7) + 1);
+      }
+      offset += 1;
+      offset = skipSubBlocks(bytes, offset);
+      continue;
+    }
+    return false;
+  }
+  return false;
+}
+var PNG_SIGNATURE = [137, 80, 78, 71, 13, 10, 26, 10];
+function isAnimatedPng(bytes) {
+  if (bytes.length < PNG_SIGNATURE.length) return false;
+  for (const [index, expected] of PNG_SIGNATURE.entries()) {
+    if (byteAt(bytes, index) !== expected) return false;
+  }
+  let offset = PNG_SIGNATURE.length;
+  while (offset + 8 <= bytes.length) {
+    const length = byteAt(bytes, offset) * 16777216 + byteAt(bytes, offset + 1) * 65536 + byteAt(bytes, offset + 2) * 256 + byteAt(bytes, offset + 3);
+    const type = ascii(bytes, offset + 4, 4);
+    if (type === "acTL") return true;
+    if (type === "IDAT") return false;
+    offset += 12 + length;
+  }
+  return false;
+}
+function isAnimatedWebp(bytes) {
+  if (bytes.length < 16) return false;
+  if (ascii(bytes, 0, 4) !== "RIFF" || ascii(bytes, 8, 4) !== "WEBP") {
+    return false;
+  }
+  let offset = 12;
+  while (offset + 8 <= bytes.length) {
+    const fourCC = ascii(bytes, offset, 4);
+    const size = byteAt(bytes, offset + 4) + byteAt(bytes, offset + 5) * 256 + byteAt(bytes, offset + 6) * 65536 + byteAt(bytes, offset + 7) * 16777216;
+    if (fourCC === "ANIM" || fourCC === "ANMF") return true;
+    if (fourCC === "VP8X" && (byteAt(bytes, offset + 8) & 2) !== 0) {
+      return true;
+    }
+    offset += 8 + size + size % 2;
+  }
+  return false;
+}
+var SNIFFERS = {
+  "image/gif": isAnimatedGif,
+  "image/png": isAnimatedPng,
+  "image/apng": isAnimatedPng,
+  "image/webp": isAnimatedWebp
+};
+function baseMimeType(type) {
+  return type.split(";")[0]?.trim().toLowerCase() ?? "";
+}
+async function isAnimatedImage(file) {
+  const sniff = SNIFFERS[baseMimeType(file.type)];
+  if (!sniff) return false;
+  try {
+    return sniff(new Uint8Array(await file.arrayBuffer()));
+  } catch {
+    return false;
+  }
+}
+
+export { isAnimatedImage };

package/dist/chunk-FYQQRULL.js

@@ -0,0 +1,37 @@
+// src/pipeline/engine.ts
+var PipelineEngine = class {
+  constructor(steps) {
+    this.steps = steps;
+  }
+  get stepCount() {
+    return this.steps.length;
+  }
+  async process(file, context) {
+    context.emit("pipeline-start", {
+      fileId: file.id,
+      steps: this.steps.map((s) => s.name)
+    });
+    let current = file;
+    for (const step of this.steps) {
+      if (step.shouldProcess && !step.shouldProcess(current)) {
+        continue;
+      }
+      current = await step.process(current, context);
+      context.emit("pipeline-step", {
+        fileId: file.id,
+        step: step.name
+      });
+    }
+    context.emit("pipeline-complete", { fileId: file.id });
+    return current;
+  }
+  async processAll(files, context) {
+    const results = [];
+    for (const file of files) {
+      results.push(await this.process(file, context));
+    }
+    return results;
+  }
+};
+
+export { PipelineEngine };

package/dist/chunk-GE4LIVXP.js

@@ -0,0 +1,133 @@
+// src/errors.ts
+var UpupErrorCode = /* @__PURE__ */ ((UpupErrorCode2) => {
+  UpupErrorCode2["AUTH_EXPIRED"] = "AUTH_EXPIRED";
+  UpupErrorCode2["AUTH_DENIED"] = "AUTH_DENIED";
+  UpupErrorCode2["AUTH_PROVIDER_ERROR"] = "AUTH_PROVIDER_ERROR";
+  UpupErrorCode2["FILE_TOO_LARGE"] = "FILE_TOO_LARGE";
+  UpupErrorCode2["FILE_TOO_SMALL"] = "FILE_TOO_SMALL";
+  UpupErrorCode2["TYPE_MISMATCH"] = "TYPE_MISMATCH";
+  UpupErrorCode2["LIMIT_EXCEEDED"] = "LIMIT_EXCEEDED";
+  UpupErrorCode2["TOTAL_SIZE_EXCEEDED"] = "TOTAL_SIZE_EXCEEDED";
+  UpupErrorCode2["DUPLICATE"] = "DUPLICATE";
+  UpupErrorCode2["MIN_FILES_NOT_MET"] = "MIN_FILES_NOT_MET";
+  UpupErrorCode2["UPLOAD_FAILED"] = "UPLOAD_FAILED";
+  UpupErrorCode2["UPLOAD_ABORTED"] = "UPLOAD_ABORTED";
+  UpupErrorCode2["PRESIGN_FAILED"] = "PRESIGN_FAILED";
+  UpupErrorCode2["CORS_ERROR"] = "CORS_ERROR";
+  UpupErrorCode2["PIPELINE_STEP_FAILED"] = "PIPELINE_STEP_FAILED";
+  UpupErrorCode2["HEIC_CONVERSION_FAILED"] = "HEIC_CONVERSION_FAILED";
+  UpupErrorCode2["NETWORK_ERROR"] = "NETWORK_ERROR";
+  UpupErrorCode2["TIMEOUT"] = "TIMEOUT";
+  UpupErrorCode2["STORAGE_ERROR"] = "STORAGE_ERROR";
+  UpupErrorCode2["QUOTA_EXCEEDED"] = "QUOTA_EXCEEDED";
+  UpupErrorCode2["NO_UPLOAD_TARGET"] = "NO_UPLOAD_TARGET";
+  UpupErrorCode2["BAD_REQUEST"] = "BAD_REQUEST";
+  UpupErrorCode2["AUTH_REQUIRED"] = "AUTH_REQUIRED";
+  UpupErrorCode2["NOT_FOUND"] = "NOT_FOUND";
+  return UpupErrorCode2;
+})(UpupErrorCode || {});
+var UpupError = class extends Error {
+  constructor(message, code, retryable = false) {
+    super(message);
+    this.name = "UpupError";
+    this.code = code;
+    this.retryable = retryable;
+  }
+};
+var UpupAuthError = class extends UpupError {
+  constructor(message, provider) {
+    super(message, "AUTH_PROVIDER_ERROR" /* AUTH_PROVIDER_ERROR */, false);
+    this.name = "UpupAuthError";
+    this.provider = provider;
+  }
+};
+var UpupNetworkError = class extends UpupError {
+  constructor(message, status) {
+    super(message, "NETWORK_ERROR" /* NETWORK_ERROR */, true);
+    this.name = "UpupNetworkError";
+    if (status !== void 0) this.status = status;
+  }
+};
+var UpupValidationError = class extends UpupError {
+  constructor(message, reason, file) {
+    super(message, reason, false);
+    this.name = "UpupValidationError";
+    this.reason = reason;
+    this.file = file;
+  }
+};
+var UpupQuotaError = class extends UpupError {
+  constructor(message, limit, used) {
+    super(message, "QUOTA_EXCEEDED" /* QUOTA_EXCEEDED */, false);
+    this.name = "UpupQuotaError";
+    this.limit = limit;
+    this.used = used;
+  }
+};
+var UpupStorageError = class extends UpupError {
+  constructor(message, provider, operation) {
+    super(message, "STORAGE_ERROR" /* STORAGE_ERROR */, false);
+    this.name = "UpupStorageError";
+    this.provider = provider;
+    this.operation = operation;
+  }
+};
+var UpupConfigError = class extends UpupError {
+  constructor(message, code = "NO_UPLOAD_TARGET" /* NO_UPLOAD_TARGET */) {
+    super(message, code, false);
+    this.name = "UpupConfigError";
+  }
+};
+var MAX_ERROR_BODY_SNIPPET = 200;
+function parseErrorBody(body) {
+  if (!body) return { message: "" };
+  try {
+    const parsed = JSON.parse(body);
+    if (parsed && typeof parsed === "object") {
+      const {
+        code,
+        error,
+        message: msg
+      } = parsed;
+      const message = typeof error === "string" ? error : msg;
+      if (typeof message === "string" || typeof code === "string") {
+        return {
+          message: message ?? "",
+          ...code !== void 0 ? { code } : {}
+        };
+      }
+    }
+  } catch {
+  }
+  const xmlCode = /<Code>([^<]*)<\/Code>/.exec(body)?.[1];
+  const xmlMessage = /<Message>([^<]*)<\/Message>/.exec(body)?.[1];
+  if (xmlCode || xmlMessage) {
+    return {
+      message: xmlMessage ?? "",
+      ...xmlCode !== void 0 ? { code: xmlCode } : {}
+    };
+  }
+  return { message: body.slice(0, MAX_ERROR_BODY_SNIPPET) };
+}
+function uploadErrorFromResponse(args) {
+  const { status, statusText, body, kind, operation, provider } = args;
+  const parsed = parseErrorBody(body);
+  const message = parsed.message || `${status} ${statusText}`.trim();
+  let err;
+  if (kind === "auth") {
+    err = new UpupAuthError(message, provider ?? "server");
+  } else if (kind === "storage") {
+    err = new UpupStorageError(
+      message,
+      provider ?? "server",
+      operation ?? "upload"
+    );
+  } else {
+    err = new UpupNetworkError(message, status);
+  }
+  if (parsed.code) err.code = parsed.code;
+  err.status = status;
+  return err;
+}
+
+export { UpupAuthError, UpupConfigError, UpupError, UpupErrorCode, UpupNetworkError, UpupQuotaError, UpupStorageError, UpupValidationError, parseErrorBody, uploadErrorFromResponse };

package/dist/chunk-HFR5HZJZ.js

@@ -0,0 +1,56 @@
+// src/runtime/browser.ts
+var BrowserRuntime = {
+  async computeHash(data) {
+    const hashBuffer = await crypto.subtle.digest("SHA-256", data);
+    return Array.from(new Uint8Array(hashBuffer)).map((b) => b.toString(16).padStart(2, "0")).join("");
+  },
+  createImageBitmap: typeof createImageBitmap !== "undefined" ? (blob) => createImageBitmap(blob) : void 0,
+  createWorker: typeof Worker !== "undefined" ? () => {
+    try {
+      return new Worker(
+        new URL("./pipeline-worker.js", import.meta.url),
+        {
+          type: "module"
+        }
+      );
+    } catch {
+      return null;
+    }
+  } : void 0,
+  async upload(url, body, options) {
+    return new Promise((resolve, reject) => {
+      const xhr = new XMLHttpRequest();
+      xhr.upload.addEventListener("progress", (e) => {
+        if (e.lengthComputable) options.onProgress(e.loaded, e.total);
+      });
+      xhr.addEventListener("load", () => {
+        const headers = {};
+        xhr.getAllResponseHeaders().split("\r\n").forEach((line) => {
+          const [key, ...vals] = line.split(": ");
+          if (key) headers[key.toLowerCase()] = vals.join(": ");
+        });
+        resolve({ status: xhr.status, headers, body: xhr.responseText });
+      });
+      xhr.addEventListener("error", () => {
+        reject(new Error("Network error"));
+      });
+      options.signal.addEventListener("abort", () => {
+        xhr.abort();
+      });
+      xhr.open(options.method, url);
+      for (const [k, v] of Object.entries(options.headers)) {
+        xhr.setRequestHeader(k, v);
+      }
+      xhr.send(body);
+    });
+  },
+  async readAsArrayBuffer(file) {
+    return file.arrayBuffer();
+  },
+  createObjectURL: typeof URL !== "undefined" && typeof URL.createObjectURL === "function" ? (blob) => URL.createObjectURL(blob) : void 0,
+  revokeObjectURL: typeof URL !== "undefined" && typeof URL.revokeObjectURL === "function" ? (url) => {
+    URL.revokeObjectURL(url);
+  } : void 0
+};
+
+export { BrowserRuntime };

package/dist/chunk-I7ULPCA2.js

@@ -0,0 +1,72 @@
+import { createCanvas, canvasToBlob } from './chunk-6S5DQDQH.js';
+import { UpupError } from './chunk-GE4LIVXP.js';
+
+// src/steps/heic-decode.ts
+var libheifPromise = null;
+function loadLibheif() {
+  if (!libheifPromise) {
+    libheifPromise = (async () => {
+      let mod;
+      try {
+        mod = await import('libheif-js/libheif-wasm/libheif-bundle.mjs');
+      } catch {
+        libheifPromise = null;
+        throw new UpupError(
+          'HEIC support requires the optional dependency "libheif-js". Install it: npm i libheif-js',
+          "HEIC_CONVERSION_FAILED" /* HEIC_CONVERSION_FAILED */
+        );
+      }
+      const factory = mod.default ?? mod;
+      return factory();
+    })();
+  }
+  return libheifPromise;
+}
+function canvasBackendAvailable() {
+  return typeof OffscreenCanvas !== "undefined" || typeof document !== "undefined" && "createElement" in document;
+}
+async function heicToJpegBlob(input, options = {}) {
+  if (!canvasBackendAvailable()) return null;
+  const quality = typeof options.quality === "number" ? options.quality : 0.92;
+  const libheif = await loadLibheif();
+  const buffer = await input.arrayBuffer();
+  const decoder = new libheif.HeifDecoder();
+  let images = [];
+  try {
+    images = decoder.decode(new Uint8Array(buffer));
+    const image = images[0];
+    if (!image)
+      throw new UpupError(
+        "HEIC: no image found in file",
+        "HEIC_CONVERSION_FAILED" /* HEIC_CONVERSION_FAILED */
+      );
+    const width = image.get_width();
+    const height = image.get_height();
+    const canvas = createCanvas(width, height);
+    const ctx = canvas?.getContext("2d");
+    if (!canvas || !ctx) return null;
+    const imageData = ctx.createImageData(width, height);
+    await new Promise((resolve, reject) => {
+      image.display(imageData, (result) => {
+        if (result) resolve();
+        else reject(new Error("HEIC: display failed"));
+      });
+    });
+    ctx.putImageData(imageData, 0, 0);
+    return await canvasToBlob(canvas, "image/jpeg", quality);
+  } finally {
+    for (const img of images) {
+      try {
+        img.free();
+      } catch {
+      }
+    }
+    try {
+      libheif.heif_context_free(decoder.decoder);
+    } catch {
+    }
+    decoder.decoder = null;
+  }
+}
+
+export { heicToJpegBlob };