@ignix-social/editor 0.1.0

package/vendor/hyperframes/dist/chunk-LHSR3M4M.js

@@ -0,0 +1,498 @@
+import { createRequire as __hf_createRequire } from "node:module";
+import { fileURLToPath as __hf_fileURLToPath } from "node:url";
+import { dirname as __hf_dirname } from "node:path";
+var require = __hf_createRequire(import.meta.url);
+var __filename = __hf_fileURLToPath(import.meta.url);
+var __dirname = __hf_dirname(__filename);
+import {
+  ensureModel,
+  selectProviders
+} from "./chunk-2EAXUCCE.js";
+import {
+  findFFmpeg,
+  findFFprobe,
+  getFFmpegInstallHint
+} from "./chunk-TVCRUG2S.js";
+import {
+  DEFAULT_VP9_CPU_USED,
+  renderProvenanceArgs
+} from "./chunk-K2FTXJYH.js";
+import {
+  loadOptionalPackage
+} from "./chunk-XT5P4QMO.js";
+
+// src/background-removal/pipeline.ts
+import { spawn } from "child_process";
+import { randomUUID } from "crypto";
+import { renameSync, rmSync } from "fs";
+import { basename, dirname, extname, join } from "path";
+
+// src/background-removal/inference.ts
+var INPUT_SIZE = 320;
+var INPUT_PLANE = INPUT_SIZE * INPUT_SIZE;
+var MEAN = [0.485, 0.456, 0.406];
+var STD = [0.229, 0.224, 0.225];
+async function loadNative(name, load) {
+  try {
+    return await load();
+  } catch (err) {
+    throw new Error(
+      `remove-background needs the optional native module '${name}', which isn't available (${err.message}). Install it with \`npm i ${name}\`, or reinstall hyperframes with optional dependencies enabled.`
+    );
+  }
+}
+async function createSession(options = {}) {
+  const sharp = (await loadNative("sharp", () => import("sharp"))).default;
+  const ort = await loadOptionalPackage(
+    "onnxruntime-node",
+    "background removal"
+  );
+  const choice = selectProviders(options.device ?? "auto");
+  const path = await ensureModel(options.model, { onProgress: options.onProgress });
+  options.onProgress?.(`Loading model on ${choice.label}...`);
+  const tryCreate = (providers) => ort.InferenceSession.create(path, {
+    executionProviders: providers,
+    graphOptimizationLevel: "all"
+  });
+  let session;
+  let providerUsed = choice.label;
+  try {
+    session = await tryCreate(choice.providers);
+  } catch (err) {
+    if (choice.providers[0] === "cpu") throw err;
+    options.onProgress?.(
+      `${choice.label} provider failed (${err.message}); falling back to CPU.`
+    );
+    session = await tryCreate(["cpu"]);
+    providerUsed = "CPU";
+  }
+  const inputName = session.inputNames[0];
+  const outputName = session.outputNames[0];
+  if (!inputName || !outputName) {
+    throw new Error("ONNX session is missing input or output bindings");
+  }
+  const inputData = new Float32Array(3 * INPUT_PLANE);
+  const maskBuf = Buffer.allocUnsafe(INPUT_PLANE);
+  let rgbaBuf = null;
+  let rgbaBgBuf = null;
+  return {
+    provider: providerUsed,
+    async process(rgb, width, height, withBackground = false) {
+      const tensor = await preprocess(sharp, ort, rgb, width, height, inputData);
+      const outputs = await session.run({ [inputName]: tensor });
+      const output = outputs[outputName];
+      if (!output) throw new Error(`Model did not return output '${outputName}'`);
+      const expectedBytes = width * height * 4;
+      if (!rgbaBuf || rgbaBuf.length !== expectedBytes) {
+        rgbaBuf = Buffer.allocUnsafe(expectedBytes);
+      }
+      if (withBackground) {
+        if (!rgbaBgBuf || rgbaBgBuf.length !== expectedBytes) {
+          rgbaBgBuf = Buffer.allocUnsafe(expectedBytes);
+        }
+      }
+      return await postprocess(
+        sharp,
+        output,
+        rgb,
+        width,
+        height,
+        maskBuf,
+        rgbaBuf,
+        withBackground ? rgbaBgBuf : null
+      );
+    },
+    async close() {
+      await session.release();
+    }
+  };
+}
+async function preprocess(sharp, ort, rgb, width, height, inputData) {
+  const resized = await sharp(rgb, { raw: { width, height, channels: 3 } }).resize(INPUT_SIZE, INPUT_SIZE, { kernel: "lanczos3", fit: "fill" }).raw().toBuffer();
+  let maxPixel = 0;
+  for (let i = 0; i < resized.length; i++) {
+    if (resized[i] > maxPixel) maxPixel = resized[i];
+  }
+  if (maxPixel === 0) maxPixel = 1;
+  for (let y = 0; y < INPUT_SIZE; y++) {
+    for (let x = 0; x < INPUT_SIZE; x++) {
+      const src = (y * INPUT_SIZE + x) * 3;
+      const dst = y * INPUT_SIZE + x;
+      inputData[dst] = (resized[src] / maxPixel - MEAN[0]) / STD[0];
+      inputData[INPUT_PLANE + dst] = (resized[src + 1] / maxPixel - MEAN[1]) / STD[1];
+      inputData[2 * INPUT_PLANE + dst] = (resized[src + 2] / maxPixel - MEAN[2]) / STD[2];
+    }
+  }
+  return new ort.Tensor("float32", inputData, [1, 3, INPUT_SIZE, INPUT_SIZE]);
+}
+async function postprocess(sharp, output, rgb, width, height, maskBuf, rgbaBuf, rgbaBgBuf) {
+  const raw = output.data;
+  let lo = Infinity;
+  let hi = -Infinity;
+  for (let i = 0; i < INPUT_PLANE; i++) {
+    const v = raw[i];
+    if (v < lo) lo = v;
+    if (v > hi) hi = v;
+  }
+  const range = hi - lo || 1;
+  for (let i = 0; i < INPUT_PLANE; i++) {
+    const norm = (raw[i] - lo) / range;
+    maskBuf[i] = Math.max(0, Math.min(255, Math.round(norm * 255)));
+  }
+  const fullMask = await sharp(maskBuf, {
+    raw: { width: INPUT_SIZE, height: INPUT_SIZE, channels: 1 }
+  }).resize(width, height, { kernel: "lanczos3", fit: "fill" }).toColourspace("b-w").raw().toBuffer();
+  return applyMask(rgb, fullMask, rgbaBuf, rgbaBgBuf, width * height);
+}
+function applyMask(rgb, mask, fg, bg, pixels) {
+  if (bg) {
+    for (let i = 0; i < pixels; i++) {
+      const r = rgb[i * 3];
+      const g = rgb[i * 3 + 1];
+      const b = rgb[i * 3 + 2];
+      const m = mask[i];
+      const o = i * 4;
+      fg[o] = r;
+      fg[o + 1] = g;
+      fg[o + 2] = b;
+      fg[o + 3] = m;
+      bg[o] = r;
+      bg[o + 1] = g;
+      bg[o + 2] = b;
+      bg[o + 3] = 255 - m;
+    }
+    return { fg, bg };
+  }
+  for (let i = 0; i < pixels; i++) {
+    fg[i * 4] = rgb[i * 3];
+    fg[i * 4 + 1] = rgb[i * 3 + 1];
+    fg[i * 4 + 2] = rgb[i * 3 + 2];
+    fg[i * 4 + 3] = mask[i];
+  }
+  return { fg, bg: null };
+}
+
+// src/background-removal/pipeline.ts
+var QUALITY_CRF = {
+  fast: 30,
+  balanced: 18,
+  best: 12
+};
+var QUALITIES = Object.keys(QUALITY_CRF);
+var DEFAULT_QUALITY = "balanced";
+var isQuality = (v) => typeof v === "string" && QUALITIES.includes(v);
+var VIDEO_EXTENSIONS = /* @__PURE__ */ new Set([".mp4", ".mov", ".webm", ".mkv", ".avi"]);
+var IMAGE_EXTENSIONS = /* @__PURE__ */ new Set([".jpg", ".jpeg", ".png", ".webp"]);
+function inferOutputFormat(outputPath) {
+  const ext = extname(outputPath).toLowerCase();
+  if (ext === ".webm") return "webm";
+  if (ext === ".mov") return "mov";
+  if (ext === ".png") return "png";
+  throw new Error(
+    `Unsupported output extension: ${ext}. Use .webm (VP9 alpha), .mov (ProRes 4444), or .png.`
+  );
+}
+function inferInputKind(inputPath) {
+  const ext = extname(inputPath).toLowerCase();
+  if (VIDEO_EXTENSIONS.has(ext)) return "video";
+  if (IMAGE_EXTENSIONS.has(ext)) return "image";
+  throw new Error(
+    `Unsupported input: ${ext}. Use a video (mp4/mov/webm/mkv/avi) or image (jpg/png/webp).`
+  );
+}
+async function probeMedia(inputPath) {
+  const isImage = inferInputKind(inputPath) === "image";
+  const engine = await import("./src-PVYUYV3M.js");
+  const meta = await engine.extractMediaMetadata(inputPath);
+  if (isImage) {
+    return { width: meta.width, height: meta.height, fps: 0, frameCount: 1 };
+  }
+  const fps = meta.fps || 30;
+  const frameCount = meta.durationSeconds ? Math.round(meta.durationSeconds * fps) : 0;
+  return { width: meta.width, height: meta.height, fps, frameCount };
+}
+function buildEncoderArgs(format, width, height, fps, outputPath, quality = DEFAULT_QUALITY) {
+  const base = [
+    "-y",
+    "-f",
+    "rawvideo",
+    "-pix_fmt",
+    "rgba",
+    "-s",
+    `${width}x${height}`,
+    "-r",
+    String(fps || 30),
+    "-i",
+    "-"
+  ];
+  if (format === "webm") {
+    return [
+      ...base,
+      "-c:v",
+      "libvpx-vp9",
+      "-b:v",
+      "0",
+      "-crf",
+      String(QUALITY_CRF[quality]),
+      "-deadline",
+      "good",
+      "-row-mt",
+      "1",
+      "-cpu-used",
+      String(DEFAULT_VP9_CPU_USED),
+      "-auto-alt-ref",
+      "0",
+      "-pix_fmt",
+      "yuva420p",
+      // Tag the output as BT.709 limited range so browsers use the same
+      // YUV→RGB matrix the source video was encoded with. Without these tags
+      // ffmpeg's default RGB→YUV conversion is BT.601, which causes a visible
+      // color shift (red/skin tones in particular) when the matted overlay is
+      // composited over the original mp4.
+      "-colorspace",
+      "bt709",
+      "-color_primaries",
+      "bt709",
+      "-color_trc",
+      "bt709",
+      "-color_range",
+      "tv",
+      "-metadata:s:v:0",
+      "alpha_mode=1",
+      "-an",
+      ...renderProvenanceArgs(outputPath),
+      outputPath
+    ];
+  }
+  if (format === "mov") {
+    return [
+      ...base,
+      "-c:v",
+      "prores_ks",
+      "-profile:v",
+      "4444",
+      "-vendor",
+      "apl0",
+      "-pix_fmt",
+      "yuva444p10le",
+      "-an",
+      ...renderProvenanceArgs(outputPath),
+      outputPath
+    ];
+  }
+  return [...base, "-frames:v", "1", "-pix_fmt", "rgba", "-update", "1", outputPath];
+}
+async function* readFrames(stream, frameBytes) {
+  let buffered = Buffer.alloc(0);
+  for await (const chunk of stream) {
+    buffered = buffered.length === 0 ? chunk : Buffer.concat([buffered, chunk]);
+    while (buffered.length >= frameBytes) {
+      yield Buffer.from(buffered.subarray(0, frameBytes));
+      buffered = buffered.subarray(frameBytes);
+    }
+  }
+}
+function resolveRenderTargets(inputPath, outputPath, backgroundOutputPath) {
+  const format = inferOutputFormat(outputPath);
+  const inputKind = inferInputKind(inputPath);
+  if (inputKind === "image" && format !== "png") {
+    throw new Error(
+      `Image input requires a .png output (got ${extname(outputPath)}). Use a video input for .webm/.mov.`
+    );
+  }
+  if (inputKind === "video" && format === "png") {
+    throw new Error(
+      `Video input requires a .webm or .mov output (got .png). Use an image input for .png.`
+    );
+  }
+  let bgFormat;
+  if (backgroundOutputPath) {
+    if (inputKind === "image") {
+      throw new Error(
+        "--background-output is not supported for image inputs. Use a video input (mp4/mov/webm) to produce both a cutout and a background plate."
+      );
+    }
+    bgFormat = inferOutputFormat(backgroundOutputPath);
+    if (bgFormat === "png") {
+      throw new Error(
+        "--background-output must be .webm or .mov; .png is only valid for single-image inputs."
+      );
+    }
+  }
+  return { format, inputKind, bgFormat };
+}
+async function render(options) {
+  const ffmpegPath = findFFmpeg();
+  if (!ffmpegPath || !findFFprobe()) {
+    throw new Error(`ffmpeg and ffprobe are required. Install: ${getFFmpegInstallHint()}`);
+  }
+  const { format, bgFormat } = resolveRenderTargets(
+    options.inputPath,
+    options.outputPath,
+    options.backgroundOutputPath
+  );
+  const media = await probeMedia(options.inputPath);
+  options.onProgress?.({
+    kind: "metadata",
+    width: media.width,
+    height: media.height,
+    fps: media.fps,
+    frameCount: media.frameCount
+  });
+  const session = await createSession({
+    model: options.model,
+    device: options.device,
+    onProgress: (msg) => options.onProgress?.({ kind: "info", message: msg })
+  });
+  const output = tempBeside(options.outputPath);
+  const background = options.backgroundOutputPath && tempBeside(options.backgroundOutputPath);
+  try {
+    const start = Date.now();
+    const framesProcessed = await runPipeline(
+      { ...options, outputPath: output, backgroundOutputPath: background },
+      session,
+      media,
+      format,
+      bgFormat,
+      ffmpegPath
+    );
+    renameSync(output, options.outputPath);
+    if (background) renameSync(background, options.backgroundOutputPath);
+    const durationSeconds = (Date.now() - start) / 1e3;
+    const avgMsPerFrame = framesProcessed ? durationSeconds * 1e3 / framesProcessed : 0;
+    return {
+      outputPath: options.outputPath,
+      backgroundOutputPath: options.backgroundOutputPath,
+      framesProcessed,
+      durationSeconds,
+      avgMsPerFrame,
+      provider: session.provider,
+      format
+    };
+  } finally {
+    await session.close();
+    rmSync(output, { force: true, maxRetries: 3 });
+    if (background) rmSync(background, { force: true, maxRetries: 3 });
+  }
+}
+function tempBeside(path) {
+  return join(dirname(path), `.tmp-${randomUUID()}-${basename(path)}`);
+}
+var RECENT_WINDOW = 30;
+function spawnFfmpeg(ffmpegPath, args, label, stdio) {
+  const proc = spawn(ffmpegPath, args, { stdio, windowsHide: true });
+  let stderrBuf = "";
+  proc.stderr?.on("data", (d) => {
+    stderrBuf += d.toString();
+  });
+  proc.stdin?.on("error", () => {
+  });
+  const exit = waitForExit(proc, label, () => stderrBuf);
+  return { proc, exit, getStderr: () => stderrBuf };
+}
+async function runPipeline(options, session, media, format, bgFormat, ffmpegPath) {
+  const { inputPath, outputPath, backgroundOutputPath } = options;
+  const { width, height, fps, frameCount } = media;
+  const frameBytes = width * height * 3;
+  const quality = options.quality ?? DEFAULT_QUALITY;
+  const decoder = spawnFfmpeg(
+    ffmpegPath,
+    ["-loglevel", "error", "-i", inputPath, "-f", "rawvideo", "-pix_fmt", "rgb24", "-an", "-"],
+    "ffmpeg decoder",
+    ["ignore", "pipe", "pipe"]
+  );
+  const fg = spawnFfmpeg(
+    ffmpegPath,
+    buildEncoderArgs(format, width, height, fps || 30, outputPath, quality),
+    "ffmpeg encoder",
+    ["pipe", "ignore", "pipe"]
+  );
+  const bg = backgroundOutputPath && bgFormat ? spawnFfmpeg(
+    ffmpegPath,
+    buildEncoderArgs(bgFormat, width, height, fps || 30, backgroundOutputPath, quality),
+    "ffmpeg background encoder",
+    ["pipe", "ignore", "pipe"]
+  ) : null;
+  let processed = 0;
+  const total = frameCount;
+  const recentMs = new Array(RECENT_WINDOW).fill(0);
+  let recentSum = 0;
+  let recentSlot = 0;
+  let recentCount = 0;
+  try {
+    for await (const rgb of readFrames(decoder.proc.stdout, frameBytes)) {
+      const t0 = Date.now();
+      const result = await session.process(rgb, width, height, bg !== null);
+      const elapsed = Date.now() - t0;
+      recentSum += elapsed - recentMs[recentSlot];
+      recentMs[recentSlot] = elapsed;
+      recentSlot = (recentSlot + 1) % RECENT_WINDOW;
+      if (recentCount < RECENT_WINDOW) recentCount++;
+      const fgWroteFully = fg.proc.stdin.write(result.fg);
+      const bgWroteFully = bg && result.bg ? bg.proc.stdin.write(result.bg) : true;
+      if (!fgWroteFully || !bgWroteFully) {
+        const drains = [];
+        if (!fgWroteFully) {
+          drains.push(
+            new Promise((resolve) => fg.proc.stdin.once("drain", () => resolve()))
+          );
+        }
+        if (!bgWroteFully && bg) {
+          drains.push(
+            new Promise((resolve) => bg.proc.stdin.once("drain", () => resolve()))
+          );
+        }
+        await Promise.all(drains);
+      }
+      processed++;
+      options.onProgress?.({
+        kind: "frame",
+        index: processed,
+        total,
+        avgMsPerFrame: recentSum / recentCount
+      });
+    }
+  } catch (err) {
+    decoder.proc.kill("SIGKILL");
+    fg.proc.kill("SIGKILL");
+    bg?.proc.kill("SIGKILL");
+    throw err;
+  }
+  fg.proc.stdin.end();
+  bg?.proc.stdin.end();
+  const exits = [decoder.exit, fg.exit];
+  if (bg) exits.push(bg.exit);
+  await Promise.all(exits);
+  if (processed === 0) {
+    throw new Error(
+      `No frames produced from ${inputPath}. Decoder stderr:
+${decoder.getStderr().slice(-400)}`
+    );
+  }
+  return processed;
+}
+function waitForExit(proc, label, getStderr) {
+  return new Promise((resolve, reject) => {
+    proc.on("error", reject);
+    proc.on("exit", (code, signal) => {
+      if (code === 0 && !signal) {
+        resolve();
+        return;
+      }
+      const cause = signal ? `killed by ${signal}` : `exited with code ${code}`;
+      reject(new Error(`${label} ${cause}: ${getStderr().slice(-400)}`));
+    });
+  });
+}
+
+export {
+  QUALITIES,
+  DEFAULT_QUALITY,
+  isQuality,
+  inferOutputFormat,
+  inferInputKind,
+  buildEncoderArgs,
+  resolveRenderTargets,
+  render,
+  waitForExit
+};

