@ignix-social/editor 0.1.0

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

@@ -0,0 +1,113 @@
+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/utils/download.ts
+import { randomUUID } from "crypto";
+import { createWriteStream, renameSync, unlinkSync } from "fs";
+import { get as httpsGet } from "https";
+import { Transform } from "stream";
+import { pipeline } from "stream/promises";
+var DEFAULT_DOWNLOAD_TIMEOUT_MS = 3e4;
+var REDIRECT_CODES = /* @__PURE__ */ new Set([301, 302, 303, 307, 308]);
+function redirectTarget(location, from) {
+  return new URL(location, from).toString();
+}
+var MAX_REDIRECTS = 10;
+function removePartialFile(path) {
+  try {
+    unlinkSync(path);
+  } catch {
+  }
+}
+function enforceByteLimit(maxBytes) {
+  let received = 0;
+  return new Transform({
+    transform(chunk, _encoding, callback) {
+      received += chunk.byteLength;
+      callback(
+        received > maxBytes ? new Error(`Download exceeded ${maxBytes} bytes`) : null,
+        chunk
+      );
+    }
+  });
+}
+function downloadFile(url, dest, options = {}) {
+  const tmp = `${dest}.${process.pid}.${randomUUID()}.tmp`;
+  const timeoutMs = options.timeoutMs ?? DEFAULT_DOWNLOAD_TIMEOUT_MS;
+  const maxBytes = options.maxBytes;
+  return new Promise((resolve, reject) => {
+    const follow = (u, hops = 0) => {
+      let activeResponse;
+      let responsePipelineStarted = false;
+      let requestError;
+      let request;
+      try {
+        request = httpsGet(u, (res) => {
+          activeResponse = res;
+          if (res.statusCode && REDIRECT_CODES.has(res.statusCode)) {
+            const location = res.headers.location;
+            if (location) {
+              if (hops >= MAX_REDIRECTS) {
+                res.resume();
+                removePartialFile(tmp);
+                reject(
+                  new Error(`Download failed: more than ${MAX_REDIRECTS} redirects from ${url}`)
+                );
+                return;
+              }
+              res.resume();
+              try {
+                follow(redirectTarget(location, u), hops + 1);
+              } catch (error) {
+                removePartialFile(tmp);
+                reject(error);
+              }
+              return;
+            }
+          }
+          if (res.statusCode !== 200) {
+            res.resume();
+            removePartialFile(tmp);
+            reject(new Error(`Download failed: HTTP ${res.statusCode}`));
+            return;
+          }
+          const file = createWriteStream(tmp);
+          responsePipelineStarted = true;
+          const transfer = maxBytes === void 0 ? pipeline(res, file) : pipeline(res, enforceByteLimit(maxBytes), file);
+          transfer.then(() => {
+            renameSync(tmp, dest);
+            resolve();
+          }).catch((err) => {
+            removePartialFile(tmp);
+            reject(requestError ?? err);
+          });
+        });
+      } catch (error) {
+        removePartialFile(tmp);
+        reject(error);
+        return;
+      }
+      request.setTimeout(timeoutMs, () => {
+        request.destroy(new Error(`Download timed out after ${timeoutMs}ms`));
+      });
+      request.on("error", (err) => {
+        if (responsePipelineStarted) {
+          requestError = err;
+          activeResponse?.destroy(err);
+          return;
+        }
+        removePartialFile(tmp);
+        reject(err);
+      });
+    };
+    follow(url);
+  });
+}
+
+export {
+  downloadFile
+};

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

@@ -0,0 +1,6 @@
+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);

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

@@ -0,0 +1,59 @@
+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 {
+  VERSION
+} from "./chunk-FLWXXDNS.js";
+
+// src/registry/compatibility.ts
+import { compareVersions } from "compare-versions";
+var DEV_VERSION = "0.0.0-dev";
+function checkRegistryItemCompatibility(item, currentCliVersion = VERSION) {
+  const warnings = [];
+  if (item.deprecated) {
+    warnings.push(`Registry item "${item.name}" is deprecated: ${item.deprecated}`);
+  }
+  const minCliVersion = item.minCliVersion?.trim();
+  if (!minCliVersion || currentCliVersion === DEV_VERSION) {
+    return { warnings };
+  }
+  try {
+    if (compareVersions(currentCliVersion, minCliVersion) >= 0) {
+      return { warnings };
+    }
+  } catch {
+    return {
+      warnings,
+      error: `Registry item "${item.name}" declares invalid minCliVersion "${minCliVersion}".`
+    };
+  }
+  return {
+    warnings,
+    error: `Registry item "${item.name}" requires hyperframes >= ${minCliVersion} (current: ${currentCliVersion}). Run \`npx hyperframes@latest add ${item.name}\` or upgrade your installed hyperframes CLI.`
+  };
+}
+var RegistryCompatibilityError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "RegistryCompatibilityError";
+  }
+};
+function gateRegistryItemsCompatibility(items, currentCliVersion = VERSION) {
+  const warnings = [];
+  for (const item of items) {
+    const result = checkRegistryItemCompatibility(item, currentCliVersion);
+    if (result.error) {
+      throw new RegistryCompatibilityError(result.error);
+    }
+    warnings.push(...result.warnings);
+  }
+  return warnings;
+}
+
+export {
+  RegistryCompatibilityError,
+  gateRegistryItemsCompatibility
+};

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

