@ignix-social/editor 0.1.0

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

@@ -0,0 +1,265 @@
+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 {
+  detectWSL
+} from "./chunk-AMKC3AXA.js";
+import {
+  runCancellableProcess
+} from "./chunk-LCSMOLGX.js";
+import {
+  findFfBinary
+} from "./chunk-PJ3HDUCY.js";
+
+// src/browser/ffmpeg.ts
+import { execFileSync as execFileSync2 } from "child_process";
+
+// src/browser/linuxDeps.ts
+import { execFileSync } from "child_process";
+import { existsSync, readFileSync } from "fs";
+var DISTRO_PACKAGES = {
+  debian: [
+    "libnss3",
+    "libnspr4",
+    "libatk1.0-0",
+    "libatk-bridge2.0-0",
+    "libcups2",
+    "libdrm2",
+    "libxkbcommon0",
+    "libatspi2.0-0",
+    "libxcomposite1",
+    "libxdamage1",
+    "libxfixes3",
+    "libxrandr2",
+    "libgbm1",
+    "libpango-1.0-0",
+    "libcairo2",
+    "libasound2"
+  ],
+  fedora: [
+    "nss",
+    "nspr",
+    "atk",
+    "at-spi2-atk",
+    "cups-libs",
+    "libdrm",
+    "libxkbcommon",
+    "at-spi2-core",
+    "libXcomposite",
+    "libXdamage",
+    "libXfixes",
+    "libXrandr",
+    "mesa-libgbm",
+    "pango",
+    "cairo",
+    "alsa-lib"
+  ],
+  arch: [
+    "nss",
+    "nspr",
+    "atk",
+    "at-spi2-atk",
+    "libcups",
+    "libdrm",
+    "libxkbcommon",
+    "at-spi2-core",
+    "libxcomposite",
+    "libxdamage",
+    "libxfixes",
+    "libxrandr",
+    "mesa",
+    "pango",
+    "cairo",
+    "alsa-lib"
+  ],
+  alpine: [
+    "nss",
+    "nspr",
+    "atk",
+    "at-spi2-atk",
+    "cups-libs",
+    "libdrm",
+    "libxkbcommon",
+    "at-spi2-core",
+    "libxcomposite",
+    "libxdamage",
+    "libxfixes",
+    "libxrandr",
+    "mesa-gbm",
+    "pango",
+    "cairo",
+    "alsa-lib"
+  ]
+};
+var INSTALL_PREFIX = {
+  debian: "sudo apt-get update && sudo apt-get install -y",
+  fedora: "sudo dnf install -y",
+  arch: "sudo pacman -S --needed",
+  alpine: "sudo apk add"
+};
+function distroFamilyFromOsRelease(id, idLike) {
+  const haystack = `${id ?? ""} ${idLike ?? ""}`.toLowerCase();
+  if (/\b(debian|ubuntu|linuxmint|pop|elementary|raspbian|kali)\b/.test(haystack)) return "debian";
+  if (/\b(fedora|rhel|centos|rocky|almalinux|amzn|ol)\b/.test(haystack)) return "fedora";
+  if (/\b(arch|manjaro|endeavouros|garuda)\b/.test(haystack)) return "arch";
+  if (/\b(alpine)\b/.test(haystack)) return "alpine";
+  return "unknown";
+}
+function parseOsRelease(contents) {
+  const out = {};
+  for (const rawLine of contents.split("\n")) {
+    const line = rawLine.trim();
+    if (!line || line.startsWith("#")) continue;
+    const eq = line.indexOf("=");
+    if (eq < 0) continue;
+    const key = line.slice(0, eq).trim();
+    let value = line.slice(eq + 1).trim();
+    if (value.length >= 2 && (value[0] === '"' || value[0] === "'") && value.at(-1) === value[0]) {
+      value = value.slice(1, -1);
+    }
+    if (key) out[key] = value;
+  }
+  return out;
+}
+function detectLinuxDistro() {
+  const isWsl = detectWSL();
+  try {
+    const contents = readFileSync("/etc/os-release", "utf-8");
+    const parsed = parseOsRelease(contents);
+    const family = distroFamilyFromOsRelease(parsed["ID"], parsed["ID_LIKE"]);
+    return {
+      family,
+      ...parsed["ID"] ? { id: parsed["ID"] } : {},
+      ...parsed["PRETTY_NAME"] ? { prettyName: parsed["PRETTY_NAME"] } : {},
+      isWsl
+    };
+  } catch {
+    return { family: "unknown", isWsl };
+  }
+}
+function chromeDepsInstallCommand(family) {
+  if (family === "unknown") {
+    return "Install the Chrome headless dependencies for your distro (nss, atk, at-spi2, cups, libdrm, libxkbcommon, gbm, pango, cairo, alsa), then re-run.";
+  }
+  return `${INSTALL_PREFIX[family]} ${DISTRO_PACKAGES[family].join(" ")}`;
+}
+function ffmpegInstallCommand(family) {
+  if (family === "unknown") {
+    return "Install ffmpeg (which includes ffprobe) via your distro package manager, then re-run.";
+  }
+  return `${INSTALL_PREFIX[family]} ffmpeg`;
+}
+function distroLabel(distro) {
+  if (distro.isWsl) return "WSL";
+  return distro.prettyName ?? "Linux";
+}
+function parseLddMissingLibs(lddOutput) {
+  const missing = [];
+  for (const rawLine of lddOutput.split("\n")) {
+    const line = rawLine.trim();
+    if (!/=>\s*not found\b/.test(line)) continue;
+    const soname = line.split("=>")[0]?.trim();
+    if (soname) missing.push(soname);
+  }
+  return { ok: missing.length === 0, missing, probeUnavailable: false };
+}
+function isSharedLibLaunchError(message) {
+  return /cannot open shared object file/i.test(message) || /error while loading shared libraries/i.test(message) || /lib[\w.+-]*\.so[\w.]*: cannot open/i.test(message);
+}
+function chromeLaunchRemediation(errorMessage) {
+  const isLaunchFailure = /Failed to launch the browser process/i.test(errorMessage) || isSharedLibLaunchError(errorMessage);
+  if (!isLaunchFailure) return void 0;
+  if (process.platform !== "linux") return void 0;
+  if (process.arch === "arm64") return void 0;
+  const distro = detectLinuxDistro();
+  const lines = [];
+  lines.push(
+    `Chrome could not launch on ${distroLabel(distro)} \u2014 this is almost always missing system libraries (e.g. libnss3).`
+  );
+  lines.push("Install the Chrome headless dependencies:");
+  lines.push(`  ${chromeDepsInstallCommand(distro.family)}`);
+  lines.push("Then verify with: npx hyperframes doctor");
+  return lines.join("\n");
+}
+
+// src/browser/ffmpeg.ts
+var H264EncoderUnavailableError = class extends Error {
+  constructor() {
+    super("This FFmpeg build has neither libx264 nor VideoToolbox H.264 encoding.");
+    this.name = "H264EncoderUnavailableError";
+  }
+};
+function resolveH264EncoderMode(ffmpegEncodersOutput, gpuRequested) {
+  if (gpuRequested) return "gpu";
+  if (/\blibx264\b/.test(ffmpegEncodersOutput)) return "software";
+  if (/\bh264_videotoolbox\b/.test(ffmpegEncodersOutput)) return "gpu";
+  throw new H264EncoderUnavailableError();
+}
+function detectH264EncoderMode(ffmpegPath, gpuRequested) {
+  const encoders = execFileSync2(ffmpegPath, ["-hide_banner", "-encoders"], {
+    encoding: "utf-8",
+    stdio: ["ignore", "pipe", "pipe"],
+    timeout: 5e3,
+    windowsHide: true
+  });
+  return resolveH264EncoderMode(encoders, gpuRequested);
+}
+async function detectH264EncoderModeForRender(ffmpegPath, gpuRequested, signal) {
+  const result = await runCancellableProcess(ffmpegPath, ["-hide_banner", "-encoders"], {
+    signal,
+    timeoutMs: 5e3
+  });
+  return resolveH264EncoderMode(result.stdout, gpuRequested);
+}
+function findFFmpeg() {
+  return findFfBinary("ffmpeg", { configuredMustExist: true });
+}
+function findFFprobe() {
+  return findFfBinary("ffprobe", { configuredMustExist: true });
+}
+var FFMPEG_DOWNLOAD_URL = "https://ffmpeg.org/download.html";
+function getFFmpegInstallCommand() {
+  switch (process.platform) {
+    case "darwin":
+      return "brew install ffmpeg";
+    case "linux": {
+      const distro = detectLinuxDistro();
+      if (distro.family === "unknown") return void 0;
+      return ffmpegInstallCommand(distro.family);
+    }
+    // winget ships with Windows 10 1809+ and Windows 11. Machines without it
+    // still get the manual download route from the hint below.
+    case "win32":
+      return "winget install --id Gyan.FFmpeg -e";
+    default:
+      return void 0;
+  }
+}
+function getFFmpegInstallHint() {
+  const command = getFFmpegInstallCommand();
+  if (command && process.platform === "win32") {
+    return `${command}, or download the 64-bit build from ${FFMPEG_DOWNLOAD_URL}#build-windows and add its bin/ directory to PATH.`;
+  }
+  if (command) return command;
+  if (process.platform === "linux") return ffmpegInstallCommand("unknown");
+  return FFMPEG_DOWNLOAD_URL;
+}
+
+export {
+  detectLinuxDistro,
+  chromeDepsInstallCommand,
+  distroLabel,
+  parseLddMissingLibs,
+  chromeLaunchRemediation,
+  H264EncoderUnavailableError,
+  resolveH264EncoderMode,
+  detectH264EncoderMode,
+  detectH264EncoderModeForRender,
+  findFFmpeg,
+  findFFprobe,
+  getFFmpegInstallCommand,
+  getFFmpegInstallHint
+};

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

