@ignix-social/editor 0.1.0

package/vendor/hyperframes/dist/tts-P3LIPIL5.js

@@ -0,0 +1,234 @@
+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 {
+  BUNDLED_VOICES,
+  DEFAULT_VOICE,
+  SUPPORTED_LANGS,
+  inferLangFromVoiceId,
+  isSupportedLang
+} from "./chunk-XZABUQTX.js";
+import {
+  errorBox
+} from "./chunk-IHFUKJOR.js";
+import {
+  ft
+} from "./chunk-WMQNIQDJ.js";
+import "./chunk-X5HWXQPU.js";
+import {
+  c
+} from "./chunk-ZTZA4UWZ.js";
+import {
+  isTextFile
+} from "./chunk-K4WKGXRC.js";
+import {
+  defineCommand
+} from "./chunk-S3S4TGEH.js";
+import {
+  failCommand,
+  failUsage
+} from "./chunk-PBN6GBJE.js";
+import "./chunk-M2WBOQ2Q.js";
+
+// src/commands/tts.ts
+import { readFileSync } from "fs";
+import { resolve } from "path";
+var examples = [
+  ["Generate speech from text", 'hyperframes tts "Welcome to HyperFrames"'],
+  ["Choose a voice", 'hyperframes tts "Hello world" --voice am_adam'],
+  ["Save to a specific file", 'hyperframes tts "Intro" --voice bf_emma --output narration.wav'],
+  ["Adjust speech speed", 'hyperframes tts "Slow and clear" --speed 0.8'],
+  [
+    "Generate Spanish speech",
+    'hyperframes tts "La reuni\xF3n empieza a las nueve" --voice ef_dora --output es.wav'
+  ],
+  [
+    "Override phonemizer language",
+    'hyperframes tts "Ciao a tutti" --voice af_heart --lang it --output accented.wav'
+  ],
+  ["Read text from a file", "hyperframes tts script.txt"],
+  ["List available voices", "hyperframes tts --list"]
+];
+var voiceList = BUNDLED_VOICES.map((v) => `${v.id} (${v.label})`).join(", ");
+var langList = SUPPORTED_LANGS.join(", ");
+var tts_default = defineCommand({
+  meta: {
+    name: "tts",
+    description: "Generate speech audio from text using a local AI model (Kokoro-82M)"
+  },
+  args: {
+    input: {
+      type: "positional",
+      description: "Text to speak, or path to a .txt file",
+      required: false
+    },
+    "text-file": {
+      type: "string",
+      description: "Read text from a .txt file (compatibility alias)"
+    },
+    output: {
+      type: "string",
+      description: "Output file path (default: speech.wav in current directory)",
+      alias: ["o", "out"]
+    },
+    voice: {
+      type: "string",
+      description: `Voice ID (default: ${DEFAULT_VOICE}). Options: ${voiceList}`,
+      alias: "v"
+    },
+    speed: {
+      type: "string",
+      description: "Speech speed multiplier (default: 1.0)",
+      alias: "s"
+    },
+    lang: {
+      type: "string",
+      description: `Phonemizer language (auto-detected from voice prefix when omitted). Options: ${langList}`,
+      alias: "l"
+    },
+    list: {
+      type: "boolean",
+      description: "List available voices and exit",
+      default: false
+    },
+    json: {
+      type: "boolean",
+      description: "Output result as JSON",
+      default: false
+    }
+  },
+  // fallow-ignore-next-line complexity
+  async run({ args }) {
+    if (args["text-file"] && args.input) {
+      console.error(c.error("Pass text to speak or --text-file, not both."));
+      failUsage();
+    }
+    if (args.list) {
+      return listVoices(args.json);
+    }
+    const input = args["text-file"] ?? args.input;
+    if (!input) {
+      console.error(c.error("Provide text to speak, or use --list to see available voices."));
+      failCommand();
+    }
+    let text;
+    if (isTextFile(input)) {
+      text = readFileSync(resolve(input), "utf-8").trim();
+      if (!text) {
+        console.error(c.error("File is empty."));
+        failCommand();
+      }
+    } else {
+      text = input;
+    }
+    if (!text.trim()) {
+      console.error(c.error("No text provided."));
+      failCommand();
+    }
+    const output = resolve(args.output ?? "speech.wav");
+    const voice = args.voice ?? DEFAULT_VOICE;
+    const speed = args.speed ? parseFloat(args.speed) : 1;
+    if (isNaN(speed) || speed <= 0 || speed > 3) {
+      console.error(c.error("Speed must be a number between 0.1 and 3.0"));
+      failCommand();
+    }
+    const inferredLang = inferLangFromVoiceId(voice);
+    let lang = inferredLang;
+    if (args.lang != null) {
+      const requested = String(args.lang).toLowerCase();
+      if (!isSupportedLang(requested)) {
+        errorBox("Invalid --lang", `Got "${args.lang}". Must be one of: ${langList}.`);
+        failCommand();
+      }
+      lang = requested;
+    }
+    if (!args.json && args.lang != null && lang !== inferredLang) {
+      console.log(
+        c.dim(
+          `  Note: voice "${voice}" is ${inferredLang}, rendering with --lang ${lang} instead.`
+        )
+      );
+    }
+    const { synthesize } = await import("./synthesize-K62TIZWI.js");
+    const spin = args.json ? null : ft();
+    spin?.start(`Generating speech with ${c.accent(voice)} (${lang})...`);
+    try {
+      const result = await synthesize(text, output, {
+        voice,
+        speed,
+        lang,
+        onProgress: spin ? (msg) => spin.message(msg) : void 0
+      });
+      if (args.json) {
+        console.log(
+          JSON.stringify({
+            ok: true,
+            voice,
+            speed,
+            lang,
+            langApplied: result.langApplied,
+            durationSeconds: result.durationSeconds,
+            outputPath: result.outputPath
+          })
+        );
+      } else {
+        spin?.stop(
+          c.success(
+            `Generated ${c.accent(result.durationSeconds.toFixed(1) + "s")} of speech \u2192 ${c.accent(result.outputPath)}`
+          )
+        );
+        if (args.lang != null && !result.langApplied) {
+          console.log(
+            c.dim(
+              "  Note: installed kokoro-onnx version does not support the --lang kwarg; phonemization used Kokoro's default."
+            )
+          );
+        }
+      }
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      if (args.json) {
+        console.log(JSON.stringify({ ok: false, error: message }));
+      } else {
+        spin?.stop(c.error(`Speech synthesis failed: ${message}`));
+      }
+      failCommand();
+    }
+  }
+});
+function listVoices(json) {
+  const rows = BUNDLED_VOICES.map((v) => ({ ...v, defaultLang: inferLangFromVoiceId(v.id) }));
+  if (json) {
+    console.log(JSON.stringify(rows));
+    return;
+  }
+  console.log(`
+${c.bold("Available voices")} (Kokoro-82M)
+`);
+  console.log(
+    `  ${c.dim("ID")}                ${c.dim("Name")}         ${c.dim("Language")}   ${c.dim("Lang code")}  ${c.dim("Gender")}`
+  );
+  console.log(`  ${c.dim("\u2500".repeat(72))}`);
+  for (const row of rows) {
+    const id = row.id.padEnd(18);
+    const label = row.label.padEnd(13);
+    const lang = row.language.padEnd(10);
+    const code = row.defaultLang.padEnd(10);
+    console.log(`  ${c.accent(id)} ${label} ${lang} ${code} ${row.gender}`);
+  }
+  console.log(
+    `
+  ${c.dim("Use any Kokoro voice ID \u2014 see https://github.com/thewh1teagle/kokoro-onnx for all 54 voices")}`
+  );
+  console.log(
+    `  ${c.dim("Override phonemizer with --lang <" + SUPPORTED_LANGS.join("|") + ">")}
+`
+  );
+}
+export {
+  tts_default as default,
+  examples
+};