package/vendor/hyperframes/dist/chunk-LYNI3FOL.js

@@ -0,0 +1,123 @@
+import { createRequire as __hf_createRequire } from "node:module";
+import { fileURLToPath as __hf_fileURLToPath } from "node:url";
+import { dirname as __hf_dirname } from "node:path";
+var require = __hf_createRequire(import.meta.url);
+var __filename = __hf_fileURLToPath(import.meta.url);
+var __dirname = __hf_dirname(__filename);
+import {
+  DEFAULT_REGISTRY_URL,
+  fetchItemManifest,
+  fetchRegistryManifest
+} from "./chunk-A2Z4Z4VL.js";
+
+// src/registry/resolver.ts
+function defaultWarn(message) {
+  process.stderr.write(`hyperframes:registry ${message}
+`);
+}
+async function listRegistryItems(filter, options = {}) {
+  const baseUrl = options.baseUrl ?? DEFAULT_REGISTRY_URL;
+  const manifest = await fetchRegistryManifest(baseUrl, { skipCache: options.skipCache });
+  if (!manifest) return [];
+  if (!filter?.type) return manifest.items;
+  return manifest.items.filter((item) => item.type === filter.type);
+}
+async function loadAllItems(entries, options = {}) {
+  const baseUrl = options.baseUrl ?? DEFAULT_REGISTRY_URL;
+  const warn = options.onWarn ?? defaultWarn;
+  const results = await Promise.allSettled(
+    entries.map((e) => fetchItemManifest(e.name, e.type, baseUrl))
+  );
+  const items = [];
+  results.forEach((r, i) => {
+    if (r.status === "fulfilled") {
+      items.push(r.value);
+    } else {
+      const name = entries[i]?.name ?? "<unknown>";
+      warn(`skipped item "${name}": ${String(r.reason)}`);
+    }
+  });
+  return items;
+}
+async function resolveItem(name, options = {}) {
+  const items = await resolveItemWithDependencies(name, options);
+  if (items.length > 1) {
+    const deps = items.slice(0, -1).map((i) => i.name).join(", ");
+    throw new Error(
+      `Item "${name}" declares registryDependencies (${deps}); use resolveItemWithDependencies to resolve and install them in order.`
+    );
+  }
+  const item = items[items.length - 1];
+  if (!item) {
+    throw new Error(unreachableRegistryMessage(name, options.baseUrl));
+  }
+  return item;
+}
+function unreachableRegistryMessage(name, baseUrl) {
+  const where = baseUrl && !baseUrl.startsWith(DEFAULT_REGISTRY_URL) ? ` Contacted ${baseUrl}, set by this project's hyperframes.json, not the public registry.` : "";
+  return `Item "${name}" not found \u2014 registry unreachable or empty.${where}`;
+}
+async function resolveItemWithDependencies(name, options = {}) {
+  const entries = await listRegistryItems(void 0, options);
+  const entry = entries.find((e) => e.name === name);
+  if (!entry) {
+    const available = entries.map((e) => e.name).join(", ");
+    throw new Error(
+      available.length > 0 ? `Item "${name}" not found in registry. Available: ${available}` : unreachableRegistryMessage(name, options.baseUrl)
+    );
+  }
+  const entryByName = new Map(entries.map((e) => [e.name, e]));
+  const visiting = /* @__PURE__ */ new Set();
+  const visited = /* @__PURE__ */ new Set();
+  const ordered = [];
+  const itemCache = /* @__PURE__ */ new Map();
+  const getItem = async (itemName) => {
+    const existing = itemCache.get(itemName);
+    if (existing) return existing;
+    const registryEntry = entryByName.get(itemName);
+    if (!registryEntry) {
+      const available = entries.map((e) => e.name).join(", ");
+      throw new Error(
+        available.length > 0 ? `Dependency "${itemName}" not found in registry. Available: ${available}` : unreachableRegistryMessage(itemName, options.baseUrl)
+      );
+    }
+    const pending = fetchItemManifest(registryEntry.name, registryEntry.type, options.baseUrl);
+    itemCache.set(itemName, pending);
+    return pending;
+  };
+  const visit = async (itemName, path) => {
+    if (visited.has(itemName)) return;
+    if (visiting.has(itemName)) {
+      const cycleStart = path.indexOf(itemName);
+      const cyclePath = [...path.slice(cycleStart), itemName].join(" -> ");
+      throw new Error(`Circular registryDependencies detected: ${cyclePath}`);
+    }
+    visiting.add(itemName);
+    const item = await getItem(itemName);
+    for (const dep of item.registryDependencies ?? []) {
+      await visit(dep, [...path, itemName]);
+    }
+    visiting.delete(itemName);
+    visited.add(itemName);
+    ordered.push(item);
+  };
+  await visit(name, []);
+  return ordered;
+}
+async function resolveItemsByTag(tag, options = {}) {
+  const entries = await listRegistryItems(void 0, options);
+  const allItems = await loadAllItems(entries, { ...options, onWarn: () => {
+  } });
+  return allItems.filter(
+    (item) => "tags" in item && Array.isArray(item.tags) && item.tags.includes(tag)
+  );
+}
+
+export {
+  listRegistryItems,
+  loadAllItems,
+  resolveItem,
+  unreachableRegistryMessage,
+  resolveItemWithDependencies,
+  resolveItemsByTag
+};

package/vendor/hyperframes/dist/chunk-M2WBOQ2Q.js

@@ -0,0 +1,54 @@
+import { createRequire as __hf_createRequire } from "node:module";
+import { fileURLToPath as __hf_fileURLToPath } from "node:url";
+import { dirname as __hf_dirname } from "node:path";
+var require = __hf_createRequire(import.meta.url);
+var __filename = __hf_fileURLToPath(import.meta.url);
+var __dirname = __hf_dirname(__filename);
+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 __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __commonJS = (cb, mod) => function __require2() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+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);
+
+export {
+  __require,
+  __esm,
+  __commonJS,
+  __export,
+  __toESM,
+  __toCommonJS
+};