@@ -0,0 +1,24 @@
+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);
+
+// ../engine/src/services/chromeHostCeiling.ts
+import { release } from "os";
+var MACOS_12_LAST_CHROME_MAJOR = 150;
+function chromeMajorCeiling(hostPlatform = process.platform, hostRelease = release()) {
+  if (hostPlatform !== "darwin") return void 0;
+  return Number.parseInt(hostRelease, 10) < 22 ? MACOS_12_LAST_CHROME_MAJOR : void 0;
+}
+function exceedsChromeCeiling(versionName, ceiling) {
+  if (ceiling === void 0) return false;
+  const major = Number.parseInt(versionName.slice(versionName.indexOf("-") + 1), 10);
+  return major > ceiling;
+}
+
+export {
+  chromeMajorCeiling,
+  exceedsChromeCeiling
+};

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

@@ -0,0 +1,27 @@
+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 {
+  c
+} from "./chunk-ZTZA4UWZ.js";
+
+// src/cloud/statusColor.ts
+function colorStatus(status) {
+  switch (status) {
+    case "completed":
+      return c.success(status);
+    case "failed":
+      return c.error(status);
+    case "rendering":
+      return c.progress(status);
+    default:
+      return c.dim(status);
+  }
+}
+
+export {
+  colorStatus
+};

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