package/vendor/hyperframes/dist/updateCheck-UDWIJ4ZQ.js

@@ -0,0 +1,39 @@
+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 {
+  cachedUpdateCheck,
+  checkForUpdate,
+  getUpdateMeta,
+  isSafeVersion,
+  printDeprecationNotice,
+  printStalePinNotice,
+  printUpdateNotice,
+  updateCheckDisabled,
+  updateCheckDue,
+  updateNoticesSuppressed,
+  withMeta
+} from "./chunk-HW6OYASV.js";
+import "./chunk-K4WIOZFP.js";
+import "./chunk-XUXGIA7H.js";
+import "./chunk-WERLJGIC.js";
+import "./chunk-ISN5GRYI.js";
+import "./chunk-FLWXXDNS.js";
+import "./chunk-KNU5COPB.js";
+import "./chunk-M2WBOQ2Q.js";
+export {
+  cachedUpdateCheck,
+  checkForUpdate,
+  getUpdateMeta,
+  isSafeVersion,
+  printDeprecationNotice,
+  printStalePinNotice,
+  printUpdateNotice,
+  updateCheckDisabled,
+  updateCheckDue,
+  updateNoticesSuppressed,
+  withMeta
+};

package/vendor/hyperframes/dist/upgrade-CT3CPO3E.js