@@ -0,0 +1,23 @@
+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/browser/gpuPolicy.ts
+function resolveLocalBrowserGpuMode(browserGpuArg, envMode = process.env.PRODUCER_BROWSER_GPU_MODE) {
+  if (browserGpuArg === true) return "hardware";
+  if (browserGpuArg === false) return "software";
+  if (envMode === "hardware" || envMode === "software" || envMode === "auto") return envMode;
+  return "auto";
+}
+async function resolveCaptureBrowserGpuMode(requestedMode, chromePath) {
+  const { resolveBrowserGpuMode } = await import("./src-PVYUYV3M.js");
+  return resolveBrowserGpuMode(requestedMode, { chromePath });
+}
+
+export {
+  resolveLocalBrowserGpuMode,
+  resolveCaptureBrowserGpuMode
+};

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

@@ -0,0 +1,181 @@
+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 {
+  buildNpmCommand
+} from "./chunk-6BEFEWFB.js";
+
+// src/utils/optionalPackages.ts
+import { spawn } from "child_process";
+import { randomUUID } from "crypto";
+import {
+  existsSync,
+  mkdirSync,
+  readdirSync,
+  readFileSync,
+  realpathSync,
+  renameSync,
+  rmSync,
+  statSync,
+  writeFileSync
+} from "fs";
+import { createRequire } from "module";
+import { homedir } from "os";
+import { basename, dirname, join, sep } from "path";
+var OPTIONAL_PACKAGES = {
+  "onnxruntime-node": "1.21.1",
+  "@google/genai": "1.52.0"
+};
+var CACHE_DIR = join(homedir(), ".cache", "hyperframes", "optional");
+function optionalPackageDir(name, cacheDir = CACHE_DIR) {
+  return join(cacheDir, `${name.replace("/", "__")}@${OPTIONAL_PACKAGES[name]}`);
+}
+function installedOptionalPackageVersion(name, cacheDir = CACHE_DIR, cliUrl = import.meta.url) {
+  if (pinnedCopyBesideCli(name, cliUrl)) return OPTIONAL_PACKAGES[name];
+  const dir = optionalPackageDir(name, cacheDir);
+  if (!isInstalled(dir, name)) return null;
+  return JSON.parse(readFileSync(manifestPath(dir, name), "utf-8")).version;
+}
+function loadInstalledOptionalPackage(name, deps = defaultDeps) {
+  const found = deps.loadBesideCli(name) ?? deps.loadInstalled(optionalPackageDir(name, deps.cacheDir), name);
+  return found;
+}
+async function loadOptionalPackage(name, feature, deps = defaultDeps) {
+  const present = loadInstalledOptionalPackage(name, deps);
+  if (present !== null) return present;
+  const dir = optionalPackageDir(name, deps.cacheDir);
+  const version = OPTIONAL_PACKAGES[name];
+  deps.log(`installing ${name} for ${feature}, once`);
+  try {
+    await deps.install(dir, name, version);
+  } catch (err) {
+    const output = err.message.trim();
+    const advice = NETWORK_FAILURE.test(output) ? "Check your network connection, then retry" : "Retry";
+    throw new Error(
+      `${feature} needs ${name}, and installing it failed (${output.split("\n")[0]}). ${advice}, or install it yourself: npm install ${name}@${version} --prefix "${dir}"`
+    );
+  }
+  const loaded = deps.loadInstalled(dir, name);
+  if (loaded === null) {
+    throw new Error(`${name}@${version} installed into ${dir} but could not be loaded.`);
+  }
+  return loaded;
+}
+var NETWORK_FAILURE = /ENOTFOUND|ETIMEDOUT|EAI_AGAIN|ECONNRESET|ECONNREFUSED|network/i;
+function manifestPath(dir, name) {
+  return join(dir, "node_modules", name, "package.json");
+}
+function isInstalled(dir, name) {
+  return existsSync(manifestPath(dir, name));
+}
+function loadInstalled(dir, name) {
+  if (!isInstalled(dir, name)) return null;
+  return createRequire(join(dir, "package.json"))(name);
+}
+function pinnedCopyBesideCli(name, cliUrl) {
+  const req = createRequire(cliUrl);
+  try {
+    const entry = realpathSync(req.resolve(name));
+    const copy = (req.resolve.paths(name) ?? []).map((dir) => join(dir, name)).find((dir) => existsSync(dir) && entry.startsWith(realpathSync(dir) + sep));
+    if (!copy) return false;
+    const manifest = readFileSync(join(copy, "package.json"), "utf-8");
+    return JSON.parse(manifest).version === OPTIONAL_PACKAGES[name];
+  } catch {
+    return false;
+  }
+}
+function loadBesideCli(name, cliUrl = import.meta.url) {
+  return pinnedCopyBesideCli(name, cliUrl) ? createRequire(cliUrl)(name) : null;
+}
+function runNpm(args, signal) {
+  const npm = buildNpmCommand(args);
+  const child = spawn(npm.command, npm.args, { stdio: ["ignore", "pipe", "pipe"], signal });
+  return new Promise((resolve, reject) => {
+    let output = "";
+    child.stdout.on("data", (chunk) => output += chunk);
+    child.stderr.on("data", (chunk) => output += chunk);
+    child.on("error", reject);
+    child.on(
+      "close",
+      (code) => code === 0 ? resolve() : reject(new Error(output || `npm exited with code ${code}`))
+    );
+  });
+}
+function isProcessAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (err) {
+    return err.code !== "ESRCH";
+  }
+}
+var STAGING_PID_TRUSTED_FOR_MS = 6 * 60 * 60 * 1e3;
+function sweepStaleStaging(dir) {
+  const prefix = `${basename(dir)}.tmp-`;
+  const parent = dirname(dir);
+  if (!existsSync(parent)) return;
+  for (const entry of readdirSync(parent)) {
+    if (!entry.startsWith(prefix)) continue;
+    const pid = /^(\d+)(?:-|$)/.exec(entry.slice(prefix.length))?.[1];
+    if (pid === void 0) continue;
+    const stale = join(parent, entry);
+    const age = Date.now() - (statSync(stale, { throwIfNoEntry: false })?.mtimeMs ?? Date.now());
+    if (isProcessAlive(Number(pid)) && age < STAGING_PID_TRUSTED_FOR_MS) continue;
+    try {
+      rmSync(stale, { recursive: true, force: true });
+    } catch (err) {
+      console.error(`could not remove stale install dir ${stale}: ${err.message}`);
+    }
+  }
+}
+async function install(dir, name, version, run = runNpm) {
+  sweepStaleStaging(dir);
+  const staging = `${dir}.tmp-${process.pid}-${randomUUID().slice(0, 8)}`;
+  mkdirSync(staging, { recursive: true });
+  writeFileSync(join(staging, "package.json"), "{}");
+  try {
+    await run([
+      "install",
+      `${name}@${version}`,
+      "--prefix",
+      staging,
+      "--no-audit",
+      "--no-fund",
+      "--loglevel=error",
+      // A first-use install is interactive, not a CI resolve: fail fast and name the
+      // manual command instead of sitting through npm's default multi-minute backoff.
+      "--fetch-retries=0",
+      "--fetch-timeout=20000"
+    ]);
+    if (isInstalled(dir, name)) return;
+    rmSync(dir, { recursive: true, force: true });
+    renameSync(staging, dir);
+  } catch (err) {
+    if (!isInstalled(dir, name)) throw err;
+  } finally {
+    rmSync(staging, { recursive: true, force: true });
+  }
+}
+var defaultDeps = {
+  cacheDir: CACHE_DIR,
+  loadBesideCli: (name) => loadBesideCli(name),
+  loadInstalled,
+  install,
+  log: (line) => console.error(line)
+};
+
+export {
+  OPTIONAL_PACKAGES,
+  CACHE_DIR,
+  installedOptionalPackageVersion,
+  loadInstalledOptionalPackage,
+  loadOptionalPackage,
+  isInstalled,
+  loadInstalled,
+  runNpm,
+  sweepStaleStaging,
+  install
+};

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

@@ -0,0 +1,6 @@
+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);

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

@@ -0,0 +1,6 @@
+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);