@@ -0,0 +1,139 @@
+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 {
+  getMimeType
+} from "./chunk-S7NPLFWV.js";
+import {
+  injectTagsAtHeadStart
+} from "./chunk-HWKCIWQT.js";
+
+// src/utils/compositionServer.ts
+import { createHash } from "crypto";
+import { createReadStream, existsSync, statSync } from "fs";
+import { resolve, dirname } from "path";
+import { Readable } from "stream";
+import { fileURLToPath } from "url";
+function helperDir() {
+  return dirname(fileURLToPath(import.meta.url));
+}
+function resolveRuntimePath() {
+  const d = helperDir();
+  const candidates = [
+    resolve(d, "hyperframe-runtime.js"),
+    resolve(d, "..", "hyperframe-runtime.js"),
+    // Monorepo dev: src/<dir>/ → src/ → cli/ → packages/ then into core/dist/
+    resolve(d, "..", "..", "..", "core", "dist", "hyperframe.runtime.iife.js")
+  ];
+  return candidates.find((p) => existsSync(p)) ?? null;
+}
+function resolvePlayerPath() {
+  const d = helperDir();
+  const candidates = [
+    resolve(d, "..", "..", "..", "player", "dist", "hyperframes-player.global.js"),
+    resolve(d, "hyperframes-player.global.js"),
+    resolve(d, "..", "hyperframes-player.global.js")
+  ];
+  return candidates.find((p) => existsSync(p)) ?? null;
+}
+function resolveSlideshowPath() {
+  const d = helperDir();
+  const candidates = [
+    resolve(d, "..", "..", "..", "player", "dist", "slideshow", "hyperframes-slideshow.global.js"),
+    resolve(d, "hyperframes-slideshow.global.js"),
+    resolve(d, "..", "hyperframes-slideshow.global.js")
+  ];
+  return candidates.find((p) => existsSync(p)) ?? null;
+}
+function injectRuntime(html) {
+  return injectTagsAtHeadStart(html, `<script src="/runtime.js"></script>`);
+}
+function assetContentType(filePath) {
+  return getMimeType(filePath);
+}
+function revalidatedResponse(body, contentType, ifNoneMatch) {
+  const etag = `"${createHash("sha256").update(body).digest("base64url").slice(0, 27)}"`;
+  const headers = { "Content-Type": contentType, "Cache-Control": "no-cache", ETag: etag };
+  if (ifNoneMatch === etag) return new Response(null, { status: 304, headers });
+  return new Response(body, { status: 200, headers });
+}
+function buildRangeResponse(filePath, contentType, rangeHeader, ifNoneMatch) {
+  const { size, mtimeMs } = statSync(filePath);
+  const last = size - 1;
+  const cache = {
+    "Cache-Control": "no-cache",
+    ETag: `"${mtimeMs.toString(36)}-${size.toString(36)}"`
+  };
+  if (ifNoneMatch === cache.ETag) return new Response(null, { status: 304, headers: cache });
+  const match = rangeHeader ? /^bytes=(\d*)-(\d*)$/.exec(rangeHeader.trim()) : null;
+  const body = (start2, end2) => size === 0 ? null : Readable.toWeb(createReadStream(filePath, { start: start2, end: end2 }));
+  if (!match) {
+    return new Response(body(0, last), {
+      status: 200,
+      headers: {
+        ...cache,
+        "Content-Type": contentType,
+        "Accept-Ranges": "bytes",
+        "Content-Length": String(size)
+      }
+    });
+  }
+  const hasStart = match[1] !== "";
+  const start = hasStart ? Number(match[1]) : Math.max(0, size - Number(match[2]));
+  const end = !hasStart ? last : match[2] !== "" ? Math.min(Number(match[2]), last) : last;
+  if (start > end || start > last) {
+    return new Response(null, {
+      status: 416,
+      headers: { "Content-Range": `bytes */${size}`, "Accept-Ranges": "bytes" }
+    });
+  }
+  return new Response(body(start, end), {
+    status: 206,
+    headers: {
+      ...cache,
+      "Content-Type": contentType,
+      "Accept-Ranges": "bytes",
+      "Content-Range": `bytes ${start}-${end}/${size}`,
+      "Content-Length": String(end - start + 1)
+    }
+  });
+}
+async function listenOnFreePort(server, startPort) {
+  for (let attempt = 0; attempt < 10; attempt++) {
+    const port = startPort + attempt;
+    try {
+      await new Promise((res, rej) => {
+        const onErr = (err) => {
+          server.removeListener("listening", onOk);
+          rej(err ?? new Error("server error"));
+        };
+        const onOk = () => {
+          server.removeListener("error", onErr);
+          res();
+        };
+        server.once("error", onErr);
+        server.once("listening", onOk);
+        server.listen(port);
+      });
+      return port;
+    } catch (err) {
+      if (err.code === "EADDRINUSE") continue;
+      throw err;
+    }
+  }
+  throw new Error(`No free port found in [${startPort}, ${startPort + 9}]`);
+}
+
+export {
+  resolveRuntimePath,
+  resolvePlayerPath,
+  resolveSlideshowPath,
+  injectRuntime,
+  assetContentType,
+  revalidatedResponse,
+  buildRangeResponse,
+  listenOnFreePort
+};

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