@@ -0,0 +1,231 @@
+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 {
+  ft,
+  ge,
+  q,
+  ue,
+  ye
+} from "./chunk-WMQNIQDJ.js";
+import {
+  c
+} from "./chunk-ZTZA4UWZ.js";
+import {
+  defineCommand
+} from "./chunk-S3S4TGEH.js";
+import {
+  setCommandExitCode
+} from "./chunk-PBN6GBJE.js";
+import {
+  checkForUpdate,
+  detectInstaller,
+  installInvocation,
+  isSafeVersion,
+  rewritePinnedHyperframesText,
+  rewriteProjectPinnedScripts,
+  withMeta
+} from "./chunk-HW6OYASV.js";
+import "./chunk-K4WIOZFP.js";
+import "./chunk-XUXGIA7H.js";
+import "./chunk-WERLJGIC.js";
+import "./chunk-ISN5GRYI.js";
+import {
+  VERSION
+} from "./chunk-FLWXXDNS.js";
+import "./chunk-KNU5COPB.js";
+import "./chunk-M2WBOQ2Q.js";
+
+// src/commands/upgrade.ts
+import { execFileSync } from "child_process";
+import { existsSync, readFileSync, writeFileSync, renameSync, readdirSync } from "fs";
+import { resolve } from "path";
+var examples = [
+  ["Check for updates interactively", "hyperframes upgrade"],
+  ["Check for updates without prompting", "hyperframes upgrade --check"],
+  ["Upgrade non-interactively", "hyperframes upgrade --yes"],
+  ["Bump a project's pinned CLI scripts", "hyperframes upgrade --project"]
+];
+var upgrade_default = defineCommand({
+  meta: { name: "upgrade", description: "Check for updates and show upgrade instructions" },
+  args: {
+    yes: { type: "boolean", alias: "y", description: "Show upgrade commands without prompting" },
+    check: { type: "boolean", description: "Check for updates and exit (no prompt)" },
+    json: { type: "boolean", description: "Output as JSON", default: false },
+    project: {
+      type: "string",
+      description: "Bump this project's package.json hyperframes@<version> script pins to latest (default: current dir)"
+    }
+  },
+  // fallow-ignore-next-line complexity
+  async run({ args }) {
+    const useJson = args.json === true;
+    const checkOnly = args.check === true;
+    if (args.project !== void 0) {
+      const p = resolveProjectArgs(args.project, { check: checkOnly, json: useJson });
+      const res = await upgradeProjectPins(resolve(p.dir), { json: p.json, check: p.check });
+      if (p.json) {
+        console.log(JSON.stringify(withMeta(res), null, 2));
+        return;
+      }
+      printProjectPinResult(res, p.check);
+      return;
+    }
+    if (useJson) {
+      const result2 = await checkForUpdate(true);
+      console.log(JSON.stringify(withMeta(result2), null, 2));
+      return;
+    }
+    const autoYes = args.yes === true;
+    ge(c.bold("hyperframes upgrade"));
+    const s = ft();
+    s.start("Checking for updates...");
+    const result = await checkForUpdate(true);
+    if (result.latest === result.current) {
+      s.stop(c.success("Already up to date"));
+      ye(`${c.success("\u25C7")}  ${c.bold("v" + VERSION)}`);
+      return;
+    }
+    s.stop("Update available");
+    console.log();
+    console.log(`   ${c.dim("Current:")}  ${c.bold("v" + result.current)}`);
+    console.log(`   ${c.dim("Latest:")}   ${c.bold(c.accent("v" + result.latest))}`);
+    console.log();
+    if (checkOnly) {
+      ye(c.accent("Update available: v" + result.latest));
+      return;
+    }
+    if (!autoYes && !await confirmUpgrade()) {
+      ye(c.dim("Skipped."));
+      return;
+    }
+    applyUpgrade(result, autoYes);
+  }
+});
+async function confirmUpgrade() {
+  const shouldUpgrade = await ue({ message: "Upgrade now?" });
+  return !q(shouldUpgrade) && shouldUpgrade === true;
+}
+function applyUpgrade(result, autoYes) {
+  if (!isSafeVersion(result.latest)) {
+    ye(c.dim("Refusing to install: unexpected version string from npm registry."));
+    setCommandExitCode(1);
+    return;
+  }
+  const installer = detectInstaller();
+  const invocation = installInvocation(installer.kind, result.latest);
+  const displayCmd = installer.installCommand(result.latest);
+  const npxFallback = `npx hyperframes@${result.latest}`;
+  if (!invocation || !displayCmd) {
+    printNpxFallback(installer.reason, npxFallback, autoYes);
+    return;
+  }
+  if (!autoYes) {
+    printManualCommands(displayCmd, npxFallback);
+    return;
+  }
+  runDetectedInstall(invocation, displayCmd, result.latest);
+}
+function printNpxFallback(reason, npxFallback, autoYes) {
+  console.log();
+  if (autoYes) {
+    console.log(
+      `   ${c.dim("Couldn't detect a global install to upgrade")} ${c.dim("(" + reason + ")")}`
+    );
+  }
+  console.log(`   ${c.accent(npxFallback)}`);
+  console.log();
+  ye(c.success("Run the command above to use the latest version."));
+}
+function printManualCommands(displayCmd, npxFallback) {
+  console.log();
+  console.log(`   ${c.accent(displayCmd)}`);
+  console.log(`   ${c.dim("or")}`);
+  console.log(`   ${c.accent(npxFallback)}`);
+  console.log();
+  ye(c.success("Run one of the commands above to upgrade."));
+}
+function resolveProjectArgs(project, opts) {
+  if (typeof project !== "string" || project.length === 0) {
+    return { dir: ".", check: opts.check, json: opts.json };
+  }
+  if (project.startsWith("-")) {
+    return {
+      dir: ".",
+      check: opts.check || project === "--check",
+      json: opts.json || project === "--json"
+    };
+  }
+  return { dir: project, check: opts.check, json: opts.json };
+}
+async function upgradeProjectPins(dir, opts) {
+  const pkgPath = resolve(dir, "package.json");
+  if (!existsSync(pkgPath)) {
+    return { changed: false, from: [], to: "", path: pkgPath };
+  }
+  const raw = JSON.parse(readFileSync(pkgPath, "utf-8"));
+  const scripts = raw.scripts ?? {};
+  const { latest } = await checkForUpdate(true);
+  if (!isSafeVersion(latest)) return { changed: false, from: [], to: latest, path: pkgPath };
+  const rewrite = rewriteProjectPinnedScripts(scripts, latest);
+  const wrapperRewrites = readdirSync(dir, { withFileTypes: true }).filter((entry) => entry.isFile() && entry.name.endsWith(".sh")).map((entry) => {
+    const path = resolve(dir, entry.name);
+    return { path, rewrite: rewritePinnedHyperframesText(readFileSync(path, "utf-8"), latest) };
+  });
+  if (rewrite.changed && !opts.check) {
+    raw.scripts = rewrite.scripts;
+    const tmp = `${pkgPath}.tmp`;
+    writeFileSync(tmp, `${JSON.stringify(raw, null, 2)}
+`, "utf-8");
+    renameSync(tmp, pkgPath);
+  }
+  if (!opts.check) {
+    for (const wrapper of wrapperRewrites) {
+      if (wrapper.rewrite.changed) writeFileSync(wrapper.path, wrapper.rewrite.text, "utf-8");
+    }
+  }
+  const from = new Set(rewrite.fromVersions);
+  for (const wrapper of wrapperRewrites) {
+    for (const version of wrapper.rewrite.fromVersions) from.add(version);
+  }
+  return { changed: from.size > 0, from: [...from].sort(), to: latest, path: pkgPath };
+}
+function printProjectPinResult(res, checkOnly) {
+  if (!existsSync(res.path)) {
+    console.log(`   ${c.dim("No package.json found \u2014 nothing to upgrade.")}`);
+    return;
+  }
+  if (!res.changed) {
+    console.log(`   ${c.success("\u25C7")}  Project pins already on hyperframes@${res.to}`);
+    return;
+  }
+  const verb = checkOnly ? "would bump" : "bumped";
+  console.log(
+    `   ${c.success("\u25C7")}  ${verb} project pins ${res.from.join(", ")} \u2192 ${c.accent(res.to)}`
+  );
+  if (checkOnly)
+    console.log(`   ${c.dim("Run `npx hyperframes@latest upgrade --project` to apply.")}`);
+}
+function runDetectedInstall(invocation, displayCmd, version) {
+  console.log();
+  console.log(`   ${c.dim("Running:")} ${c.accent(displayCmd)}`);
+  console.log();
+  try {
+    execFileSync(invocation.bin, invocation.args, { stdio: "inherit", shell: false });
+    ye(c.success(`Upgraded to v${version}`));
+  } catch {
+    ye(c.dim("Install failed. Try running manually:"));
+    console.log(`   ${c.accent(displayCmd)}`);
+    setCommandExitCode(1);
+  }
+}
+export {
+  upgrade_default as default,
+  examples,
+  resolveProjectArgs,
+  runDetectedInstall,
+  upgradeProjectPins
+};

