@rohal12/twee-ts 1.1.1

package/dist/bin/twee-ts.js

@@ -0,0 +1,2247 @@
+#!/usr/bin/env node
+
+// bin/twee-ts.ts
+import { parseArgs } from "util";
+import { writeFileSync as writeFileSync3, mkdirSync as mkdirSync2, existsSync as existsSync3 } from "fs";
+import { join as join6 } from "path";
+
+// src/compiler.ts
+import { writeFileSync as writeFileSync2 } from "fs";
+
+// src/ifid.ts
+import { randomUUID } from "crypto";
+function generateIFID() {
+  return randomUUID().toUpperCase();
+}
+function validateIFID(ifid) {
+  let uuid = ifid;
+  switch (ifid.length) {
+    case 36:
+      break;
+    case 45: {
+      if (ifid.slice(0, 7).toUpperCase() !== "UUID://" || ifid.slice(43) !== "//") {
+        return "invalid IFID UUID://...// format";
+      }
+      uuid = ifid.slice(7, 43);
+      break;
+    }
+    default:
+      return `invalid IFID length: ${ifid.length}`;
+  }
+  for (let i = 0; i < uuid.length; i++) {
+    const ch = uuid[i];
+    switch (i) {
+      case 8:
+      case 13:
+      case 18:
+      case 23:
+        if (ch !== "-") {
+          return `invalid IFID character '${ch}' at position ${i + 1}`;
+        }
+        break;
+      case 14:
+        if (ch < "1" || ch > "5") {
+          return `invalid version '${ch}' at position ${i + 1}`;
+        }
+        break;
+      case 19:
+        if (!["8", "9", "a", "A", "b", "B"].includes(ch)) {
+          return `invalid variant '${ch}' at position ${i + 1}`;
+        }
+        break;
+      default:
+        if (!/^[0-9a-fA-F]$/.test(ch)) {
+          return `invalid IFID hex value '${ch}' at position ${i + 1}`;
+        }
+        break;
+    }
+  }
+  return null;
+}
+
+// src/escape.ts
+function attrEscape(s) {
+  if (s.length === 0) return s;
+  return s.replace(/&/g, "&amp;").replace(/"/g, "&quot;").replace(/'/g, "&#39;");
+}
+function htmlEscape(s) {
+  if (s.length === 0) return s;
+  return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#39;");
+}
+function tiddlerEscape(s) {
+  if (s.length === 0) return s;
+  return s.replace(/\\/g, "\\s").replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/\t/g, "\\t").replace(/\n/g, "\\n");
+}
+function tweeEscape(s) {
+  if (s.length === 0) return s;
+  return s.replace(/[\\[\]{}]/g, (ch) => "\\" + ch);
+}
+function tweeUnescape(s) {
+  if (s.length === 0) return s;
+  let result = "";
+  for (let i = 0; i < s.length; i++) {
+    if (s[i] === "\\") {
+      i++;
+      if (i >= s.length) break;
+    }
+    result += s[i];
+  }
+  return result;
+}
+
+// src/passage.ts
+var INFO_PASSAGE_NAMES = /* @__PURE__ */ new Set([
+  "StoryAuthor",
+  "StoryInit",
+  "StoryMenu",
+  "StorySubtitle",
+  "StoryTitle",
+  "PassageReady",
+  "PassageDone",
+  "PassageHeader",
+  "PassageFooter",
+  "StoryBanner",
+  "StoryCaption",
+  "MenuOptions",
+  "MenuShare",
+  "MenuStory",
+  "StoryInterface",
+  "StoryShare",
+  "StorySettings",
+  "StoryData",
+  "StoryIncludes"
+]);
+var INFO_TAGS = ["annotation", "script", "stylesheet", "widget"];
+function hasTag(p, tag) {
+  return p.tags.includes(tag);
+}
+function hasAnyTag(p, ...tags) {
+  return p.tags.some((t) => tags.includes(t));
+}
+function hasTagStartingWith(p, prefix) {
+  return p.tags.some((t) => t.startsWith(prefix));
+}
+function hasInfoTags(p) {
+  return hasAnyTag(p, ...INFO_TAGS) || hasTagStartingWith(p, "Twine.");
+}
+function hasInfoName(p) {
+  return INFO_PASSAGE_NAMES.has(p.name);
+}
+function isStoryPassage(p) {
+  return !hasInfoName(p) && !hasInfoTags(p);
+}
+function hasMetadataPosition(p) {
+  return p.metadata != null && p.metadata.position != null && p.metadata.position !== "";
+}
+function hasMetadataSize(p) {
+  return p.metadata != null && p.metadata.size != null && p.metadata.size !== "";
+}
+function hasAnyMetadata(p) {
+  return hasMetadataPosition(p) || hasMetadataSize(p);
+}
+function marshalMetadata(meta) {
+  const obj = {};
+  if (meta.position) obj.position = meta.position;
+  if (meta.size) obj.size = meta.size;
+  return JSON.stringify(obj);
+}
+function passageToTwee(p, outMode) {
+  let output;
+  if (outMode === "twee3") {
+    output = ":: " + tweeEscape(p.name);
+    if (p.tags.length > 0) {
+      output += " [" + tweeEscape(p.tags.join(" ")) + "]";
+    }
+    if (hasAnyMetadata(p) && p.metadata) {
+      output += " " + marshalMetadata(p.metadata);
+    }
+  } else {
+    output = ":: " + p.name;
+    if (p.tags.length > 0) {
+      output += " [" + p.tags.join(" ") + "]";
+    }
+  }
+  output += "\n";
+  if (p.text.length > 0) {
+    output += p.text + "\n";
+  }
+  output += "\n\n";
+  return output;
+}
+function passageToPassagedata(p, pid) {
+  let position;
+  let size;
+  if (hasMetadataPosition(p)) {
+    position = p.metadata.position;
+  } else {
+    const x = pid % 10;
+    let y = Math.floor(pid / 10);
+    const xp = x === 0 ? 10 : x;
+    const yp = x === 0 ? y : y + 1;
+    position = `${xp * 125 - 25},${yp * 125 - 25}`;
+  }
+  if (hasMetadataSize(p)) {
+    size = p.metadata.size;
+  } else {
+    size = "100,100";
+  }
+  return `<tw-passagedata pid="${pid}" name=${quote(attrEscape(p.name))} tags=${quote(attrEscape(p.tags.join(" ")))} position=${quote(attrEscape(position))} size=${quote(attrEscape(size))}>${htmlEscape(p.text)}</tw-passagedata>`;
+}
+function passageToTiddler(p, pid) {
+  let position;
+  if (hasMetadataPosition(p)) {
+    position = p.metadata.position;
+  } else {
+    const x = pid % 10;
+    let y = Math.floor(pid / 10);
+    const xp = x === 0 ? 10 : x;
+    const yp = x === 0 ? y : y + 1;
+    position = `${xp * 140 - 130},${yp * 140 - 130}`;
+  }
+  return `<div tiddler=${quote(attrEscape(p.name))} tags=${quote(attrEscape(p.tags.join(" ")))} twine-position=${quote(attrEscape(position))}>${tiddlerEscape(p.text)}</div>`;
+}
+function countWords(p) {
+  let text = p.text;
+  text = text.replace(/\n/g, "");
+  text = text.replace(/(?:\/%.+?%\/|\/\*.+?\*\/|<!--.+?-->)/gs, "");
+  const normalized = text.normalize("NFKD");
+  const count = [...normalized].length;
+  if (count === 0) return 0;
+  const words = Math.floor(count / 5);
+  return count % 5 > 0 ? words + 1 : words;
+}
+function applyTagAliases(passages, aliases) {
+  const entries = Object.entries(aliases);
+  if (entries.length === 0) return;
+  for (const p of passages) {
+    const original = [...p.tags];
+    for (const [alias, canonical] of entries) {
+      if (original.includes(alias) && !p.tags.includes(canonical)) {
+        p.tags.push(canonical);
+      }
+    }
+  }
+}
+function quote(s) {
+  return `"${s}"`;
+}
+
+// src/story.ts
+function createStory() {
+  return {
+    name: "",
+    ifid: "",
+    passages: [],
+    legacyIFID: "",
+    twine1: { settings: /* @__PURE__ */ new Map() },
+    twine2: {
+      format: "",
+      formatVersion: "",
+      options: /* @__PURE__ */ new Map(),
+      start: "",
+      tagColors: /* @__PURE__ */ new Map(),
+      zoom: 1
+    }
+  };
+}
+function storyHas(story, name) {
+  return story.passages.some((p) => p.name === name);
+}
+function storyIndex(story, name) {
+  return story.passages.findIndex((p) => p.name === name);
+}
+function storyAppend(story, p, diagnostics) {
+  const i = storyIndex(story, p.name);
+  if (i === -1) {
+    story.passages.push(p);
+  } else {
+    diagnostics.push({
+      level: "warning",
+      message: `Replacing existing passage "${p.name}" with duplicate.`
+    });
+    story.passages[i] = p;
+  }
+}
+function storyPrepend(story, p, diagnostics) {
+  const i = storyIndex(story, p.name);
+  if (i === -1) {
+    story.passages.unshift(p);
+  } else {
+    diagnostics.push({
+      level: "warning",
+      message: `Replacing existing passage "${p.name}" with duplicate.`
+    });
+    story.passages[i] = p;
+  }
+}
+function marshalStoryData(story) {
+  const data = {};
+  if (story.ifid) data.ifid = story.ifid;
+  if (story.twine2.format) data.format = story.twine2.format;
+  if (story.twine2.formatVersion) data["format-version"] = story.twine2.formatVersion;
+  const options = [];
+  for (const [opt, val] of story.twine2.options) {
+    if (val) options.push(opt);
+  }
+  if (options.length > 0) data.options = options;
+  if (story.twine2.start) data.start = story.twine2.start;
+  if (story.twine2.tagColors.size > 0) {
+    data["tag-colors"] = Object.fromEntries(story.twine2.tagColors);
+  }
+  if (story.twine2.zoom !== 1) data.zoom = story.twine2.zoom;
+  return JSON.stringify(data, null, "	");
+}
+function unmarshalStoryData(story, json) {
+  let data;
+  try {
+    data = JSON.parse(json);
+  } catch (e) {
+    return `Cannot unmarshal "StoryData"; ${e instanceof Error ? e.message : String(e)}`;
+  }
+  if (data.ifid) story.ifid = data.ifid.toUpperCase();
+  if (data.format) story.twine2.format = data.format;
+  if (data["format-version"]) story.twine2.formatVersion = data["format-version"];
+  if (data.options) {
+    for (const opt of data.options) {
+      story.twine2.options.set(opt, true);
+    }
+  }
+  if (data.start) story.twine2.start = data.start;
+  if (data["tag-colors"]) {
+    for (const [tag, color] of Object.entries(data["tag-colors"])) {
+      story.twine2.tagColors.set(tag, color);
+    }
+  }
+  if (data.zoom != null && data.zoom !== 0) story.twine2.zoom = data.zoom;
+  return null;
+}
+function unmarshalStorySettings(story, text, diagnostics) {
+  const obsolete = [];
+  for (const rawLine of text.split("\n")) {
+    const line = rawLine.trim();
+    if (line.length === 0) continue;
+    const colonIdx = line.indexOf(":");
+    if (colonIdx === -1) {
+      diagnostics.push({
+        level: "warning",
+        message: `Malformed "StorySettings" entry; skipping "${line}".`
+      });
+      continue;
+    }
+    const key = line.slice(0, colonIdx).trim().toLowerCase();
+    const val = line.slice(colonIdx + 1).trim().toLowerCase();
+    switch (key) {
+      case "ifid": {
+        const err = validateIFID(val);
+        if (err === null) {
+          story.legacyIFID = val.toUpperCase();
+        }
+        obsolete.push('"ifid"');
+        continue;
+      }
+      case "zoom":
+        obsolete.push('"zoom"');
+        continue;
+    }
+    story.twine1.settings.set(key, val);
+  }
+  if (obsolete.length > 0) {
+    const entries = obsolete.length === 1 ? "entry" : "entries";
+    const pronoun = obsolete.length === 1 ? "it" : "them";
+    diagnostics.push({
+      level: "warning",
+      message: `Detected obsolete "StorySettings" ${entries}: ${obsolete.join(", ")}. Please remove ${pronoun} from the "StorySettings" special passage.`
+    });
+  }
+}
+function storyAdd(story, p, diagnostics) {
+  switch (p.name) {
+    case "StoryIncludes":
+      diagnostics.push({
+        level: "warning",
+        message: 'Ignoring "StoryIncludes" compiler special passage; twee-ts allows you to specify project files and/or directories to recursively search.'
+      });
+      break;
+    case "StoryData": {
+      const err = unmarshalStoryData(story, p.text);
+      if (err === null) {
+        if (story.ifid.length > 0) {
+          const vErr = validateIFID(story.ifid);
+          if (vErr !== null) {
+            diagnostics.push({
+              level: "error",
+              message: `Cannot validate IFID; ${vErr}.`
+            });
+          }
+        }
+        p.text = marshalStoryData(story);
+      } else {
+        diagnostics.push({
+          level: "error",
+          message: `Cannot unmarshal "StoryData" compiler special passage; ${err}.`
+        });
+      }
+      break;
+    }
+    case "StorySettings":
+      unmarshalStorySettings(story, p.text, diagnostics);
+      break;
+    case "StoryTitle":
+      p.text = p.text.trim();
+      story.name = p.text;
+      break;
+  }
+  storyAppend(story, p, diagnostics);
+}
+function getStoryStats(story) {
+  let storyPassages = 0;
+  let words = 0;
+  for (const p of story.passages) {
+    if (isStoryPassage(p)) {
+      storyPassages++;
+      words += countWords(p);
+    }
+  }
+  return { passages: story.passages.length, storyPassages, words };
+}
+
+// src/filesystem.ts
+import { readdirSync, statSync, watch as fsWatch } from "fs";
+import { resolve, relative, join } from "path";
+
+// src/media-types.ts
+import { extname } from "path";
+var MEDIA_TYPE_MAP = {
+  // Audio
+  aac: "audio/aac",
+  flac: "audio/flac",
+  ogg: "audio/ogg",
+  wav: "audio/wav",
+  mp3: "audio/mpeg",
+  m4a: "audio/mp4",
+  oga: "audio/ogg",
+  opus: "audio/ogg",
+  wave: "audio/wav",
+  weba: "audio/webm",
+  // Fonts
+  otf: "font/otf",
+  ttf: "font/ttf",
+  woff: "font/woff",
+  woff2: "font/woff2",
+  // Images
+  gif: "image/gif",
+  jpeg: "image/jpeg",
+  jpg: "image/jpeg",
+  png: "image/png",
+  svg: "image/svg+xml",
+  tif: "image/tiff",
+  tiff: "image/tiff",
+  webp: "image/webp",
+  // Metadata
+  vtt: "text/vtt",
+  // Video
+  mp4: "video/mp4",
+  ogv: "video/ogg",
+  webm: "video/webm"
+};
+function mediaTypeFromExt(ext) {
+  return MEDIA_TYPE_MAP[ext] ?? "";
+}
+function mediaTypeFromFilename(filename) {
+  return mediaTypeFromExt(normalizedFileExt(filename));
+}
+function normalizedFileExt(filename) {
+  const ext = extname(filename);
+  if (!ext) return "";
+  return ext.slice(1).toLowerCase();
+}
+function slugify(original) {
+  return original.replace(/[\x00-\x20!-/:-@[-^`{-\x9f]+/g, "_");
+}
+function isKnownFileType(filename) {
+  const ext = normalizedFileExt(filename);
+  return KNOWN_EXTENSIONS.has(ext);
+}
+var KNOWN_EXTENSIONS = /* @__PURE__ */ new Set([
+  "tw",
+  "twee",
+  "tw2",
+  "twee2",
+  "htm",
+  "html",
+  "css",
+  "js",
+  "otf",
+  "ttf",
+  "woff",
+  "woff2",
+  "gif",
+  "jpeg",
+  "jpg",
+  "png",
+  "svg",
+  "tif",
+  "tiff",
+  "webp",
+  "aac",
+  "flac",
+  "m4a",
+  "mp3",
+  "oga",
+  "ogg",
+  "opus",
+  "wav",
+  "wave",
+  "weba",
+  "mp4",
+  "ogv",
+  "webm",
+  "vtt"
+]);
+function fontFormatHint(ext) {
+  switch (ext) {
+    case "ttf":
+      return "truetype";
+    case "otf":
+      return "opentype";
+    default:
+      return ext;
+  }
+}
+
+// src/filesystem.ts
+function getFilenames(pathnames, outFilename) {
+  const filenames = [];
+  const absOutFile = outFilename ? resolve(outFilename) : "";
+  function walk(pathname) {
+    let stat;
+    try {
+      stat = statSync(pathname);
+    } catch {
+      return;
+    }
+    if (stat.isFile()) {
+      const abs = resolve(pathname);
+      if (abs === absOutFile) return;
+      const rel = relative(process.cwd(), abs);
+      filenames.push(rel || abs);
+    } else if (stat.isDirectory()) {
+      let entries;
+      try {
+        entries = readdirSync(pathname);
+      } catch {
+        return;
+      }
+      for (const entry of entries) {
+        walk(join(pathname, entry));
+      }
+    }
+  }
+  for (const pathname of pathnames) {
+    walk(pathname);
+  }
+  return filenames;
+}
+function watchFilesystem(pathnames, outFilename, callback) {
+  const absOutFile = resolve(outFilename);
+  const watchers = [];
+  let buildTimer = null;
+  const BUILD_DEBOUNCE = 500;
+  function scheduleBuild() {
+    if (buildTimer) clearTimeout(buildTimer);
+    buildTimer = setTimeout(() => {
+      buildTimer = null;
+      callback();
+    }, BUILD_DEBOUNCE);
+  }
+  for (const pathname of pathnames) {
+    try {
+      const watcher = fsWatch(pathname, { recursive: true }, (_event, filename) => {
+        if (!filename) return;
+        const abs = resolve(pathname, filename);
+        if (abs === absOutFile) return;
+        if (isKnownFileType(filename)) {
+          scheduleBuild();
+        }
+      });
+      watchers.push(watcher);
+    } catch {
+    }
+  }
+  callback();
+  return {
+    close() {
+      if (buildTimer) clearTimeout(buildTimer);
+      for (const w of watchers) w.close();
+    }
+  };
+}
+
+// src/formats.ts
+import { readFileSync, readdirSync as readdirSync2, statSync as statSync2 } from "fs";
+import { join as join2 } from "path";
+import { homedir } from "os";
+function parseFormatJSON(source, formatId) {
+  const first = source.indexOf("{");
+  const last = source.lastIndexOf("}");
+  if (first === -1 || last === -1) return null;
+  let chunk = source.slice(first, last + 1);
+  try {
+    return JSON.parse(chunk);
+  } catch {
+    if (formatId.toLowerCase().startsWith("harlowe")) {
+      const setupIdx = chunk.lastIndexOf(',"setup": function');
+      if (setupIdx !== -1) {
+        chunk = chunk.slice(0, setupIdx) + "}";
+        try {
+          return JSON.parse(chunk);
+        } catch {
+        }
+      }
+    }
+    return null;
+  }
+}
+function readUTF8(filename) {
+  let content = readFileSync(filename, "utf-8");
+  if (content.charCodeAt(0) === 65279) content = content.slice(1);
+  content = content.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+  return content;
+}
+function discoverFormats(searchDirs) {
+  const formats = /* @__PURE__ */ new Map();
+  const baseFilenames = ["format.js", "header.html"];
+  for (const searchDir of searchDirs) {
+    try {
+      const stat = statSync2(searchDir);
+      if (!stat.isDirectory()) continue;
+    } catch {
+      continue;
+    }
+    let entries;
+    try {
+      entries = readdirSync2(searchDir);
+    } catch {
+      continue;
+    }
+    for (const entry of entries) {
+      const formatDir = join2(searchDir, entry);
+      try {
+        if (!statSync2(formatDir).isDirectory()) continue;
+      } catch {
+        continue;
+      }
+      for (const baseFilename of baseFilenames) {
+        const formatFilename = join2(formatDir, baseFilename);
+        try {
+          const stat = statSync2(formatFilename);
+          if (!stat.isFile()) continue;
+        } catch {
+          continue;
+        }
+        const isTwine2 = baseFilename === "format.js";
+        const format = {
+          id: entry,
+          filename: formatFilename,
+          isTwine2,
+          name: "",
+          version: "",
+          proofing: false
+        };
+        if (isTwine2) {
+          try {
+            const source = readUTF8(formatFilename);
+            const data = parseFormatJSON(source, entry);
+            if (!data) continue;
+            format.name = data.name;
+            format.version = data.version;
+            format.proofing = data.proofing ?? false;
+          } catch {
+            continue;
+          }
+        }
+        formats.set(entry, format);
+        break;
+      }
+    }
+  }
+  return formats;
+}
+function getFormatSearchDirs(extraPaths = [], useTweegoPath = true) {
+  const subdirNames = ["storyformats", ".storyformats", "story-formats", "storyFormats", "targets"];
+  const basePaths = /* @__PURE__ */ new Set();
+  try {
+    basePaths.add(homedir());
+  } catch {
+  }
+  basePaths.add(process.cwd());
+  const dirs = [];
+  for (const base of basePaths) {
+    for (const sub of subdirNames) {
+      const dir = join2(base, sub);
+      try {
+        if (statSync2(dir).isDirectory()) {
+          dirs.push(dir);
+        }
+      } catch {
+      }
+    }
+  }
+  dirs.push(...extraPaths);
+  if (useTweegoPath) {
+    const tweegoPath = process.env.TWEEGO_PATH;
+    if (tweegoPath) {
+      dirs.push(...tweegoPath.split(process.platform === "win32" ? ";" : ":"));
+    }
+  }
+  return dirs;
+}
+function parseSemver(v) {
+  const m = /^(\d+)\.(\d+)\.(\d+)/.exec(v);
+  if (!m) return null;
+  return [Number(m[1]), Number(m[2]), Number(m[3])];
+}
+function semverCompare(a, b) {
+  for (let i = 0; i < 3; i++) {
+    if (a[i] !== b[i]) return a[i] - b[i];
+  }
+  return 0;
+}
+function getFormatIdByNameAndVersion(formats, name, version) {
+  const wanted = parseSemver(version);
+  let bestVersion = null;
+  let bestId;
+  for (const [id, f] of formats) {
+    if (!f.isTwine2 || f.name !== name) continue;
+    const have = parseSemver(f.version);
+    if (!have) continue;
+    if (wanted === null || have[0] === wanted[0] && semverCompare(have, wanted) >= 0) {
+      if (!bestVersion || semverCompare(have, bestVersion) > 0) {
+        bestVersion = have;
+        bestId = id;
+      }
+    }
+  }
+  return bestId;
+}
+function readFormatSource(format) {
+  const source = readUTF8(format.filename);
+  if (format.isTwine2) {
+    const data = parseFormatJSON(source, format.id);
+    if (!data) throw new Error(`Cannot parse format ${format.id} JSON`);
+    return data.source;
+  }
+  return source;
+}
+
+// src/loader.ts
+import { readFileSync as readFileSync2 } from "fs";
+import { basename } from "path";
+
+// src/lexer.ts
+var EOF = -1;
+var HEADER_DELIM = "::";
+var NEWLINE_HEADER_DELIM = "\n::";
+var LexerContext = class {
+  input;
+  line = 1;
+  start = 0;
+  pos = 0;
+  items = [];
+  constructor(input) {
+    this.input = input;
+  }
+  next() {
+    if (this.pos >= this.input.length) return EOF;
+    const ch = this.input.charCodeAt(this.pos);
+    this.pos++;
+    if (ch === 10) this.line++;
+    return ch;
+  }
+  peek() {
+    if (this.pos >= this.input.length) return EOF;
+    return this.input.charCodeAt(this.pos);
+  }
+  backup() {
+    if (this.pos > this.start) {
+      this.pos--;
+      if (this.input.charCodeAt(this.pos) === 10) this.line--;
+    } else {
+      throw new Error("backup would leave pos < start");
+    }
+  }
+  emit(type) {
+    const val = this.input.slice(this.start, this.pos);
+    this.items.push({ type, line: this.line, pos: this.start, val });
+    if (type === 6 /* Content */) {
+      for (let i = this.start; i < this.pos; i++) {
+        if (this.input.charCodeAt(i) === 10) this.line++;
+      }
+    }
+    this.start = this.pos;
+  }
+  ignore() {
+    for (let i = this.start; i < this.pos; i++) {
+      if (this.input.charCodeAt(i) === 10) this.line++;
+    }
+    this.start = this.pos;
+  }
+  acceptRun(valid) {
+    let ch;
+    for (ch = this.next(); ch !== EOF && valid.includes(String.fromCharCode(ch)); ch = this.next()) {
+    }
+    if (ch !== EOF) this.backup();
+  }
+  errorf(message) {
+    this.items.push({
+      type: 0 /* Error */,
+      line: this.line,
+      pos: this.start,
+      val: message
+    });
+    return null;
+  }
+  /** Drain all pending items and return them. */
+  drainItems() {
+    const result = this.items;
+    this.items = [];
+    return result;
+  }
+};
+function acceptQuoted(ctx, quote2) {
+  for (; ; ) {
+    const ch = ctx.next();
+    switch (ch) {
+      case 92: {
+        const r = ctx.next();
+        if (r !== 10 && r !== EOF) break;
+      }
+      // falls through
+      case 10:
+      case EOF:
+        return "unterminated quoted string";
+      default:
+        if (ch === quote2) return null;
+        break;
+    }
+  }
+}
+function lexProlog(ctx) {
+  if (ctx.input.startsWith(HEADER_DELIM, ctx.pos)) {
+    return lexHeaderDelim;
+  }
+  const i = ctx.input.indexOf(NEWLINE_HEADER_DELIM, ctx.pos);
+  if (i > -1) {
+    ctx.pos = i + 1;
+    ctx.ignore();
+    return lexHeaderDelim;
+  }
+  ctx.emit(1 /* EOF */);
+  return null;
+}
+function lexContent(ctx) {
+  if (ctx.input.startsWith(HEADER_DELIM, ctx.pos)) {
+    return lexHeaderDelim;
+  }
+  const i = ctx.input.indexOf(NEWLINE_HEADER_DELIM, ctx.pos);
+  if (i > -1) {
+    ctx.pos = i + 1;
+    ctx.emit(6 /* Content */);
+    return lexHeaderDelim;
+  }
+  ctx.pos = ctx.input.length;
+  if (ctx.pos > ctx.start) {
+    ctx.emit(6 /* Content */);
+  }
+  ctx.emit(1 /* EOF */);
+  return null;
+}
+function lexHeaderDelim(ctx) {
+  ctx.pos += HEADER_DELIM.length;
+  ctx.emit(2 /* Header */);
+  return lexName;
+}
+function lexName(ctx) {
+  let r;
+  outer: for (; ; ) {
+    r = ctx.next();
+    switch (r) {
+      case 92: {
+        const next = ctx.next();
+        if (next !== 10 && next !== EOF) break;
+        r = next;
+      }
+      // falls through
+      case 91:
+      // [
+      case 93:
+      // ]
+      case 123:
+      // {
+      case 125:
+      // }
+      case 10:
+      // \n
+      case EOF:
+        if (r !== EOF) ctx.backup();
+        break outer;
+    }
+  }
+  ctx.emit(3 /* Name */);
+  switch (r) {
+    case 91:
+      return lexTags;
+    // [
+    case 93:
+      return ctx.errorf(`unexpected right square bracket ']'`);
+    case 123:
+      return lexMetadata;
+    // {
+    case 125:
+      return ctx.errorf(`unexpected right curly brace '}'`);
+    case 10:
+      ctx.pos++;
+      ctx.ignore();
+      return lexContent;
+  }
+  ctx.emit(1 /* EOF */);
+  return null;
+}
+function lexNextOptionalBlock(ctx) {
+  ctx.acceptRun(" 	");
+  ctx.ignore();
+  const r = ctx.peek();
+  switch (r) {
+    case 91:
+      return lexTags;
+    // [
+    case 93:
+      return ctx.errorf(`unexpected right square bracket ']'`);
+    case 123:
+      return lexMetadata;
+    // {
+    case 125:
+      return ctx.errorf(`unexpected right curly brace '}'`);
+    case 10:
+      ctx.pos++;
+      ctx.ignore();
+      return lexContent;
+    case EOF:
+      ctx.emit(1 /* EOF */);
+      return null;
+  }
+  return ctx.errorf(`illegal character '${String.fromCharCode(r)}' amid the optional blocks`);
+}
+function lexTags(ctx) {
+  ctx.pos++;
+  for (; ; ) {
+    const r = ctx.next();
+    switch (r) {
+      case 92: {
+        const next = ctx.next();
+        if (next !== 10 && next !== EOF) break;
+      }
+      // falls through
+      case 10:
+      case EOF:
+        if (r === 10) ctx.backup();
+        return ctx.errorf("unterminated tag block");
+      case 93:
+        if (ctx.pos > ctx.start) ctx.emit(4 /* Tags */);
+        return lexNextOptionalBlock;
+      case 91:
+        return ctx.errorf(`unexpected left square bracket '['`);
+      case 123:
+        return ctx.errorf(`unexpected left curly brace '{'`);
+      case 125:
+        return ctx.errorf(`unexpected right curly brace '}'`);
+    }
+  }
+}
+function lexMetadata(ctx) {
+  ctx.pos++;
+  let depth = 1;
+  for (; ; ) {
+    const r = ctx.next();
+    switch (r) {
+      case 34: {
+        const err = acceptQuoted(ctx, 34);
+        if (err) return ctx.errorf(err);
+        break;
+      }
+      case 10:
+        ctx.backup();
+      // falls through
+      case EOF:
+        return ctx.errorf("unterminated metadata block");
+      case 123:
+        depth++;
+        break;
+      case 125:
+        depth--;
+        if (depth === 0) {
+          if (ctx.pos > ctx.start) ctx.emit(5 /* Metadata */);
+          return lexNextOptionalBlock;
+        }
+        break;
+    }
+  }
+}
+function* tweeLexer(input) {
+  const ctx = new LexerContext(input);
+  let state = lexProlog;
+  while (state !== null) {
+    state = state(ctx);
+    const items = ctx.drainItems();
+    for (const item of items) {
+      yield item;
+    }
+  }
+  const remaining = ctx.drainItems();
+  for (const item of remaining) {
+    yield item;
+  }
+}
+
+// src/twee2-compat.ts
+var twee2DetectRe = /^:: *[^[]*?(?: *\[.*?\])? *<(.*?)> *$/m;
+var twee2HeaderRe = /^(:: *[^[]*?)( *\[.*?\])?(?: *<(.*?)>)? *$/gm;
+var twee2BadPosRe = /^(::.*?) *\{"position":" *"\}$/gm;
+function hasTwee2Syntax(s) {
+  return twee2DetectRe.test(s);
+}
+function twee2ToV3(s) {
+  if (!hasTwee2Syntax(s)) return s;
+  s = s.replace(twee2HeaderRe, (_, p1, p2, p3) => {
+    const tags = p2 ?? "";
+    const pos = p3 ?? "";
+    return `${p1}${tags} {"position":"${pos}"}`;
+  });
+  s = s.replace(twee2BadPosRe, "$1");
+  return s;
+}
+
+// src/parser.ts
+function parseTwee(source, options = {}) {
+  const { filename = "<inline>", trim = true, twee2Compat = false } = options;
+  const diagnostics = [];
+  if (twee2Compat) {
+    source = twee2ToV3(source);
+  }
+  const passages = [];
+  let current = null;
+  let pCount = 0;
+  let lastType = 1 /* EOF */;
+  for (const item of tweeLexer(source)) {
+    switch (item.type) {
+      case 0 /* Error */:
+        diagnostics.push({
+          level: "error",
+          message: `line ${item.line}: Malformed twee source; ${item.val}.`,
+          file: filename,
+          line: item.line
+        });
+        return { passages, diagnostics };
+      case 1 /* EOF */:
+        if (pCount > 0 && current) {
+          passages.push(current);
+        }
+        return { passages, diagnostics };
+      case 2 /* Header */:
+        pCount++;
+        if (pCount > 1 && current) {
+          passages.push(current);
+        }
+        current = { name: "", tags: [], text: "" };
+        break;
+      case 3 /* Name */: {
+        if (!current) break;
+        const name = tweeUnescape(item.val).trim();
+        if (name.length === 0) {
+          diagnostics.push({
+            level: "error",
+            message: `line ${item.line}: Malformed twee source; passage with no name.`,
+            file: filename,
+            line: item.line
+          });
+          return { passages, diagnostics };
+        }
+        current.name = name;
+        break;
+      }
+      case 4 /* Tags */: {
+        if (!current) break;
+        if (lastType !== 3 /* Name */) {
+          diagnostics.push({
+            level: "error",
+            message: `line ${item.line}: Malformed twee source; optional tags block must immediately follow the passage name.`,
+            file: filename,
+            line: item.line
+          });
+          return { passages, diagnostics };
+        }
+        const inner = item.val.slice(1, -1);
+        current.tags = tweeUnescape(inner).split(/\s+/).filter(Boolean);
+        break;
+      }
+      case 5 /* Metadata */: {
+        if (!current) break;
+        if (lastType !== 3 /* Name */ && lastType !== 4 /* Tags */) {
+          diagnostics.push({
+            level: "error",
+            message: `line ${item.line}: Malformed twee source; optional metadata block must immediately follow the passage name or tags block.`,
+            file: filename,
+            line: item.line
+          });
+          return { passages, diagnostics };
+        }
+        try {
+          const parsed = JSON.parse(item.val);
+          const meta = {};
+          if (typeof parsed.position === "string") meta.position = parsed.position;
+          if (typeof parsed.size === "string") meta.size = parsed.size;
+          current.metadata = meta;
+        } catch (e) {
+          diagnostics.push({
+            level: "warning",
+            message: `load ${filename}: line ${item.line}: Malformed twee source; could not decode metadata (reason: ${e instanceof Error ? e.message : String(e)}).`,
+            file: filename,
+            line: item.line
+          });
+        }
+        break;
+      }
+      case 6 /* Content */: {
+        if (!current) break;
+        current.text = trim ? item.val.trim() : item.val;
+        break;
+      }
+    }
+    lastType = item.type;
+  }
+  if (pCount > 0 && current) {
+    passages.push(current);
+  }
+  return { passages, diagnostics };
+}
+
+// src/loader.ts
+function readUTF82(filename) {
+  let content = readFileSync2(filename, "utf-8");
+  if (content.charCodeAt(0) === 65279) content = content.slice(1);
+  content = content.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+  return content;
+}
+function readBase64(filename) {
+  return readFileSync2(filename).toString("base64");
+}
+function loadSources(story, filenames, opts, diagnostics, processedFiles) {
+  for (const filename of filenames) {
+    if (processedFiles.has(filename)) {
+      diagnostics.push({ level: "warning", message: `load ${filename}: Skipping duplicate.` });
+      continue;
+    }
+    const ext = normalizedFileExt(filename);
+    try {
+      switch (ext) {
+        case "tw":
+        case "twee":
+          loadTwee(story, filename, opts, diagnostics);
+          break;
+        case "tw2":
+        case "twee2":
+          loadTwee(story, filename, { ...opts, twee2Compat: true }, diagnostics);
+          break;
+        case "css":
+          loadTagged(story, "stylesheet", filename, diagnostics);
+          break;
+        case "js":
+          loadTagged(story, "script", filename, diagnostics);
+          break;
+        case "otf":
+        case "ttf":
+        case "woff":
+        case "woff2":
+          loadFont(story, filename, diagnostics);
+          break;
+        case "gif":
+        case "jpeg":
+        case "jpg":
+        case "png":
+        case "svg":
+        case "tif":
+        case "tiff":
+        case "webp":
+          loadMedia(story, "Twine.image", filename, diagnostics);
+          break;
+        case "aac":
+        case "flac":
+        case "m4a":
+        case "mp3":
+        case "oga":
+        case "ogg":
+        case "opus":
+        case "wav":
+        case "wave":
+        case "weba":
+          loadMedia(story, "Twine.audio", filename, diagnostics);
+          break;
+        case "mp4":
+        case "ogv":
+        case "webm":
+          loadMedia(story, "Twine.video", filename, diagnostics);
+          break;
+        case "vtt":
+          loadMedia(story, "Twine.vtt", filename, diagnostics);
+          break;
+        default:
+          continue;
+      }
+    } catch (e) {
+      diagnostics.push({
+        level: "error",
+        message: `load ${filename}: ${e instanceof Error ? e.message : String(e)}`,
+        file: filename
+      });
+      continue;
+    }
+    processedFiles.add(filename);
+  }
+  if (story.name !== "" && !story.passages.some((p) => p.name === "StoryTitle")) {
+    storyPrepend(story, { name: "StoryTitle", tags: [], text: story.name }, diagnostics);
+  }
+}
+function loadInlineSources(story, sources, opts, diagnostics) {
+  for (const source of sources) {
+    if (typeof source === "string") {
+      continue;
+    }
+    const content = typeof source.content === "string" ? source.content : source.content.toString("utf-8");
+    const ext = normalizedFileExt(source.filename);
+    if (ext === "tw" || ext === "twee" || ext === "tw2" || ext === "twee2" || !ext) {
+      const twee2 = ext === "tw2" || ext === "twee2" || opts.twee2Compat;
+      const result = parseTwee(content, {
+        filename: source.filename,
+        trim: opts.trim ?? true,
+        twee2Compat: twee2
+      });
+      diagnostics.push(...result.diagnostics);
+      for (const p of result.passages) {
+        storyAdd(story, p, diagnostics);
+      }
+    }
+  }
+}
+function loadTwee(story, filename, opts, diagnostics) {
+  const source = readUTF82(filename);
+  const result = parseTwee(source, {
+    filename,
+    trim: opts.trim ?? true,
+    twee2Compat: opts.twee2Compat ?? false
+  });
+  diagnostics.push(...result.diagnostics);
+  for (const p of result.passages) {
+    storyAdd(story, p, diagnostics);
+  }
+}
+function loadTagged(story, tag, filename, diagnostics) {
+  const source = readUTF82(filename);
+  storyAdd(story, { name: basename(filename), tags: [tag], text: source }, diagnostics);
+}
+function loadMedia(story, tag, filename, diagnostics) {
+  const source = readBase64(filename);
+  const name = basename(filename).split(".")[0];
+  storyAdd(story, {
+    name,
+    tags: [tag],
+    text: `data:${mediaTypeFromFilename(filename)};base64,${source}`
+  }, diagnostics);
+}
+function loadFont(story, filename, diagnostics) {
+  const source = readBase64(filename);
+  const name = basename(filename);
+  const family = name.split(".")[0];
+  const ext = normalizedFileExt(filename);
+  const mediaType = mediaTypeFromExt(ext);
+  const hint = fontFormatHint(ext);
+  storyAdd(story, {
+    name,
+    tags: ["stylesheet"],
+    text: `@font-face {
+	font-family: "${family}";
+	src: url("data:${mediaType};base64,${source}") format("${hint}");
+}`
+  }, diagnostics);
+}
+
+// src/output-twine2.ts
+var CREATOR_NAME = "Twee-ts";
+var CREATOR_VERSION = "0.1.0";
+function toTwine2Archive(story, startName, diagnostics) {
+  return getTwine2DataChunk(story, startName, diagnostics) + "\n";
+}
+function toTwine2HTML(story, format, startName, diagnostics) {
+  let template = readFormatSource(format);
+  if (template.includes("{{STORY_NAME}}")) {
+    template = template.replaceAll("{{STORY_NAME}}", htmlEscape(story.name));
+  }
+  if (template.includes("{{STORY_DATA}}")) {
+    template = template.replace("{{STORY_DATA}}", getTwine2DataChunk(story, startName, diagnostics));
+  }
+  return template;
+}
+function getTwine2DataChunk(story, startName, diagnostics) {
+  ensureIFID(story, diagnostics);
+  const parts = [];
+  let startID = "";
+  let pid = 0;
+  const scripts = [];
+  const stylesheets = [];
+  for (const p of story.passages) {
+    if (hasTag(p, "Twine.private")) continue;
+    if (hasTag(p, "script")) scripts.push(p);
+    else if (hasTag(p, "stylesheet")) stylesheets.push(p);
+  }
+  let styleContent = "";
+  if (stylesheets.length === 1) {
+    styleContent = stylesheets[0].text;
+  } else if (stylesheets.length > 1) {
+    let pidS = 1;
+    for (const p of stylesheets) {
+      if (pidS > 1 && !styleContent.endsWith("\n")) styleContent += "\n";
+      styleContent += `/* twine-user-stylesheet #${pidS}: "${p.name}" */
+`;
+      styleContent += p.text;
+      pidS++;
+    }
+  }
+  parts.push(`<style role="stylesheet" id="twine-user-stylesheet" type="text/twine-css">${styleContent}</style>`);
+  let scriptContent = "";
+  if (scripts.length === 1) {
+    scriptContent = scripts[0].text;
+  } else if (scripts.length > 1) {
+    let pidS = 1;
+    for (const p of scripts) {
+      if (pidS > 1 && !scriptContent.endsWith("\n")) scriptContent += "\n";
+      scriptContent += `/* twine-user-script #${pidS}: "${p.name}" */
+`;
+      scriptContent += p.text;
+      pidS++;
+    }
+  }
+  parts.push(`<script role="script" id="twine-user-script" type="text/twine-javascript">${scriptContent}</script>`);
+  for (const [tag, color] of story.twine2.tagColors) {
+    parts.push(`<tw-tag name="${attrEscape(tag)}" color="${attrEscape(color)}"></tw-tag>`);
+  }
+  pid = 1;
+  for (const p of story.passages) {
+    if (p.name === "StoryTitle" || p.name === "StoryData" || hasAnyTag(p, "script", "stylesheet", "Twine.private")) {
+      continue;
+    }
+    if (p.name === "StorySettings" && story.twine1.settings.size === 0) {
+      continue;
+    }
+    parts.push(passageToPassagedata(p, pid));
+    if (startName === p.name) {
+      startID = String(pid);
+    }
+    pid++;
+  }
+  const opts = [];
+  for (const [opt, val] of story.twine2.options) {
+    if (val) opts.push(opt);
+  }
+  const options = opts.join(" ");
+  const zoom = story.twine2.zoom === Math.floor(story.twine2.zoom) ? story.twine2.zoom.toString() : story.twine2.zoom.toFixed(1);
+  const wrapper = `<!-- UUID://${story.ifid}// --><tw-storydata name="${attrEscape(story.name)}" startnode="${startID}" creator="${attrEscape(CREATOR_NAME)}" creator-version="${attrEscape(CREATOR_VERSION)}" ifid="${attrEscape(story.ifid)}" zoom="${attrEscape(zoom)}" format="${attrEscape(story.twine2.format)}" format-version="${attrEscape(story.twine2.formatVersion)}" options="${attrEscape(options)}" hidden>`;
+  return wrapper + parts.join("") + "</tw-storydata>";
+}
+function ensureIFID(story, diagnostics) {
+  if (story.ifid !== "") return;
+  if (story.legacyIFID !== "") {
+    diagnostics.push({
+      level: "warning",
+      message: 'Story IFID not found; reusing "ifid" entry from the "StorySettings" special passage.'
+    });
+    story.ifid = story.legacyIFID;
+  } else {
+    story.ifid = generateIFID();
+    diagnostics.push({
+      level: "warning",
+      message: `Story IFID not found; generated ${story.ifid} for your project. Add it to a StoryData passage.`
+    });
+  }
+}
+
+// src/output-twine1.ts
+import { readFileSync as readFileSync3 } from "fs";
+import { join as join3, dirname } from "path";
+var CREATOR_NAME2 = "twee-ts";
+var CREATOR_VERSION2 = "0.1.0";
+function toTwine1Archive(story, _startName) {
+  const { data, count } = getTwine1PassageChunk(story);
+  return `<div id="storeArea" data-size="${count}" hidden>${data}</div>
+`;
+}
+function toTwine1HTML(story, format, startName, _diagnostics) {
+  const formatDir = dirname(format.filename);
+  const parentDir = dirname(formatDir);
+  let template = readFormatSource(format);
+  const { data, count } = getTwine1PassageChunk(story);
+  template = tryReplaceComponent(template, '"USER_LIB"', join3(formatDir, "userlib.js"), false);
+  template = tryReplaceComponent(template, '"ENGINE"', join3(parentDir, "engine.js"), true);
+  template = tryReplaceComponent(template, '"SUGARCANE"', join3(formatDir, "code.js"), true);
+  template = tryReplaceComponent(template, '"JONAH"', join3(formatDir, "code.js"), true);
+  if (story.twine1.settings.get("jquery") === "on") {
+    template = tryReplaceComponent(template, '"JQUERY"', join3(parentDir, "jquery.js"), true);
+  }
+  if (story.twine1.settings.get("modernizr") === "on") {
+    template = tryReplaceComponent(template, '"MODERNIZR"', join3(parentDir, "modernizr.js"), true);
+  }
+  const displayStart = startName === "Start" ? "" : startName;
+  template = template.replace('"VERSION"', `Compiled with ${CREATOR_NAME2}, ${CREATOR_VERSION2}`);
+  template = template.replace('"TIME"', `Built on ${(/* @__PURE__ */ new Date()).toUTCString()}`);
+  template = template.replace('"START_AT"', `"${displayStart}"`);
+  template = template.replace('"STORY_SIZE"', `"${count}"`);
+  if (template.includes('"STORY"')) {
+    template = template.replace('"STORY"', data);
+  } else {
+    let footer;
+    try {
+      footer = readFileSync3(join3(formatDir, "footer.html"), "utf-8");
+    } catch {
+      footer = "</div>\n</body>\n</html>\n";
+    }
+    template += data + footer;
+  }
+  if (story.ifid) {
+    if (template.includes('<div id="store-area"')) {
+      template = template.replace('<div id="store-area"', `<!-- UUID://${story.ifid}// --><div id="store-area"`);
+    } else {
+      template = template.replace('<div id="storeArea"', `<!-- UUID://${story.ifid}// --><div id="storeArea"`);
+    }
+  }
+  return template;
+}
+function getTwine1PassageChunk(story) {
+  let data = "";
+  let count = 0;
+  for (const p of story.passages) {
+    if (hasTag(p, "Twine.private")) continue;
+    count++;
+    data += passageToTiddler(p, count);
+  }
+  return { data, count };
+}
+function tryReplaceComponent(template, placeholder, componentPath, _required) {
+  if (!template.includes(placeholder)) return template;
+  try {
+    let content = readFileSync3(componentPath, "utf-8");
+    if (content.charCodeAt(0) === 65279) content = content.slice(1);
+    return template.replace(placeholder, content);
+  } catch {
+    return template;
+  }
+}
+
+// src/output-twee.ts
+function toTwee(story, outMode) {
+  let data = "";
+  for (const p of story.passages) {
+    data += passageToTwee(p, outMode);
+  }
+  return data;
+}
+
+// src/modules.ts
+import { readFileSync as readFileSync4 } from "fs";
+import { basename as basename2 } from "path";
+function readUTF83(filename) {
+  let content = readFileSync4(filename, "utf-8");
+  if (content.charCodeAt(0) === 65279) content = content.slice(1);
+  return content.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+}
+function readBase642(filename) {
+  return readFileSync4(filename).toString("base64");
+}
+function loadModules(filenames) {
+  const processed = /* @__PURE__ */ new Set();
+  const headTags = [];
+  for (const filename of filenames) {
+    if (processed.has(filename)) continue;
+    const ext = normalizedFileExt(filename);
+    let tag = null;
+    switch (ext) {
+      case "css":
+        tag = loadModuleTagged("style", filename);
+        break;
+      case "js":
+        tag = loadModuleTagged("script", filename);
+        break;
+      case "otf":
+      case "ttf":
+      case "woff":
+      case "woff2":
+        tag = loadModuleFont(filename);
+        break;
+      default:
+        continue;
+    }
+    if (tag) headTags.push(tag);
+    processed.add(filename);
+  }
+  return headTags.join("\n");
+}
+function loadModuleTagged(tag, filename) {
+  const source = readUTF83(filename).trim();
+  if (source.length === 0) return null;
+  const family = basename2(filename).split(".")[0];
+  const idSlug = `${tag}-module-${slugify(family)}`;
+  const mimeType = tag === "script" ? "text/javascript" : "text/css";
+  return `<${tag} id="${idSlug}" type="${mimeType}">${source}</${tag}>`;
+}
+function loadModuleFont(filename) {
+  const source = readBase642(filename);
+  const family = basename2(filename).split(".")[0];
+  const idSlug = `style-module-${slugify(family)}`;
+  const ext = normalizedFileExt(filename);
+  const mediaType = mediaTypeFromExt(ext);
+  const hint = fontFormatHint(ext);
+  return `<style id="${idSlug}" type="text/css">@font-face {
+	font-family: "${family}";
+	src: url("data:${mediaType};base64,${source}") format("${hint}");
+}</style>`;
+}
+function modifyHead(html, modulePaths, headFile) {
+  const parts = [];
+  if (modulePaths.length > 0) {
+    const modules = loadModules(modulePaths).trim();
+    if (modules.length > 0) parts.push(modules);
+  }
+  if (headFile) {
+    try {
+      const source = readUTF83(headFile).trim();
+      if (source.length > 0) parts.push(source);
+    } catch {
+    }
+  }
+  if (parts.length > 0) {
+    parts.push("</head>");
+    return html.replace("</head>", parts.join("\n"));
+  }
+  return html;
+}
+
+// src/remote-formats.ts
+import { mkdirSync, readFileSync as readFileSync5, writeFileSync, existsSync, readdirSync as readdirSync3, statSync as statSync3 } from "fs";
+import { join as join4 } from "path";
+import { homedir as homedir2 } from "os";
+var DEFAULT_SFA_INDICES = [
+  "https://videlais.github.io/story-formats-archive/official/index.json",
+  "https://videlais.github.io/story-formats-archive/unofficial/index.json"
+];
+function getCacheDir() {
+  const xdg = process.env["XDG_CACHE_HOME"];
+  const base = xdg || join4(homedir2(), ".cache");
+  return join4(base, "twee-ts", "storyformats");
+}
+var indexCache = /* @__PURE__ */ new Map();
+function clearIndexCache() {
+  indexCache.clear();
+}
+async function fetchIndex(url) {
+  const cached = indexCache.get(url);
+  if (cached) return cached;
+  const res = await fetch(url);
+  if (!res.ok) {
+    throw new Error(`Failed to fetch format index from ${url}: ${res.status} ${res.statusText}`);
+  }
+  const data = await res.json();
+  indexCache.set(url, data);
+  return data;
+}
+function findEntry(index, name, version) {
+  const wanted = parseSemver(version);
+  const entries = [...index.twine2 ?? [], ...index.twine1 ?? []];
+  let bestEntry;
+  let bestVersion = null;
+  for (const entry of entries) {
+    if (entry.name.toLowerCase() !== name.toLowerCase()) continue;
+    const have = parseSemver(entry.version);
+    if (!have) continue;
+    if (wanted && semverCompare(have, wanted) === 0) return entry;
+    if (wanted === null || have[0] === wanted[0] && semverCompare(have, wanted) >= 0) {
+      if (!bestVersion || semverCompare(have, bestVersion) > 0) {
+        bestVersion = have;
+        bestEntry = entry;
+      }
+    }
+  }
+  return bestEntry;
+}
+async function verifySHA256(content, expectedHex) {
+  const digest = await crypto.subtle.digest("SHA-256", content);
+  const hex = Array.from(new Uint8Array(digest)).map((b) => b.toString(16).padStart(2, "0")).join("");
+  return hex === expectedHex.toLowerCase();
+}
+function getDownloadUrl(indexUrl, entry) {
+  const base = indexUrl.replace(/\/index\.json$/, "");
+  return `${base}/twine2/${entry.name}/${entry.version}/format.js`;
+}
+async function fetchAndCacheFormat(entry, downloadUrl) {
+  const res = await fetch(downloadUrl);
+  if (!res.ok) {
+    throw new Error(`Failed to download format from ${downloadUrl}: ${res.status} ${res.statusText}`);
+  }
+  const text = await res.text();
+  const checksumKey = Object.keys(entry.checksums ?? {}).find((k) => k.endsWith("format.js"));
+  if (checksumKey) {
+    const expected = entry.checksums[checksumKey];
+    const encoder = new TextEncoder();
+    const valid = await verifySHA256(encoder.encode(text), expected);
+    if (!valid) {
+      throw new Error(`Checksum verification failed for ${entry.name} ${entry.version}`);
+    }
+  }
+  const id = `${entry.name.toLowerCase().replace(/\s+/g, "-")}-${parseSemver(entry.version)?.[0] ?? "0"}`;
+  const data = parseFormatJSON(text, id);
+  if (!data) {
+    throw new Error(`Failed to parse format JSON from ${downloadUrl}`);
+  }
+  const cacheDir = getCacheDir();
+  const formatDir = join4(cacheDir, entry.name, entry.version);
+  mkdirSync(formatDir, { recursive: true });
+  const formatPath = join4(formatDir, "format.js");
+  writeFileSync(formatPath, text, "utf-8");
+  return {
+    id,
+    filename: formatPath,
+    isTwine2: true,
+    name: data.name,
+    version: data.version,
+    proofing: data.proofing ?? false
+  };
+}
+async function fetchDirectFormat(url) {
+  const res = await fetch(url);
+  if (!res.ok) {
+    throw new Error(`Failed to download format from ${url}: ${res.status} ${res.statusText}`);
+  }
+  const text = await res.text();
+  const tempId = "direct-url";
+  const data = parseFormatJSON(text, tempId);
+  if (!data) {
+    throw new Error(`Failed to parse format JSON from ${url}`);
+  }
+  const id = `${data.name.toLowerCase().replace(/\s+/g, "-")}-${parseSemver(data.version)?.[0] ?? "0"}`;
+  const cacheDir = getCacheDir();
+  const formatDir = join4(cacheDir, data.name, data.version);
+  mkdirSync(formatDir, { recursive: true });
+  const formatPath = join4(formatDir, "format.js");
+  writeFileSync(formatPath, text, "utf-8");
+  return {
+    id,
+    filename: formatPath,
+    isTwine2: true,
+    name: data.name,
+    version: data.version,
+    proofing: data.proofing ?? false
+  };
+}
+async function resolveRemoteFormat(name, version, indices, urls) {
+  if (urls) {
+    for (const url of urls) {
+      try {
+        const info = await fetchDirectFormat(url);
+        if (info.name.toLowerCase() === name.toLowerCase()) {
+          const wanted = parseSemver(version);
+          const have = parseSemver(info.version);
+          if (!wanted || have && have[0] === wanted[0] && semverCompare(have, wanted) >= 0) {
+            return info;
+          }
+        }
+      } catch {
+      }
+    }
+  }
+  const allIndices = [...indices ?? [], ...DEFAULT_SFA_INDICES];
+  for (const indexUrl of allIndices) {
+    try {
+      const index = await fetchIndex(indexUrl);
+      const entry = findEntry(index, name, version);
+      if (entry) {
+        const cached = getCachedFormat(entry.name, entry.version);
+        if (cached) return cached;
+        const downloadUrl = getDownloadUrl(indexUrl, entry);
+        return await fetchAndCacheFormat(entry, downloadUrl);
+      }
+    } catch {
+    }
+  }
+  return void 0;
+}
+function getCachedFormat(name, version) {
+  const formatPath = join4(getCacheDir(), name, version, "format.js");
+  try {
+    if (!existsSync(formatPath)) return void 0;
+    const source = readFileSync5(formatPath, "utf-8");
+    const id = `${name.toLowerCase().replace(/\s+/g, "-")}-${parseSemver(version)?.[0] ?? "0"}`;
+    const data = parseFormatJSON(source, id);
+    if (!data) return void 0;
+    return {
+      id,
+      filename: formatPath,
+      isTwine2: true,
+      name: data.name,
+      version: data.version,
+      proofing: data.proofing ?? false
+    };
+  } catch {
+    return void 0;
+  }
+}
+function discoverCachedFormats() {
+  const formats = /* @__PURE__ */ new Map();
+  const cacheDir = getCacheDir();
+  try {
+    if (!existsSync(cacheDir)) return formats;
+  } catch {
+    return formats;
+  }
+  let names;
+  try {
+    names = readdirSync3(cacheDir);
+  } catch {
+    return formats;
+  }
+  for (const name of names) {
+    const nameDir = join4(cacheDir, name);
+    try {
+      if (!statSync3(nameDir).isDirectory()) continue;
+    } catch {
+      continue;
+    }
+    let versions;
+    try {
+      versions = readdirSync3(nameDir);
+    } catch {
+      continue;
+    }
+    for (const version of versions) {
+      const info = getCachedFormat(name, version);
+      if (info) {
+        formats.set(`${info.id}-${version}`, info);
+      }
+    }
+  }
+  return formats;
+}
+
+// src/compiler.ts
+var DEFAULT_FORMAT_ID = "sugarcube-2";
+var DEFAULT_START_NAME = "Start";
+var TweeTsError = class extends Error {
+  constructor(message, diagnostics = []) {
+    super(message);
+    this.diagnostics = diagnostics;
+    this.name = "TweeTsError";
+  }
+};
+async function compile(options) {
+  return buildOutput(options);
+}
+async function compileToFile(options) {
+  const result = await compile(options);
+  writeFileSync2(options.outFile, result.output, "utf-8");
+  return result;
+}
+async function watch(options) {
+  const controller = new AbortController();
+  const filePaths = options.sources.filter((s) => typeof s === "string");
+  const modulePaths = options.modules ?? [];
+  const allPaths = [...filePaths, ...modulePaths];
+  const handle = watchFilesystem(allPaths, options.outFile, () => {
+    buildOutput(options).then((result) => {
+      writeFileSync2(options.outFile, result.output, "utf-8");
+      options.onBuild?.(result);
+    }).catch((e) => {
+      options.onError?.(e instanceof Error ? e : new Error(String(e)));
+    });
+  });
+  controller.signal.addEventListener("abort", () => handle.close());
+  return controller;
+}
+async function buildOutput(options) {
+  const diagnostics = [];
+  const outputMode = options.outputMode ?? "html";
+  const trim = options.trim ?? true;
+  const twee2Compat = options.twee2Compat ?? false;
+  const testMode = options.testMode ?? false;
+  const noRemote = options.noRemote ?? false;
+  clearIndexCache();
+  const filePaths = [];
+  const inlineSources = [];
+  for (const source of options.sources) {
+    if (typeof source === "string") {
+      filePaths.push(source);
+    } else {
+      inlineSources.push(source);
+    }
+  }
+  const sourceFilenames = getFilenames(filePaths);
+  const story = createStory();
+  const processedFiles = /* @__PURE__ */ new Set();
+  loadSources(story, sourceFilenames, { trim, twee2Compat }, diagnostics, processedFiles);
+  loadInlineSources(story, inlineSources, { trim, twee2Compat }, diagnostics);
+  if (options.tagAliases) {
+    applyTagAliases(story.passages, options.tagAliases);
+  }
+  const fatalErrors = diagnostics.filter((d) => d.level === "error");
+  if (fatalErrors.length > 0 && outputMode === "html") {
+  }
+  let format;
+  let formatId = options.formatId ?? "";
+  if (outputMode === "html") {
+    const formatSearchDirs = getFormatSearchDirs(
+      options.formatPaths,
+      options.useTweegoPath ?? true
+    );
+    const formats = discoverFormats(formatSearchDirs);
+    if (!formatId && story.twine2.format) {
+      formatId = getFormatIdByNameAndVersion(formats, story.twine2.format, story.twine2.formatVersion) ?? "";
+    }
+    if (!formatId) {
+      formatId = DEFAULT_FORMAT_ID;
+    }
+    format = formats.get(formatId);
+    if (!format && !noRemote) {
+      const remoteName = story.twine2.format || formatId;
+      const remoteVersion = story.twine2.formatVersion || "";
+      try {
+        format = await resolveRemoteFormat(
+          remoteName,
+          remoteVersion,
+          options.formatIndices,
+          options.formatUrls
+        );
+      } catch {
+      }
+    }
+    if (!format) {
+      const reason = noRemote ? " (remote fetching disabled)" : "";
+      diagnostics.push({
+        level: "error",
+        message: `Story format "${formatId}" is not available${reason}. Found: ${[...formats.keys()].join(", ") || "none"}`
+      });
+    }
+  }
+  let startName;
+  if (options.startPassage) {
+    startName = options.startPassage;
+  } else if (story.twine2.start) {
+    startName = story.twine2.start;
+  } else {
+    startName = DEFAULT_START_NAME;
+  }
+  if (testMode) {
+    story.twine2.options.set("debug", true);
+  }
+  let output;
+  switch (outputMode) {
+    case "twee3":
+    case "twee1":
+      output = toTwee(story, outputMode);
+      break;
+    case "twine2-archive":
+      output = toTwine2Archive(story, startName, diagnostics);
+      break;
+    case "twine1-archive":
+      output = toTwine1Archive(story, startName);
+      break;
+    case "json":
+      output = storyToJSON(story);
+      break;
+    case "html":
+    default: {
+      if (!storyHas(story, startName)) {
+        diagnostics.push({
+          level: "error",
+          message: `Starting passage "${startName}" not found.`
+        });
+      }
+      if (!format) {
+        throw new TweeTsError("No story format available for HTML output.", diagnostics);
+      }
+      if (format.isTwine2) {
+        output = toTwine2HTML(story, format, startName, diagnostics);
+      } else {
+        if (story.name === "" && !storyHas(story, "StoryTitle")) {
+          diagnostics.push({
+            level: "error",
+            message: 'Special passage "StoryTitle" not found.'
+          });
+        }
+        output = toTwine1HTML(story, format, startName, diagnostics);
+      }
+      const modulePaths = options.modules ? getFilenames(options.modules) : [];
+      output = modifyHead(output, modulePaths, options.headFile);
+      break;
+    }
+  }
+  const stats = {
+    ...getStoryStats(story),
+    files: [...processedFiles]
+  };
+  return { output, story, format, diagnostics, stats };
+}
+function storyToJSON(story) {
+  return JSON.stringify({
+    name: story.name,
+    ifid: story.ifid,
+    passages: story.passages.map((p) => ({
+      name: p.name,
+      tags: p.tags,
+      text: p.text,
+      metadata: p.metadata ?? null
+    })),
+    twine2: {
+      format: story.twine2.format,
+      formatVersion: story.twine2.formatVersion,
+      start: story.twine2.start,
+      tagColors: Object.fromEntries(story.twine2.tagColors),
+      options: Object.fromEntries(story.twine2.options),
+      zoom: story.twine2.zoom
+    }
+  }, null, 2);
+}
+
+// src/config.ts
+import { readFileSync as readFileSync6, existsSync as existsSync2 } from "fs";
+import { join as join5 } from "path";
+var CONFIG_FILENAME = "twee-ts.config.json";
+var VALID_OUTPUT_MODES = ["html", "twee3", "twee1", "twine2-archive", "twine1-archive", "json"];
+function loadConfig(dir) {
+  const base = dir ?? process.cwd();
+  const configPath = join5(base, CONFIG_FILENAME);
+  if (!existsSync2(configPath)) return null;
+  let raw;
+  try {
+    raw = readFileSync6(configPath, "utf-8");
+  } catch {
+    return null;
+  }
+  let data;
+  try {
+    data = JSON.parse(raw);
+  } catch (e) {
+    throw new Error(`Invalid JSON in ${configPath}: ${e instanceof Error ? e.message : String(e)}`);
+  }
+  const errors = validateConfig(data);
+  if (errors.length > 0) {
+    throw new Error(`Invalid config in ${configPath}:
+  ${errors.join("\n  ")}`);
+  }
+  return data;
+}
+function loadConfigFile(filePath) {
+  let raw;
+  try {
+    raw = readFileSync6(filePath, "utf-8");
+  } catch (e) {
+    throw new Error(`Cannot read config file ${filePath}: ${e instanceof Error ? e.message : String(e)}`);
+  }
+  let data;
+  try {
+    data = JSON.parse(raw);
+  } catch (e) {
+    throw new Error(`Invalid JSON in ${filePath}: ${e instanceof Error ? e.message : String(e)}`);
+  }
+  const errors = validateConfig(data);
+  if (errors.length > 0) {
+    throw new Error(`Invalid config in ${filePath}:
+  ${errors.join("\n  ")}`);
+  }
+  return data;
+}
+function validateConfig(data) {
+  const errors = [];
+  if (typeof data !== "object" || data === null || Array.isArray(data)) {
+    errors.push("Config must be a JSON object.");
+    return errors;
+  }
+  const obj = data;
+  for (const key of ["output", "formatId", "startPassage", "headFile"]) {
+    if (key in obj && typeof obj[key] !== "string") {
+      errors.push(`"${key}" must be a string.`);
+    }
+  }
+  for (const key of ["useTweegoPath", "trim", "twee2Compat", "testMode", "noRemote"]) {
+    if (key in obj && typeof obj[key] !== "boolean") {
+      errors.push(`"${key}" must be a boolean.`);
+    }
+  }
+  for (const key of ["sources", "formatPaths", "formatIndices", "formatUrls", "modules"]) {
+    if (key in obj) {
+      if (!Array.isArray(obj[key])) {
+        errors.push(`"${key}" must be an array.`);
+      } else if (!obj[key].every((v) => typeof v === "string")) {
+        errors.push(`"${key}" must be an array of strings.`);
+      }
+    }
+  }
+  if ("tagAliases" in obj) {
+    if (typeof obj["tagAliases"] !== "object" || obj["tagAliases"] === null || Array.isArray(obj["tagAliases"])) {
+      errors.push('"tagAliases" must be an object.');
+    } else {
+      const aliases = obj["tagAliases"];
+      for (const [key, val] of Object.entries(aliases)) {
+        if (typeof val !== "string") {
+          errors.push(`"tagAliases.${key}" must be a string.`);
+        }
+      }
+    }
+  }
+  if ("outputMode" in obj) {
+    if (typeof obj["outputMode"] !== "string" || !VALID_OUTPUT_MODES.includes(obj["outputMode"])) {
+      errors.push(`"outputMode" must be one of: ${VALID_OUTPUT_MODES.join(", ")}.`);
+    }
+  }
+  return errors;
+}
+function scaffoldConfig() {
+  const config = {
+    sources: ["src/"],
+    output: "story.html"
+  };
+  return JSON.stringify(config, null, 2) + "\n";
+}
+
+// bin/twee-ts.ts
+var VERSION = "0.1.0";
+var { values, positionals } = parseArgs({
+  allowPositionals: true,
+  options: {
+    output: { type: "string", short: "o" },
+    format: { type: "string", short: "f" },
+    start: { type: "string", short: "s" },
+    module: { type: "string", short: "m", multiple: true },
+    head: { type: "string" },
+    "decompile-twee3": { type: "boolean", short: "d" },
+    "decompile-twee1": { type: "boolean" },
+    "archive-twine2": { type: "boolean", short: "a" },
+    "archive-twine1": { type: "boolean" },
+    "twee2-compat": { type: "boolean" },
+    "no-trim": { type: "boolean" },
+    test: { type: "boolean", short: "t" },
+    watch: { type: "boolean", short: "w" },
+    "log-stats": { type: "boolean", short: "l" },
+    "log-files": { type: "boolean" },
+    "list-formats": { type: "boolean" },
+    json: { type: "boolean" },
+    init: { type: "boolean" },
+    help: { type: "boolean", short: "h" },
+    version: { type: "boolean", short: "v" },
+    // New flags
+    "format-index": { type: "string", multiple: true },
+    "format-url": { type: "string", multiple: true },
+    "no-remote": { type: "boolean" },
+    "tag-alias": { type: "string", multiple: true },
+    config: { type: "string", short: "c" },
+    "no-config": { type: "boolean" }
+  }
+});
+async function main() {
+  if (values.version) {
+    console.log(`twee-ts v${VERSION}`);
+    return;
+  }
+  if (values.help) {
+    printUsage();
+    return;
+  }
+  if (values["list-formats"]) {
+    listFormats();
+    return;
+  }
+  if (values.init) {
+    runInit();
+    return;
+  }
+  let config = null;
+  if (!values["no-config"]) {
+    if (values.config) {
+      config = loadConfigFile(values.config);
+    } else {
+      config = loadConfig();
+    }
+  }
+  const sources = positionals.length > 0 ? positionals : config?.sources;
+  if (!sources || sources.length === 0) {
+    console.error("Error: No input sources specified.");
+    printUsage();
+    process.exit(1);
+  }
+  let outputMode = config?.outputMode ?? "html";
+  if (values["decompile-twee3"]) outputMode = "twee3";
+  else if (values["decompile-twee1"]) outputMode = "twee1";
+  else if (values["archive-twine2"]) outputMode = "twine2-archive";
+  else if (values["archive-twine1"]) outputMode = "twine1-archive";
+  else if (values.json) outputMode = "json";
+  let tagAliases;
+  if (values["tag-alias"] || config?.tagAliases) {
+    tagAliases = { ...config?.tagAliases };
+    for (const pair of values["tag-alias"] ?? []) {
+      const eq = pair.indexOf("=");
+      if (eq < 1) {
+        console.error(`Error: Invalid --tag-alias "${pair}". Expected format: alias=target`);
+        process.exit(1);
+      }
+      tagAliases[pair.slice(0, eq)] = pair.slice(eq + 1);
+    }
+  }
+  const compileOptions = {
+    sources,
+    outputMode,
+    formatId: values.format ?? config?.formatId,
+    startPassage: values.start ?? config?.startPassage,
+    formatPaths: config?.formatPaths,
+    modules: values.module ?? config?.modules,
+    headFile: values.head ?? config?.headFile,
+    trim: values["no-trim"] ? false : config?.trim ?? true,
+    twee2Compat: values["twee2-compat"] ?? config?.twee2Compat ?? false,
+    testMode: values.test ?? config?.testMode ?? false,
+    useTweegoPath: config?.useTweegoPath,
+    formatIndices: values["format-index"] ?? config?.formatIndices,
+    formatUrls: values["format-url"] ?? config?.formatUrls,
+    noRemote: values["no-remote"] ?? config?.noRemote ?? false,
+    tagAliases
+  };
+  const outFile = values.output ?? config?.output ?? "-";
+  if (values.watch) {
+    if (outFile === "-") {
+      console.error("Error: Watch mode requires an output file (-o).");
+      process.exit(1);
+    }
+    console.log("Watch mode started. Press CTRL+C to stop.");
+    await watch({
+      ...compileOptions,
+      outFile,
+      onBuild(result) {
+        console.log(`Built: ${result.stats.passages} passages, ${result.stats.words} words`);
+        logDiagnostics(result.diagnostics);
+      },
+      onError(error) {
+        console.error(`Build error: ${error.message}`);
+      }
+    });
+  } else {
+    if (outFile === "-") {
+      const result = await compile(compileOptions);
+      process.stdout.write(result.output);
+      logDiagnostics(result.diagnostics);
+      if (values["log-stats"]) logStats(result);
+    } else {
+      const result = await compileToFile({ ...compileOptions, outFile });
+      logDiagnostics(result.diagnostics);
+      if (values["log-files"]) {
+        console.log(`
+Files: ${result.stats.files.join(", ")}`);
+      }
+      if (values["log-stats"]) logStats(result);
+    }
+  }
+}
+function listFormats() {
+  const dirs = getFormatSearchDirs();
+  const formats = discoverFormats(dirs);
+  console.log("Local story formats:");
+  if (formats.size === 0) {
+    console.log("  (none)");
+  } else {
+    for (const [id, f] of formats) {
+      const type = f.isTwine2 ? "Twine 2" : "Twine 1";
+      console.log(`  ${id}: ${f.name || id} ${f.version} (${type})`);
+    }
+  }
+  const cached = discoverCachedFormats();
+  if (cached.size > 0) {
+    console.log("\nCached remote formats:");
+    for (const [id, f] of cached) {
+      console.log(`  ${id}: ${f.name} ${f.version}`);
+    }
+  }
+}
+function logDiagnostics(diagnostics) {
+  for (const d of diagnostics) {
+    if (d.level === "error") console.error(`error: ${d.message}`);
+    else console.warn(`warning: ${d.message}`);
+  }
+}
+function logStats(result) {
+  const s = result.stats;
+  console.log(`
+Statistics:`);
+  console.log(`  Passages: ${s.passages}`);
+  console.log(`  Words: ${s.words}`);
+  console.log(`  Files: ${s.files.length}`);
+}
+function runInit() {
+  console.log("Initializing new twee-ts project...");
+  mkdirSync2("src", { recursive: true });
+  writeFileSync3(join6("src", "StoryData.tw"), `:: StoryData
+{
+	"ifid": "${crypto.randomUUID().toUpperCase()}"
+}
+`);
+  writeFileSync3(join6("src", "Start.tw"), `:: Start
+Welcome to your new Twine story!
+
+This is the starting passage. Edit this file to begin writing your story.
+`);
+  if (!existsSync3(CONFIG_FILENAME)) {
+    writeFileSync3(CONFIG_FILENAME, scaffoldConfig());
+    console.log(`Created: ${CONFIG_FILENAME}`);
+  }
+  console.log("Created:");
+  console.log("  src/StoryData.tw");
+  console.log("  src/Start.tw");
+  console.log("\nRun: npx @rohal12/twee-ts");
+}
+function printUsage() {
+  console.log(`twee-ts v${VERSION} \u2014 TypeScript Twee-to-HTML compiler
+
+Usage: twee-ts [options] <sources...>
+
+Options:
+  -o, --output <file>       Output file (default: stdout)
+  -f, --format <id>         Story format ID (default: sugarcube-2)
+  -s, --start <name>        Starting passage (default: Start)
+  -m, --module <file>       Module file to inject into <head> (repeatable)
+  --head <file>             Raw HTML file to append to <head>
+  -d, --decompile-twee3     Output as Twee 3 source
+  --decompile-twee1         Output as Twee 1 source
+  -a, --archive-twine2      Output as Twine 2 archive
+  --archive-twine1          Output as Twine 1 archive
+  --json                    Output as JSON
+  --twee2-compat            Enable Twee2 syntax compatibility
+  --no-trim                 Don't trim passage whitespace
+  -t, --test                Enable test/debug mode
+  -w, --watch               Watch for changes and rebuild
+  -l, --log-stats           Log compilation statistics
+  --log-files               Log input file list
+  --list-formats            List available story formats
+  --init                    Initialize a new project
+  --format-index <url>      SFA-compatible format index URL (repeatable)
+  --format-url <url>        Direct format.js URL (repeatable)
+  --tag-alias <alias=target> Map a tag to a special tag (repeatable)
+  --no-remote               Disable remote format fetching
+  -c, --config <file>       Config file path (default: ${CONFIG_FILENAME})
+  --no-config               Skip config file loading
+  -h, --help                Show this help
+  -v, --version             Show version`);
+}
+main().catch((err) => {
+  console.error(err.message || err);
+  process.exit(1);
+});
+//# sourceMappingURL=twee-ts.js.map