@@ -0,0 +1,61 @@
+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);
+
+// src/capture/captureWatchdog.ts
+async function runWithWatchdog(work, deadline) {
+  const observedWork = work.then(
+    (result) => ({ kind: "complete", result }),
+    (error) => ({ kind: "error", error })
+  );
+  return await Promise.race([
+    observedWork,
+    deadline.then(() => ({ kind: "deadline" }))
+  ]);
+}
+function createCaptureWatchdog(deadlineMs) {
+  let browser;
+  let didExpire = false;
+  let timer;
+  let resolveDeadline = () => {
+  };
+  const promise = new Promise((resolve) => {
+    resolveDeadline = resolve;
+  });
+  if (deadlineMs !== void 0) {
+    timer = setTimeout(() => {
+      didExpire = true;
+      resolveDeadline();
+      void browser?.close().catch(() => void 0);
+    }, deadlineMs);
+  }
+  return {
+    expired: () => didExpire,
+    promise,
+    registerBrowser: (nextBrowser) => {
+      browser = nextBrowser;
+      if (didExpire) void browser.close().catch(() => void 0);
+    },
+    unregisterBrowser: (closedBrowser) => {
+      if (browser === closedBrowser) browser = void 0;
+    },
+    dispose: () => {
+      if (timer !== void 0) clearTimeout(timer);
+    }
+  };
+}
+function parseCaptureDeadline(raw) {
+  if (raw === void 0 || raw === "") return void 0;
+  const parsed = Number(raw);
+  if (!Number.isInteger(parsed) || parsed <= 0) return void 0;
+  return parsed;
+}
+
+export {
+  runWithWatchdog,
+  createCaptureWatchdog,
+  parseCaptureDeadline
+};

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

@@ -0,0 +1,27 @@
+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);
+
+// ../core/dist/tokenSlug.js
+function slugify(name) {
+  const collapsed = name.toLowerCase().replace(/[^a-z0-9]+/g, "-");
+  let start = 0;
+  let end = collapsed.length;
+  while (start < end && collapsed[start] === "-")
+    start++;
+  while (end > start && collapsed[end - 1] === "-")
+    end--;
+  const slug = collapsed.slice(start, end);
+  return slug.length > 0 ? slug : "node";
+}
+function cssVariableName(id) {
+  return `--${slugify(id)}`;
+}
+
+export {
+  slugify,
+  cssVariableName
+};