package/vendor/hyperframes/dist/urlDownloader-H6WRI2UE.js

@@ -0,0 +1,39 @@
+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 "./chunk-BZ56MTDX.js";
+import {
+  downloadToTemp,
+  fetchPublicHttpsText,
+  isHttpUrl,
+  safeDownloadUrlIdentity,
+  writeUrlDownloadTelemetry
+} from "./chunk-K2FTXJYH.js";
+import "./chunk-2YN64IN5.js";
+import "./chunk-AVUUN2XD.js";
+import "./chunk-DPVXBVLL.js";
+import "./chunk-Z6B37SNM.js";
+import "./chunk-HWKCIWQT.js";
+import "./chunk-VC76R6W2.js";
+import "./chunk-OFQWTKPW.js";
+import "./chunk-TWWSYAKJ.js";
+import "./chunk-ZJUKFZ2P.js";
+import "./chunk-HBBJFK6I.js";
+import "./chunk-PJ3HDUCY.js";
+import "./chunk-TQFG7HTI.js";
+import "./chunk-GK4AIFIH.js";
+import "./chunk-2PSPARWP.js";
+import "./chunk-3GXQPCJC.js";
+import "./chunk-RQVDTPGD.js";
+import "./chunk-PMRBLBUP.js";
+import "./chunk-M2WBOQ2Q.js";
+export {
+  downloadToTemp,
+  fetchPublicHttpsText,
+  isHttpUrl,
+  safeDownloadUrlIdentity,
+  writeUrlDownloadTelemetry
+};