@utilix-tech/sdk 0.1.0

package/dist/chunk-ZKL2VX2G.js

@@ -0,0 +1,2215 @@
+import { __export } from './chunk-MLKGABMK.js';
+import { load } from 'js-yaml';
+
+// src/tools/code.ts
+var code_exports = {};
+__export(code_exports, {
+  ALL_FLAGS: () => ALL_FLAGS,
+  CHEATSHEET: () => CHEATSHEET,
+  OPERATIONS: () => OPERATIONS,
+  SQL_DEFAULT_OPTIONS: () => SQL_DEFAULT_OPTIONS,
+  buildDockerPull: () => buildDockerPull,
+  buildDockerRun: () => buildDockerRun,
+  buildGitCommand: () => buildGitCommand,
+  collapseHtmlWhitespace: () => collapseHtmlWhitespace,
+  collapseJsWhitespace: () => collapseJsWhitespace,
+  detectDialect: () => detectDialect,
+  detectOperationType: () => detectOperationType,
+  envToExport: () => envToExport,
+  envToJson: () => envToJson,
+  formatGql: () => formatGql,
+  formatHtml: () => formatHtml,
+  formatSql: () => formatSql,
+  getEndpointsByTag: () => getEndpointsByTag,
+  getHtmlStats: () => getHtmlStats,
+  getJsStats: () => getJsStats,
+  getMethodColor: () => getMethodColor,
+  isValidTag: () => isValidTag,
+  minifyGql: () => minifyGql,
+  minifyHtml: () => minifyHtml,
+  minifyJs: () => minifyJs,
+  minifySql: () => minifySql,
+  normalizeRef: () => normalizeRef,
+  parseDockerImage: () => parseDockerImage,
+  parseEnv: () => parseEnv,
+  parseGitCommand: () => parseGitCommand,
+  parseSpec: () => parseSpec,
+  removeConsoleCalls: () => removeConsoleCalls,
+  removeEmptyAttributes: () => removeEmptyAttributes,
+  removeHtmlComments: () => removeHtmlComments,
+  removeJsComments: () => removeJsComments,
+  removeRedundantAttributes: () => removeRedundantAttributes,
+  searchCheatsheet: () => searchCheatsheet,
+  searchEndpoints: () => searchEndpoints,
+  splitStatements: () => splitStatements,
+  testPattern: () => testPattern,
+  testRegex: () => testRegex,
+  validateEnvKey: () => validateEnvKey
+});
+var ALL_FLAGS = ["g", "i", "m", "s", "u"];
+function testRegex(pattern, flags, input) {
+  if (!pattern) {
+    return {
+      ok: true,
+      matches: [],
+      matchCount: 0,
+      segments: input ? [{ text: input, matched: false, matchIndex: -1 }] : []
+    };
+  }
+  const flagStr = Array.from(/* @__PURE__ */ new Set([...flags, "g"])).join("");
+  let regex;
+  try {
+    regex = new RegExp(pattern, flagStr);
+  } catch (e) {
+    return { ok: false, error: e.message };
+  }
+  const matches = [];
+  let match;
+  let lastIndex = 0;
+  while ((match = regex.exec(input)) !== null) {
+    matches.push({
+      fullMatch: match[0],
+      index: match.index,
+      groups: match.slice(1),
+      namedGroups: match.groups ?? {}
+    });
+    if (match.index === regex.lastIndex) {
+      regex.lastIndex++;
+    }
+    if (regex.lastIndex <= lastIndex) break;
+    lastIndex = regex.lastIndex;
+    if (!flags.includes("g")) break;
+  }
+  return {
+    ok: true,
+    matches,
+    matchCount: matches.length,
+    segments: buildSegments(input, matches)
+  };
+}
+function buildSegments(input, matches) {
+  if (!input) return [];
+  if (matches.length === 0) return [{ text: input, matched: false, matchIndex: -1 }];
+  const segments = [];
+  let cursor = 0;
+  for (let i = 0; i < matches.length; i++) {
+    const { index, fullMatch } = matches[i];
+    if (index > cursor) {
+      segments.push({ text: input.slice(cursor, index), matched: false, matchIndex: -1 });
+    }
+    if (fullMatch.length > 0) {
+      segments.push({ text: fullMatch, matched: true, matchIndex: i });
+    }
+    cursor = index + fullMatch.length;
+  }
+  if (cursor < input.length) {
+    segments.push({ text: input.slice(cursor), matched: false, matchIndex: -1 });
+  }
+  return segments;
+}
+var CHEATSHEET = [
+  { pattern: "^", description: "Matches the start of a string or line", example: "^Hello matches 'Hello world' but not 'Say Hello'", category: "Anchors" },
+  { pattern: "$", description: "Matches the end of a string or line", example: "world$ matches 'Hello world' but not 'world domination'", category: "Anchors" },
+  { pattern: "\\b", description: "Matches a word boundary", example: "\\bcat\\b matches 'cat' but not 'concatenate'", category: "Anchors" },
+  { pattern: "\\B", description: "Matches a non-word boundary", example: "\\Bcat\\B matches 'concatenate' but not standalone 'cat'", category: "Anchors" },
+  { pattern: "\\A", description: "Matches the absolute start of the string (not multiline)", example: "\\AHello matches only if string starts with Hello", category: "Anchors" },
+  { pattern: "\\Z", description: "Matches the absolute end of the string", example: "world\\Z matches only if string ends with world", category: "Anchors" },
+  { pattern: ".", description: "Matches any character except newline", example: "h.t matches 'hat', 'hit', 'hot'", category: "Character Classes" },
+  { pattern: "\\d", description: "Matches any digit (0-9)", example: "\\d+ matches '123' in 'abc123def'", category: "Character Classes" },
+  { pattern: "\\D", description: "Matches any non-digit character", example: "\\D+ matches 'abc' in 'abc123'", category: "Character Classes" },
+  { pattern: "\\w", description: "Matches any word character (alphanumeric plus underscore)", example: "\\w+ matches 'hello_world'", category: "Character Classes" },
+  { pattern: "\\W", description: "Matches any non-word character", example: "\\W+ matches spaces and punctuation", category: "Character Classes" },
+  { pattern: "\\s", description: "Matches any whitespace character", example: "\\s+ matches spaces, tabs, newlines", category: "Character Classes" },
+  { pattern: "\\S", description: "Matches any non-whitespace character", example: "\\S+ matches 'hello' in '  hello  '", category: "Character Classes" },
+  { pattern: "[abc]", description: "Matches any single character listed in the set", example: "[aeiou] matches any vowel", category: "Character Classes" },
+  { pattern: "[^abc]", description: "Matches any single character not in the set", example: "[^aeiou] matches any consonant or non-letter", category: "Character Classes" },
+  { pattern: "[a-z]", description: "Matches any character in the specified range", example: "[a-z] matches any lowercase letter", category: "Character Classes" },
+  { pattern: "*", description: "Matches 0 or more repetitions of the preceding element", example: "ab* matches 'a', 'ab', 'abb', 'abbb'", category: "Quantifiers" },
+  { pattern: "+", description: "Matches 1 or more repetitions of the preceding element", example: "ab+ matches 'ab', 'abb', 'abbb' but not 'a'", category: "Quantifiers" },
+  { pattern: "?", description: "Matches 0 or 1 occurrence of the preceding element", example: "colou?r matches 'color' and 'colour'", category: "Quantifiers" },
+  { pattern: "{n}", description: "Matches exactly n repetitions", example: "\\d{3} matches exactly 3 digits", category: "Quantifiers" },
+  { pattern: "{n,}", description: "Matches n or more repetitions", example: "\\d{2,} matches 2 or more digits", category: "Quantifiers" },
+  { pattern: "{n,m}", description: "Matches between n and m repetitions", example: "\\d{2,4} matches 2 to 4 digits", category: "Quantifiers" },
+  { pattern: "*?", description: "Lazy match \u2014 matches as few characters as possible", example: "<.*?> matches the shortest possible HTML tag", category: "Quantifiers" },
+  { pattern: "+?", description: "Lazy version of +", example: "a+? matches as few 'a's as possible", category: "Quantifiers" },
+  { pattern: "(abc)", description: "Capturing group \u2014 captures the matched substring", example: "(\\d+) captures digit sequences", category: "Groups" },
+  { pattern: "(?:abc)", description: "Non-capturing group \u2014 groups without capturing", example: "(?:foo|bar)baz matches 'foobaz' or 'barbaz'", category: "Groups" },
+  { pattern: "(?<name>abc)", description: "Named capturing group", example: "(?<year>\\d{4}) captures year by name", category: "Groups" },
+  { pattern: "a|b", description: "Alternation \u2014 matches either a or b", example: "cat|dog matches 'cat' or 'dog'", category: "Groups" },
+  { pattern: "\\1", description: "Backreference to the first capturing group", example: "(\\w+) \\1 matches repeated words like 'the the'", category: "Groups" },
+  { pattern: "\\k<name>", description: "Backreference to a named capturing group", example: "(?<word>\\w+) \\k<word> matches repeated named group", category: "Groups" },
+  { pattern: "(?=abc)", description: "Positive lookahead \u2014 asserts what follows matches", example: "\\d+(?= dollars) matches digits followed by ' dollars'", category: "Lookahead/Lookbehind" },
+  { pattern: "(?!abc)", description: "Negative lookahead \u2014 asserts what follows does not match", example: "\\d+(?! dollars) matches digits not followed by ' dollars'", category: "Lookahead/Lookbehind" },
+  { pattern: "(?<=abc)", description: "Positive lookbehind \u2014 asserts what precedes matches", example: "(?<=\\$)\\d+ matches digits preceded by '$'", category: "Lookahead/Lookbehind" },
+  { pattern: "(?<!abc)", description: "Negative lookbehind \u2014 asserts what precedes does not match", example: "(?<!\\$)\\d+ matches digits not preceded by '$'", category: "Lookahead/Lookbehind" },
+  { pattern: "g", description: "Global flag \u2014 finds all matches rather than stopping at the first", example: "/\\d+/g finds all numbers in a string", category: "Flags" },
+  { pattern: "i", description: "Case-insensitive flag \u2014 ignores letter case", example: "/hello/i matches 'Hello', 'HELLO', 'hello'", category: "Flags" },
+  { pattern: "m", description: "Multiline flag \u2014 ^ and $ match start/end of each line", example: "/^\\w+/m matches the first word of each line", category: "Flags" },
+  { pattern: "s", description: "Dotall flag \u2014 makes . match newline characters too", example: "/a.b/s matches 'a\\nb'", category: "Flags" },
+  { pattern: "u", description: "Unicode flag \u2014 enables full Unicode matching", example: "/\\u{1F600}/u matches a Unicode emoji", category: "Flags" },
+  { pattern: "y", description: "Sticky flag \u2014 matches only from the lastIndex position", example: "/\\d+/y matches digits starting at the current position", category: "Flags" },
+  { pattern: "[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\\.[a-zA-Z]{2,}", description: "Matches a basic email address", example: "user@example.com", category: "Common Patterns" },
+  { pattern: "https?://[\\w\\-]+(\\.[\\w\\-]+)+([\\w.,@?^=%&:/~+#\\-]*[\\w@?^=%&/~+#\\-])?", description: "Matches an HTTP or HTTPS URL", example: "https://www.example.com/path?query=value", category: "Common Patterns" },
+  { pattern: "^(?:\\+1)?[-.\\s]?\\(?\\d{3}\\)?[-.\\s]?\\d{3}[-.\\s]?\\d{4}$", description: "Matches a North American phone number in various formats", example: "(555) 123-4567 or 555-123-4567", category: "Common Patterns" },
+  { pattern: "^\\d{5}(?:-\\d{4})?$", description: "Matches a US ZIP code (5 digits or ZIP+4)", example: "12345 or 12345-6789", category: "Common Patterns" },
+  { pattern: "^(?:(?:25[0-5]|2[0-4]\\d|[01]?\\d\\d?)\\.){3}(?:25[0-5]|2[0-4]\\d|[01]?\\d\\d?)$", description: "Matches a valid IPv4 address", example: "192.168.1.1", category: "Common Patterns" },
+  { pattern: "^(?:[0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}$", description: "Matches a basic IPv6 address", example: "2001:0db8:85a3:0000:0000:8a2e:0370:7334", category: "Common Patterns" },
+  { pattern: "^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$", description: "Matches a UUID/GUID", example: "123e4567-e89b-12d3-a456-426614174000", category: "Common Patterns" },
+  { pattern: "^(?:(?:31(\\/|-|\\.)(?:0?[13578]|1[02]))\\1|(?:(?:29|30)(\\/|-|\\.)(?:0?[1,3-9]|1[0-2])\\2))(?:(?:1[6-9]|[2-9]\\d)?\\d{2})$|^(?:29(\\/|-|\\.)0?2\\3(?:(?:(?:1[6-9]|[2-9]\\d)?(?:0[48]|[2468][048]|[13579][26])|(?:(?:16|[2468][048]|[3579][26])00))))$|^(?:0?[1-9]|1\\d|2[0-8])(\\/|-|\\.)(?:(?:0?[1-9])|(?:1[0-2]))\\4(?:(?:1[6-9]|[2-9]\\d)?\\d{2})$", description: "Matches a date in DD/MM/YYYY format with basic validation", example: "31/12/2023", category: "Common Patterns" },
+  { pattern: "^#([A-Fa-f0-9]{6}|[A-Fa-f0-9]{3})$", description: "Matches a CSS hex color code", example: "#FF5733 or #F53", category: "Common Patterns" },
+  { pattern: "^(?=.*[a-z])(?=.*[A-Z])(?=.*\\d)(?=.*[@$!%*?&])[A-Za-z\\d@$!%*?&]{8,}$", description: "Matches a strong password with uppercase, lowercase, digit, and special character", example: "P@ssword1", category: "Common Patterns" }
+];
+function testPattern(pattern, flags, text) {
+  let regex;
+  try {
+    const flagsWithGlobal = flags.includes("g") ? flags : flags + "g";
+    regex = new RegExp(pattern, flagsWithGlobal);
+  } catch (err) {
+    return {
+      matches: [],
+      isValid: false,
+      error: err instanceof Error ? err.message : String(err)
+    };
+  }
+  const matches = [];
+  let match;
+  while ((match = regex.exec(text)) !== null) {
+    const result = {
+      value: match[0],
+      index: match.index
+    };
+    if (match.groups && Object.keys(match.groups).length > 0) {
+      const filteredGroups = {};
+      for (const [key, value] of Object.entries(match.groups)) {
+        if (value !== void 0) {
+          filteredGroups[key] = value;
+        }
+      }
+      if (Object.keys(filteredGroups).length > 0) {
+        result.groups = filteredGroups;
+      }
+    }
+    matches.push(result);
+    if (match[0].length === 0) {
+      regex.lastIndex++;
+    }
+  }
+  return { matches, isValid: true };
+}
+function searchCheatsheet(query) {
+  if (query === "") {
+    return CHEATSHEET;
+  }
+  const lower = query.toLowerCase();
+  return CHEATSHEET.filter(
+    (entry) => entry.pattern.toLowerCase().includes(lower) || entry.description.toLowerCase().includes(lower) || entry.category.toLowerCase().includes(lower)
+  );
+}
+var SQL_DEFAULT_OPTIONS = {
+  indent: 2,
+  uppercase: true,
+  linesBetweenQueries: 1
+};
+var SQL_KEYWORDS = [
+  "SELECT",
+  "DISTINCT",
+  "FROM",
+  "WHERE",
+  "AND",
+  "OR",
+  "NOT",
+  "JOIN",
+  "INNER JOIN",
+  "LEFT JOIN",
+  "RIGHT JOIN",
+  "FULL JOIN",
+  "FULL OUTER JOIN",
+  "LEFT OUTER JOIN",
+  "RIGHT OUTER JOIN",
+  "CROSS JOIN",
+  "ON",
+  "AS",
+  "GROUP BY",
+  "ORDER BY",
+  "HAVING",
+  "LIMIT",
+  "OFFSET",
+  "INSERT INTO",
+  "VALUES",
+  "UPDATE",
+  "SET",
+  "DELETE FROM",
+  "DELETE",
+  "CREATE TABLE",
+  "CREATE INDEX",
+  "CREATE VIEW",
+  "ALTER TABLE",
+  "DROP TABLE",
+  "DROP",
+  "IF NOT EXISTS",
+  "IF EXISTS",
+  "PRIMARY KEY",
+  "FOREIGN KEY",
+  "REFERENCES",
+  "UNIQUE",
+  "NOT NULL",
+  "DEFAULT",
+  "CHECK",
+  "CONSTRAINT",
+  "INDEX",
+  "INTO",
+  "IN",
+  "IS",
+  "NULL",
+  "BETWEEN",
+  "LIKE",
+  "ILIKE",
+  "EXISTS",
+  "UNION",
+  "UNION ALL",
+  "INTERSECT",
+  "EXCEPT",
+  "WITH",
+  "CASE",
+  "WHEN",
+  "THEN",
+  "ELSE",
+  "END",
+  "CAST",
+  "COALESCE",
+  "COUNT",
+  "SUM",
+  "AVG",
+  "MIN",
+  "MAX",
+  "ASC",
+  "DESC",
+  "NULLS FIRST",
+  "NULLS LAST",
+  "RETURNING",
+  "OUTPUT"
+];
+var MAJOR_CLAUSE_KEYWORDS = /* @__PURE__ */ new Set([
+  "SELECT",
+  "FROM",
+  "WHERE",
+  "GROUP BY",
+  "ORDER BY",
+  "HAVING",
+  "LIMIT",
+  "OFFSET",
+  "JOIN",
+  "INNER JOIN",
+  "LEFT JOIN",
+  "RIGHT JOIN",
+  "FULL JOIN",
+  "FULL OUTER JOIN",
+  "LEFT OUTER JOIN",
+  "RIGHT OUTER JOIN",
+  "CROSS JOIN",
+  "ON",
+  "INSERT INTO",
+  "VALUES",
+  "UPDATE",
+  "SET",
+  "DELETE FROM",
+  "DELETE",
+  "CREATE TABLE",
+  "ALTER TABLE",
+  "DROP TABLE",
+  "UNION",
+  "UNION ALL",
+  "INTERSECT",
+  "EXCEPT",
+  "RETURNING",
+  "WITH"
+]);
+function sqlTokenize(sql) {
+  const tokens = [];
+  let i = 0;
+  while (i < sql.length) {
+    if (sql[i] === "-" && sql[i + 1] === "-") {
+      let j = i;
+      while (j < sql.length && sql[j] !== "\n") j++;
+      tokens.push({ type: "comment", value: sql.slice(i, j), upper: sql.slice(i, j) });
+      i = j;
+      continue;
+    }
+    if (sql[i] === "/" && sql[i + 1] === "*") {
+      let j = i + 2;
+      while (j < sql.length && !(sql[j] === "*" && sql[j + 1] === "/")) j++;
+      j += 2;
+      tokens.push({ type: "comment", value: sql.slice(i, j), upper: sql.slice(i, j) });
+      i = j;
+      continue;
+    }
+    if (sql[i] === "'" || sql[i] === '"' || sql[i] === "`") {
+      const quote = sql[i];
+      let j = i + 1;
+      while (j < sql.length) {
+        if (sql[j] === quote && sql[j + 1] === quote) {
+          j += 2;
+          continue;
+        }
+        if (sql[j] === quote) {
+          j++;
+          break;
+        }
+        if (sql[j] === "\\") j++;
+        j++;
+      }
+      tokens.push({ type: "string", value: sql.slice(i, j), upper: sql.slice(i, j) });
+      i = j;
+      continue;
+    }
+    if (sql[i] === "$") {
+      const dollarMatch = sql.slice(i).match(/^\$([A-Za-z_]*)\$/);
+      if (dollarMatch) {
+        const tag = dollarMatch[0];
+        const end = sql.indexOf(tag, i + tag.length);
+        if (end !== -1) {
+          const j = end + tag.length;
+          tokens.push({ type: "string", value: sql.slice(i, j), upper: sql.slice(i, j) });
+          i = j;
+          continue;
+        }
+      }
+    }
+    if (/\s/.test(sql[i])) {
+      let j = i;
+      while (j < sql.length && /\s/.test(sql[j])) j++;
+      tokens.push({ type: "whitespace", value: sql.slice(i, j), upper: "" });
+      i = j;
+      continue;
+    }
+    if (/[0-9]/.test(sql[i]) || sql[i] === "." && /[0-9]/.test(sql[i + 1] || "")) {
+      let j = i;
+      while (j < sql.length && /[0-9._eE+\-]/.test(sql[j])) j++;
+      tokens.push({ type: "number", value: sql.slice(i, j), upper: sql.slice(i, j) });
+      i = j;
+      continue;
+    }
+    if (/[a-zA-Z_]/.test(sql[i])) {
+      let j = i;
+      while (j < sql.length && /[a-zA-Z0-9_]/.test(sql[j])) j++;
+      const word = sql.slice(i, j);
+      tokens.push({ type: "word", value: word, upper: word.toUpperCase() });
+      i = j;
+      continue;
+    }
+    tokens.push({ type: "punctuation", value: sql[i], upper: sql[i] });
+    i++;
+  }
+  return tokens;
+}
+function mergeKeywordTokens(tokens) {
+  const result = [];
+  let i = 0;
+  while (i < tokens.length) {
+    if (tokens[i].type === "word") {
+      let matched = false;
+      const sortedKws = [...SQL_KEYWORDS].sort((a, b) => b.length - a.length);
+      for (const kw of sortedKws) {
+        const parts = kw.split(" ");
+        let j = i;
+        const wordParts = [];
+        let ok = true;
+        for (const part of parts) {
+          while (j < tokens.length && tokens[j].type === "whitespace") {
+            wordParts.push(tokens[j]);
+            j++;
+          }
+          if (j < tokens.length && tokens[j].type === "word" && tokens[j].upper === part) {
+            wordParts.push(tokens[j]);
+            j++;
+          } else {
+            ok = false;
+            break;
+          }
+        }
+        if (ok && parts.length > 1) {
+          result.push({ type: "keyword", value: wordParts.map((t) => t.value).join(""), upper: kw });
+          i = j;
+          matched = true;
+          break;
+        }
+      }
+      if (!matched) {
+        const upper = tokens[i].upper;
+        if (SQL_KEYWORDS.includes(upper)) {
+          result.push({ type: "keyword", value: tokens[i].value, upper });
+        } else {
+          result.push(tokens[i]);
+        }
+        i++;
+      }
+    } else {
+      result.push(tokens[i]);
+      i++;
+    }
+  }
+  return result;
+}
+function applySqlCase(value, upper, uppercase) {
+  return uppercase ? upper : value;
+}
+function formatSql(sql, options) {
+  const opts = { ...SQL_DEFAULT_OPTIONS, ...options };
+  const indent = " ".repeat(opts.indent);
+  const statements = splitStatements(sql);
+  const separator = "\n".repeat(opts.linesBetweenQueries + 1);
+  return statements.map((stmt) => formatSqlStatement(stmt.trim(), opts, indent)).filter((s) => s.length > 0).join(separator);
+}
+function formatSqlStatement(sql, opts, indent) {
+  const raw = sqlTokenize(sql);
+  const tokens = mergeKeywordTokens(raw).filter((t) => t.type !== "whitespace");
+  if (tokens.length === 0) return "";
+  const lines = [];
+  let currentLine = "";
+  let parenDepth = 0;
+  let i = 0;
+  const flush = () => {
+    const trimmed = currentLine.trimEnd();
+    if (trimmed) lines.push(trimmed);
+    currentLine = "";
+  };
+  const addToLine = (s) => {
+    if (currentLine === "" || currentLine.endsWith(" ")) {
+      currentLine += s;
+    } else {
+      currentLine += " " + s;
+    }
+  };
+  const isColumnSeparatorContext = () => {
+    return parenDepth === 0 && lines.length > 0 && /^(SELECT|INSERT INTO)/i.test(lines[0]);
+  };
+  while (i < tokens.length) {
+    const tok = tokens[i];
+    if (tok.type === "comment") {
+      flush();
+      lines.push(tok.value);
+      i++;
+      continue;
+    }
+    if (tok.type === "punctuation" && tok.value === "(") {
+      currentLine += "(";
+      parenDepth++;
+      i++;
+      continue;
+    }
+    if (tok.type === "punctuation" && tok.value === ")") {
+      currentLine += ")";
+      parenDepth--;
+      i++;
+      continue;
+    }
+    if (tok.type === "punctuation" && tok.value === ",") {
+      currentLine += ",";
+      if (parenDepth === 0) {
+        flush();
+        if (isColumnSeparatorContext()) {
+          currentLine = indent;
+        }
+      }
+      i++;
+      continue;
+    }
+    if (tok.type === "punctuation" && tok.value === ";") {
+      currentLine += ";";
+      flush();
+      i++;
+      continue;
+    }
+    if (tok.type === "keyword" && MAJOR_CLAUSE_KEYWORDS.has(tok.upper) && parenDepth === 0) {
+      flush();
+      const kw = applySqlCase(tok.value, tok.upper, opts.uppercase);
+      currentLine = kw;
+      i++;
+      if (tok.upper === "SELECT" || tok.upper === "INSERT INTO") {
+        flush();
+        currentLine = indent;
+      }
+      continue;
+    }
+    if (tok.type === "keyword") {
+      addToLine(applySqlCase(tok.value, tok.upper, opts.uppercase));
+      i++;
+      continue;
+    }
+    addToLine(tok.value);
+    i++;
+  }
+  flush();
+  return lines.join("\n");
+}
+function minifySql(sql) {
+  const tokens = sqlTokenize(sql);
+  const result = [];
+  let pendingSpace = false;
+  for (const tok of tokens) {
+    if (tok.type === "comment") {
+      pendingSpace = false;
+      continue;
+    }
+    if (tok.type === "whitespace") {
+      if (result.length > 0) pendingSpace = true;
+      continue;
+    }
+    if (tok.type === "punctuation" && /^[(),;]$/.test(tok.value)) {
+      pendingSpace = false;
+      if (result.length > 0 && result[result.length - 1] === " ") {
+        result.pop();
+      }
+      result.push(tok.value);
+      pendingSpace = false;
+      continue;
+    }
+    if (pendingSpace) {
+      const last = result[result.length - 1] ?? "";
+      if (last && last !== "(" && last !== " ") {
+        result.push(" ");
+      }
+      pendingSpace = false;
+    }
+    result.push(tok.value);
+  }
+  return result.join("").trim();
+}
+function detectDialect(sql) {
+  const upper = sql.toUpperCase();
+  if (upper.includes("AUTO_INCREMENT") || upper.includes("ENGINE=") || upper.includes("TINYINT") || upper.includes("SHOW TABLES")) {
+    return "mysql";
+  }
+  if (upper.includes("SERIAL") || upper.includes("RETURNING") || upper.includes("ILIKE") || upper.includes("::") || upper.includes("$$") || upper.includes("JSONB") || upper.includes("ON CONFLICT")) {
+    return "postgresql";
+  }
+  if (upper.includes("AUTOINCREMENT") || upper.includes("PRAGMA") || upper.includes("WITHOUT ROWID") || upper.includes("SQLITE_")) {
+    return "sqlite";
+  }
+  return "generic";
+}
+function splitStatements(sql) {
+  const tokens = sqlTokenize(sql);
+  const statements = [];
+  let current = "";
+  let parenDepth = 0;
+  for (const tok of tokens) {
+    if (tok.type === "punctuation" && tok.value === "(") {
+      parenDepth++;
+      current += tok.value;
+    } else if (tok.type === "punctuation" && tok.value === ")") {
+      parenDepth--;
+      current += tok.value;
+    } else if (tok.type === "punctuation" && tok.value === ";" && parenDepth === 0) {
+      const trimmed2 = current.trim();
+      if (trimmed2) statements.push(trimmed2);
+      current = "";
+    } else {
+      current += tok.value;
+    }
+  }
+  const trimmed = current.trim();
+  if (trimmed) statements.push(trimmed);
+  return statements;
+}
+var VOID_ELEMENTS = /* @__PURE__ */ new Set([
+  "area",
+  "base",
+  "br",
+  "col",
+  "embed",
+  "hr",
+  "img",
+  "input",
+  "link",
+  "meta",
+  "param",
+  "source",
+  "track",
+  "wbr"
+]);
+var RAW_TEXT_ELEMENTS = /* @__PURE__ */ new Set(["pre", "script", "style", "textarea"]);
+function computeHtmlSavings(originalSize, outputSize) {
+  if (originalSize === 0) return 0;
+  const pct = Math.round((1 - outputSize / originalSize) * 100);
+  return pct > 0 ? pct : 0;
+}
+function htmlTokenize(input) {
+  const tokens = [];
+  let i = 0;
+  while (i < input.length) {
+    if (input[i] !== "<") {
+      let j = i;
+      while (j < input.length && input[j] !== "<") j++;
+      tokens.push({ type: "text", raw: input.slice(i, j) });
+      i = j;
+      continue;
+    }
+    if (input.startsWith("<!--", i)) {
+      const end2 = input.indexOf("-->", i + 4);
+      if (end2 === -1) {
+        tokens.push({ type: "comment", raw: input.slice(i) });
+        break;
+      }
+      tokens.push({ type: "comment", raw: input.slice(i, end2 + 3) });
+      i = end2 + 3;
+      continue;
+    }
+    if (input.slice(i, i + 9).toLowerCase() === "<!doctype") {
+      const end2 = input.indexOf(">", i);
+      const raw2 = end2 === -1 ? input.slice(i) : input.slice(i, end2 + 1);
+      tokens.push({ type: "doctype", raw: raw2 });
+      i = end2 === -1 ? input.length : end2 + 1;
+      continue;
+    }
+    if (input[i + 1] === "/") {
+      const end2 = input.indexOf(">", i);
+      const raw2 = end2 === -1 ? input.slice(i) : input.slice(i, end2 + 1);
+      const tag2 = raw2.slice(2, raw2.length - 1).trim().toLowerCase();
+      tokens.push({ type: "close", tag: tag2, raw: raw2 });
+      i = end2 === -1 ? input.length : end2 + 1;
+      continue;
+    }
+    const end = input.indexOf(">", i);
+    if (end === -1) {
+      tokens.push({ type: "text", raw: input.slice(i) });
+      break;
+    }
+    const raw = input.slice(i, end + 1);
+    const tagMatch = raw.match(/^<([a-zA-Z][a-zA-Z0-9-]*)/);
+    if (!tagMatch) {
+      tokens.push({ type: "text", raw });
+      i = end + 1;
+      continue;
+    }
+    const tag = tagMatch[1].toLowerCase();
+    const selfClose = raw.endsWith("/>") || VOID_ELEMENTS.has(tag);
+    if (RAW_TEXT_ELEMENTS.has(tag) && !selfClose) {
+      const closeTag = `</${tag}>`;
+      const closeIdx = input.toLowerCase().indexOf(closeTag, end + 1);
+      if (closeIdx === -1) {
+        const content = input.slice(end + 1);
+        tokens.push({ type: "open", tag, raw, selfClose: false });
+        tokens.push({ type: "raw", tag, content, closeTag });
+        i = input.length;
+      } else {
+        const content = input.slice(end + 1, closeIdx);
+        tokens.push({ type: "open", tag, raw, selfClose: false });
+        tokens.push({ type: "raw", tag, content, closeTag: input.slice(closeIdx, closeIdx + closeTag.length) });
+        i = closeIdx + closeTag.length;
+      }
+      continue;
+    }
+    tokens.push({ type: "open", tag, raw, selfClose });
+    i = end + 1;
+  }
+  return tokens;
+}
+function formatHtml(input, indentSize = 2) {
+  const originalSize = input.length;
+  if (input.trim() === "") {
+    return { output: "", originalSize, outputSize: 0, savings: 0 };
+  }
+  const indent = " ".repeat(indentSize);
+  const tokens = htmlTokenize(input);
+  const lines = [];
+  let depth = 0;
+  const pad = (d) => indent.repeat(Math.max(0, d));
+  for (const token of tokens) {
+    switch (token.type) {
+      case "doctype":
+        lines.push(token.raw.trim());
+        break;
+      case "comment":
+        lines.push(pad(depth) + token.raw.trim());
+        break;
+      case "open":
+        lines.push(pad(depth) + token.raw.trim());
+        if (!token.selfClose) {
+          depth++;
+        }
+        break;
+      case "close":
+        depth = Math.max(0, depth - 1);
+        lines.push(pad(depth) + token.raw.trim());
+        break;
+      case "text": {
+        const text = token.raw.trim();
+        if (text) {
+          lines.push(pad(depth) + text);
+        }
+        break;
+      }
+      case "raw": {
+        lines.push(token.content);
+        depth = Math.max(0, depth - 1);
+        lines.push(pad(depth) + token.closeTag.trim());
+        break;
+      }
+    }
+  }
+  const output = lines.join("\n");
+  const outputSize = output.length;
+  return {
+    output,
+    originalSize,
+    outputSize,
+    savings: computeHtmlSavings(originalSize, outputSize)
+  };
+}
+function removeHtmlComments(html) {
+  return html.replace(/<!--(?!\[if\s)[\s\S]*?-->/gi, "");
+}
+function collapseHtmlWhitespace(html) {
+  const preserved = [];
+  let result = html;
+  result = result.replace(
+    /<(pre|script|style|textarea)[\s\S]*?<\/\1>/gi,
+    (match) => {
+      preserved.push(match);
+      return `\0PRESERVED${preserved.length - 1}\0`;
+    }
+  );
+  result = result.replace(/\s+/g, " ").replace(/>\s+</g, "><").trim();
+  result = result.replace(/\x00PRESERVED(\d+)\x00/g, (_, idx) => preserved[parseInt(idx, 10)]);
+  return result;
+}
+function removeEmptyAttributes(html) {
+  return html.replace(/\s+[\w-]+=(?:""|'')/g, "");
+}
+function removeRedundantAttributes(html) {
+  return html.replace(/\s+type="text\/javascript"/gi, "").replace(/\s+type="text\/css"/gi, "").replace(/\s+language="javascript"/gi, "");
+}
+function basicMinifyCss(css) {
+  return css.replace(/\/\*[\s\S]*?\*\//g, "").replace(/\s*([{}:;,>+~])\s*/g, "$1").replace(/;\s*}/g, "}").replace(/\s+/g, " ").trim();
+}
+function basicMinifyJsInHtml(js) {
+  return js.replace(/\/\/[^\n]*/g, "").replace(/\/\*[\s\S]*?\*\//g, "").replace(/\s+/g, " ").trim();
+}
+function minifyInlineStyle(html) {
+  return html.replace(
+    /<style([\s\S]*?)>([\s\S]*?)<\/style>/gi,
+    (_, attrs, content) => `<style${attrs}>${basicMinifyCss(content)}</style>`
+  );
+}
+function minifyInlineScript(html) {
+  return html.replace(
+    /<script([\s\S]*?)>([\s\S]*?)<\/script>/gi,
+    (_, attrs, content) => `<script${attrs}>${basicMinifyJsInHtml(content)}</script>`
+  );
+}
+function minifyHtml(html, options = {}) {
+  const {
+    removeComments: doRemoveComments = true,
+    collapseWhitespace: doCollapseWhitespace = true,
+    removeEmptyAttributes: doRemoveEmptyAttrs = false,
+    removeRedundantAttributes: doRemoveRedundantAttrs = false,
+    minifyInlineCSS = false,
+    minifyInlineJS = false
+  } = options;
+  const original = html;
+  let minified = html;
+  if (doRemoveComments) minified = removeHtmlComments(minified);
+  if (doRemoveEmptyAttrs) minified = removeEmptyAttributes(minified);
+  if (doRemoveRedundantAttrs) minified = removeRedundantAttributes(minified);
+  if (minifyInlineCSS) minified = minifyInlineStyle(minified);
+  if (minifyInlineJS) minified = minifyInlineScript(minified);
+  if (doCollapseWhitespace) minified = collapseHtmlWhitespace(minified);
+  const encoder = new TextEncoder();
+  const originalSize = encoder.encode(original).length;
+  const minifiedSize = encoder.encode(minified).length;
+  const savedBytes = Math.max(0, originalSize - minifiedSize);
+  const savedPercent = originalSize > 0 ? Math.round(savedBytes / originalSize * 1e4) / 100 : 0;
+  return { original, minified, originalSize, minifiedSize, savedBytes, savedPercent };
+}
+function getHtmlStats(html) {
+  const tagMatches = html.match(/<[a-zA-Z][^>]*>/g) ?? [];
+  const tags = tagMatches.length;
+  let attributes = 0;
+  for (const tag of tagMatches) {
+    const attrMatches = tag.match(/\s[\w-]+=(?:"[^"]*"|'[^']*'|[^\s>]+)/g) ?? [];
+    attributes += attrMatches.length;
+  }
+  const textNodeMatches = html.replace(/<[^>]+>/g, "\0").split("\0").filter((s) => s.trim().length > 0);
+  const textNodes = textNodeMatches.length;
+  return { tags, attributes, textNodes };
+}
+function formatGql(input, indentSize = 2) {
+  const trimmed = input.trim();
+  if (!trimmed) {
+    return { output: "", valid: false, error: "Input is empty" };
+  }
+  const normalized = trimmed.replace(/\s+/g, " ");
+  let result = "";
+  let indentLevel = 0;
+  let lineBuffer = "";
+  let argDepth = 0;
+  let i = 0;
+  const indent = () => " ".repeat(indentSize * indentLevel);
+  while (i < normalized.length) {
+    const ch = normalized[i];
+    if (ch === "(") {
+      argDepth++;
+      lineBuffer += ch;
+      i++;
+      while (i < normalized.length && argDepth > 0) {
+        const ac = normalized[i];
+        if (ac === "(") argDepth++;
+        else if (ac === ")") argDepth--;
+        lineBuffer += ac;
+        i++;
+      }
+      continue;
+    }
+    if (ch === "{") {
+      const buf2 = lineBuffer.trim();
+      if (buf2) {
+        result += indent() + buf2 + " {\n";
+      } else {
+        result += indent() + "{\n";
+      }
+      lineBuffer = "";
+      indentLevel++;
+      i++;
+      continue;
+    }
+    if (ch === "}") {
+      const buf2 = lineBuffer.trim();
+      if (buf2) {
+        result += indent() + buf2 + "\n";
+        lineBuffer = "";
+      }
+      indentLevel = Math.max(0, indentLevel - 1);
+      result += indent() + "}\n";
+      i++;
+      continue;
+    }
+    if (ch === ",") {
+      const buf2 = lineBuffer.trim();
+      if (buf2) {
+        result += indent() + buf2 + "\n";
+        lineBuffer = "";
+      }
+      i++;
+      continue;
+    }
+    if (ch === " ") {
+      const buf2 = lineBuffer.trim();
+      if (buf2) {
+        let j = i + 1;
+        while (j < normalized.length && normalized[j] === " ") j++;
+        const nextCh = normalized[j];
+        if (nextCh === "{" || nextCh === "(" || nextCh === void 0) {
+          lineBuffer += " ";
+        } else if (nextCh === "}") {
+          result += indent() + buf2 + "\n";
+          lineBuffer = "";
+        } else {
+          let k = j;
+          let foundOpenBrace = false;
+          while (k < normalized.length) {
+            if (normalized[k] === "{") {
+              foundOpenBrace = true;
+              break;
+            }
+            if (normalized[k] === "}") break;
+            k++;
+          }
+          if (foundOpenBrace) {
+            lineBuffer += " ";
+          } else {
+            result += indent() + buf2 + "\n";
+            lineBuffer = "";
+          }
+        }
+      }
+      i++;
+      continue;
+    }
+    lineBuffer += ch;
+    i++;
+  }
+  const buf = lineBuffer.trim();
+  if (buf) {
+    result += indent() + buf + "\n";
+  }
+  const cleaned = result.split("\n").filter((line) => line.trim() !== "").map((line) => line.trimEnd()).join("\n");
+  return { output: cleaned, valid: true };
+}
+function minifyGql(input) {
+  const minified = input.replace(/\s+/g, " ").trim();
+  return { output: minified, valid: true };
+}
+function detectOperationType(input) {
+  const trimmed = input.trim().toLowerCase();
+  if (trimmed.startsWith("query")) return "query";
+  if (trimmed.startsWith("mutation")) return "mutation";
+  if (trimmed.startsWith("subscription")) return "subscription";
+  if (trimmed.startsWith("fragment")) return "fragment";
+  if (trimmed.includes("{")) return "query";
+  return "unknown";
+}
+var OPERATIONS = [
+  {
+    value: "commit",
+    label: "Commit",
+    description: "Record changes to the repository",
+    options: [
+      { key: "message", label: "Message", type: "string", flag: "--message/-m", required: true },
+      { key: "amend", label: "Amend", type: "boolean", flag: "--amend" },
+      { key: "noVerify", label: "No Verify", type: "boolean", flag: "--no-verify" },
+      { key: "all", label: "All", type: "boolean", flag: "--all/-a" }
+    ]
+  },
+  {
+    value: "branch",
+    label: "Branch",
+    description: "List, create, or delete branches",
+    options: [
+      { key: "name", label: "Branch Name", type: "string", flag: "" },
+      { key: "action", label: "Action", type: "string", flag: "", default: "list" },
+      { key: "newName", label: "New Name", type: "string", flag: "" },
+      { key: "force", label: "Force", type: "boolean", flag: "--force/-f" }
+    ]
+  },
+  {
+    value: "checkout",
+    label: "Checkout",
+    description: "Switch branches or restore working tree files",
+    options: [
+      { key: "branch", label: "Branch", type: "string", flag: "" },
+      { key: "newBranch", label: "New Branch", type: "boolean", flag: "-b" },
+      { key: "file", label: "File", type: "string", flag: "" }
+    ]
+  },
+  {
+    value: "merge",
+    label: "Merge",
+    description: "Join two or more development histories together",
+    options: [
+      { key: "branch", label: "Branch", type: "string", flag: "", required: true },
+      { key: "noFF", label: "No Fast Forward", type: "boolean", flag: "--no-ff" },
+      { key: "squash", label: "Squash", type: "boolean", flag: "--squash" },
+      { key: "message", label: "Message", type: "string", flag: "--message/-m" }
+    ]
+  },
+  {
+    value: "rebase",
+    label: "Rebase",
+    description: "Reapply commits on top of another base tip",
+    options: [
+      { key: "branch", label: "Branch", type: "string", flag: "", required: true },
+      { key: "interactive", label: "Interactive", type: "boolean", flag: "--interactive/-i" },
+      { key: "onto", label: "Onto", type: "string", flag: "--onto" }
+    ]
+  },
+  {
+    value: "stash",
+    label: "Stash",
+    description: "Stash the changes in a dirty working directory away",
+    options: [
+      { key: "action", label: "Action", type: "string", flag: "", default: "push" },
+      { key: "message", label: "Message", type: "string", flag: "" },
+      { key: "index", label: "Index", type: "number", flag: "" }
+    ]
+  },
+  {
+    value: "tag",
+    label: "Tag",
+    description: "Create, list, delete or verify a tag object",
+    options: [
+      { key: "name", label: "Tag Name", type: "string", flag: "", required: true },
+      { key: "message", label: "Message", type: "string", flag: "--message/-m" },
+      { key: "delete", label: "Delete", type: "boolean", flag: "-d" },
+      { key: "ref", label: "Ref", type: "string", flag: "" }
+    ]
+  },
+  {
+    value: "remote",
+    label: "Remote",
+    description: "Manage set of tracked repositories",
+    options: [
+      { key: "action", label: "Action", type: "string", flag: "", default: "list" },
+      { key: "name", label: "Name", type: "string", flag: "" },
+      { key: "url", label: "URL", type: "string", flag: "" },
+      { key: "newName", label: "New Name", type: "string", flag: "" }
+    ]
+  },
+  {
+    value: "reset",
+    label: "Reset",
+    description: "Reset current HEAD to the specified state",
+    options: [
+      { key: "ref", label: "Ref", type: "string", flag: "", default: "HEAD" },
+      { key: "mode", label: "Mode", type: "string", flag: "", default: "mixed" },
+      { key: "file", label: "File", type: "string", flag: "" }
+    ]
+  },
+  {
+    value: "cherry-pick",
+    label: "Cherry Pick",
+    description: "Apply the changes introduced by some existing commits",
+    options: [
+      { key: "commit", label: "Commit", type: "string", flag: "", required: true },
+      { key: "noCommit", label: "No Commit", type: "boolean", flag: "--no-commit/-n" }
+    ]
+  },
+  {
+    value: "log",
+    label: "Log",
+    description: "Show commit logs",
+    options: [
+      { key: "oneline", label: "Oneline", type: "boolean", flag: "--oneline" },
+      { key: "count", label: "Count", type: "number", flag: "-n" },
+      { key: "author", label: "Author", type: "string", flag: "--author" },
+      { key: "since", label: "Since", type: "string", flag: "--since" },
+      { key: "graph", label: "Graph", type: "boolean", flag: "--graph" }
+    ]
+  },
+  {
+    value: "diff",
+    label: "Diff",
+    description: "Show changes between commits, commit and working tree, etc",
+    options: [
+      { key: "cached", label: "Cached", type: "boolean", flag: "--cached" },
+      { key: "file", label: "File", type: "string", flag: "" },
+      { key: "ref1", label: "Ref 1", type: "string", flag: "" },
+      { key: "ref2", label: "Ref 2", type: "string", flag: "" },
+      { key: "stat", label: "Stat", type: "boolean", flag: "--stat" }
+    ]
+  },
+  {
+    value: "clone",
+    label: "Clone",
+    description: "Clone a repository into a new directory",
+    options: [
+      { key: "url", label: "URL", type: "string", flag: "", required: true },
+      { key: "directory", label: "Directory", type: "string", flag: "" },
+      { key: "depth", label: "Depth", type: "number", flag: "--depth" },
+      { key: "branch", label: "Branch", type: "string", flag: "--branch/-b" }
+    ]
+  },
+  {
+    value: "push",
+    label: "Push",
+    description: "Update remote refs along with associated objects",
+    options: [
+      { key: "remote", label: "Remote", type: "string", flag: "", default: "origin" },
+      { key: "branch", label: "Branch", type: "string", flag: "" },
+      { key: "force", label: "Force", type: "boolean", flag: "--force" },
+      { key: "setUpstream", label: "Set Upstream", type: "boolean", flag: "--set-upstream/-u" },
+      { key: "tags", label: "Tags", type: "boolean", flag: "--tags" }
+    ]
+  },
+  {
+    value: "pull",
+    label: "Pull",
+    description: "Fetch from and integrate with another repository or a local branch",
+    options: [
+      { key: "remote", label: "Remote", type: "string", flag: "", default: "origin" },
+      { key: "branch", label: "Branch", type: "string", flag: "" },
+      { key: "rebase", label: "Rebase", type: "boolean", flag: "--rebase" }
+    ]
+  },
+  {
+    value: "fetch",
+    label: "Fetch",
+    description: "Download objects and refs from another repository",
+    options: [
+      { key: "remote", label: "Remote", type: "string", flag: "", default: "origin" },
+      { key: "all", label: "All", type: "boolean", flag: "--all" },
+      { key: "prune", label: "Prune", type: "boolean", flag: "--prune/-p" },
+      { key: "tags", label: "Tags", type: "boolean", flag: "--tags" }
+    ]
+  }
+];
+function buildGitCommand(config) {
+  const { operation, options } = config;
+  switch (operation) {
+    case "commit": {
+      if (!options.message) {
+        return { error: "commit requires a message" };
+      }
+      const flags = [];
+      const parts = ["git", "commit"];
+      if (options.all) {
+        flags.push("-a");
+        parts.push("-a");
+      }
+      if (options.amend) {
+        flags.push("--amend");
+        parts.push("--amend");
+      }
+      if (options.noVerify) {
+        flags.push("--no-verify");
+        parts.push("--no-verify");
+      }
+      flags.push("-m");
+      parts.push(`-m "${options.message}"`);
+      return {
+        command: parts.join(" "),
+        explanation: `Creates a new commit with the message "${options.message}"${options.amend ? ", amending the previous commit" : ""}${options.noVerify ? ", skipping pre-commit hooks" : ""}`,
+        flags
+      };
+    }
+    case "branch": {
+      const action = options.action || "list";
+      const flags = [];
+      let command = "";
+      let explanation = "";
+      if (action === "list") {
+        command = "git branch";
+        explanation = "Lists all local branches";
+      } else if (action === "create") {
+        command = `git branch ${options.name}`;
+        explanation = `Creates a new branch named "${options.name}"`;
+      } else if (action === "delete") {
+        const flag = options.force ? "-D" : "-d";
+        flags.push(flag);
+        command = `git branch ${flag} ${options.name}`;
+        explanation = `Deletes the branch "${options.name}"${options.force ? " (force delete)" : ""}`;
+      } else if (action === "rename") {
+        flags.push("-m");
+        command = `git branch -m ${options.name} ${options.newName}`;
+        explanation = `Renames branch "${options.name}" to "${options.newName}"`;
+      } else {
+        return { error: `Unknown branch action: ${action}` };
+      }
+      return { command, explanation, flags };
+    }
+    case "checkout": {
+      const flags = [];
+      const parts = ["git", "checkout"];
+      if (options.file) {
+        parts.push("--", String(options.file));
+        return { command: parts.join(" "), explanation: `Restores the file "${options.file}" from the index`, flags };
+      }
+      if (options.newBranch) {
+        flags.push("-b");
+        parts.push("-b");
+      }
+      if (options.branch) {
+        parts.push(String(options.branch));
+      }
+      return {
+        command: parts.join(" "),
+        explanation: options.newBranch ? `Creates and switches to a new branch "${options.branch}"` : `Switches to branch "${options.branch}"`,
+        flags
+      };
+    }
+    case "merge": {
+      if (!options.branch) {
+        return { error: "merge requires a branch" };
+      }
+      const flags = [];
+      const parts = ["git", "merge"];
+      if (options.noFF) {
+        flags.push("--no-ff");
+        parts.push("--no-ff");
+      }
+      if (options.squash) {
+        flags.push("--squash");
+        parts.push("--squash");
+      }
+      if (options.message) {
+        flags.push("-m");
+        parts.push(`-m "${options.message}"`);
+      }
+      parts.push(String(options.branch));
+      return {
+        command: parts.join(" "),
+        explanation: `Merges branch "${options.branch}" into the current branch${options.noFF ? " without fast-forwarding" : ""}${options.squash ? ", squashing commits" : ""}`,
+        flags
+      };
+    }
+    case "rebase": {
+      if (!options.branch) {
+        return { error: "rebase requires a branch" };
+      }
+      const flags = [];
+      const parts = ["git", "rebase"];
+      if (options.onto) {
+        flags.push("--onto");
+        parts.push(`--onto ${options.onto}`);
+      }
+      if (options.interactive) {
+        flags.push("-i");
+        parts.push("-i");
+      }
+      parts.push(String(options.branch));
+      return {
+        command: parts.join(" "),
+        explanation: `Rebases current branch onto "${options.branch}"${options.interactive ? " interactively" : ""}`,
+        flags
+      };
+    }
+    case "stash": {
+      const action = options.action || "push";
+      const flags = [];
+      let command = "";
+      let explanation = "";
+      if (action === "push") {
+        const parts = ["git", "stash", "push"];
+        if (options.message) {
+          parts.push(`-m "${options.message}"`);
+          flags.push("-m");
+        }
+        command = parts.join(" ");
+        explanation = `Stashes current changes${options.message ? ` with message "${options.message}"` : ""}`;
+      } else if (action === "pop") {
+        command = options.index !== void 0 ? `git stash pop stash@{${options.index}}` : "git stash pop";
+        explanation = `Pops the${options.index !== void 0 ? ` stash@{${options.index}}` : " latest"} stash and applies it`;
+      } else if (action === "list") {
+        command = "git stash list";
+        explanation = "Lists all stashed changes";
+      } else if (action === "drop") {
+        command = options.index !== void 0 ? `git stash drop stash@{${options.index}}` : "git stash drop";
+        explanation = `Drops the${options.index !== void 0 ? ` stash@{${options.index}}` : " latest"} stash`;
+      } else if (action === "apply") {
+        command = options.index !== void 0 ? `git stash apply stash@{${options.index}}` : "git stash apply";
+        explanation = `Applies the${options.index !== void 0 ? ` stash@{${options.index}}` : " latest"} stash without removing it`;
+      } else {
+        return { error: `Unknown stash action: ${action}` };
+      }
+      return { command, explanation, flags };
+    }
+    case "tag": {
+      if (!options.name) {
+        return { error: "tag requires a name" };
+      }
+      const flags = [];
+      const parts = ["git", "tag"];
+      if (options.delete) {
+        flags.push("-d");
+        parts.push("-d", String(options.name));
+        return { command: parts.join(" "), explanation: `Deletes tag "${options.name}"`, flags };
+      }
+      if (options.message) {
+        flags.push("-m");
+        parts.push(`-m "${options.message}"`);
+      }
+      parts.push(String(options.name));
+      if (options.ref) {
+        parts.push(String(options.ref));
+      }
+      return {
+        command: parts.join(" "),
+        explanation: `Creates a tag "${options.name}"${options.ref ? ` at ${options.ref}` : ""}${options.message ? ` with message "${options.message}"` : ""}`,
+        flags
+      };
+    }
+    case "remote": {
+      const action = options.action || "list";
+      const flags = [];
+      let command = "";
+      let explanation = "";
+      if (action === "list") {
+        command = "git remote";
+        explanation = "Lists all remote connections";
+      } else if (action === "add") {
+        command = `git remote add ${options.name} ${options.url}`;
+        explanation = `Adds a new remote "${options.name}" pointing to "${options.url}"`;
+      } else if (action === "remove") {
+        command = `git remote remove ${options.name}`;
+        explanation = `Removes the remote "${options.name}"`;
+      } else if (action === "rename") {
+        command = `git remote rename ${options.name} ${options.newName}`;
+        explanation = `Renames remote "${options.name}" to "${options.newName}"`;
+      } else {
+        return { error: `Unknown remote action: ${action}` };
+      }
+      return { command, explanation, flags };
+    }
+    case "reset": {
+      const ref = options.ref || "HEAD";
+      const mode = options.mode || "mixed";
+      const flags = [];
+      const parts = ["git", "reset"];
+      if (options.file) {
+        parts.push(ref, "--", String(options.file));
+        return { command: parts.join(" "), explanation: `Resets the file "${options.file}" to ${ref}`, flags };
+      }
+      flags.push(`--${mode}`);
+      parts.push(`--${mode}`, ref);
+      return { command: parts.join(" "), explanation: `Resets HEAD to ${ref} using ${mode} mode`, flags };
+    }
+    case "cherry-pick": {
+      if (!options.commit) {
+        return { error: "cherry-pick requires a commit" };
+      }
+      const flags = [];
+      const parts = ["git", "cherry-pick"];
+      if (options.noCommit) {
+        flags.push("-n");
+        parts.push("-n");
+      }
+      parts.push(String(options.commit));
+      return {
+        command: parts.join(" "),
+        explanation: `Applies the changes from commit "${options.commit}"${options.noCommit ? " without creating a new commit" : ""}`,
+        flags
+      };
+    }
+    case "log": {
+      const flags = [];
+      const parts = ["git", "log"];
+      if (options.graph) {
+        flags.push("--graph");
+        parts.push("--graph");
+      }
+      if (options.oneline) {
+        flags.push("--oneline");
+        parts.push("--oneline");
+      }
+      if (options.count !== void 0) {
+        flags.push("-n");
+        parts.push(`-n ${options.count}`);
+      }
+      if (options.author) {
+        flags.push("--author");
+        parts.push(`--author="${options.author}"`);
+      }
+      if (options.since) {
+        flags.push("--since");
+        parts.push(`--since="${options.since}"`);
+      }
+      return {
+        command: parts.join(" "),
+        explanation: `Shows commit history${options.oneline ? " in condensed format" : ""}${options.count !== void 0 ? `, limited to ${options.count} commits` : ""}${options.author ? ` by "${options.author}"` : ""}${options.since ? ` since "${options.since}"` : ""}`,
+        flags
+      };
+    }
+    case "diff": {
+      const flags = [];
+      const parts = ["git", "diff"];
+      if (options.cached) {
+        flags.push("--cached");
+        parts.push("--cached");
+      }
+      if (options.stat) {
+        flags.push("--stat");
+        parts.push("--stat");
+      }
+      if (options.ref1) {
+        parts.push(String(options.ref1));
+      }
+      if (options.ref2) {
+        parts.push(String(options.ref2));
+      }
+      if (options.file) {
+        parts.push("--", String(options.file));
+      }
+      return {
+        command: parts.join(" "),
+        explanation: `Shows differences${options.cached ? " between index and last commit" : ""}${options.ref1 ? ` for ${options.ref1}${options.ref2 ? `..${options.ref2}` : ""}` : ""}${options.file ? ` in file "${options.file}"` : ""}`,
+        flags
+      };
+    }
+    case "clone": {
+      if (!options.url) {
+        return { error: "clone requires a url" };
+      }
+      const flags = [];
+      const parts = ["git", "clone"];
+      if (options.depth !== void 0) {
+        flags.push("--depth");
+        parts.push(`--depth ${options.depth}`);
+      }
+      if (options.branch) {
+        flags.push("-b");
+        parts.push(`-b ${options.branch}`);
+      }
+      parts.push(String(options.url));
+      if (options.directory) {
+        parts.push(String(options.directory));
+      }
+      return {
+        command: parts.join(" "),
+        explanation: `Clones the repository at "${options.url}"${options.directory ? ` into "${options.directory}"` : ""}${options.branch ? ` on branch "${options.branch}"` : ""}${options.depth !== void 0 ? ` with depth ${options.depth}` : ""}`,
+        flags
+      };
+    }
+    case "push": {
+      const remote = options.remote || "origin";
+      const flags = [];
+      const parts = ["git", "push"];
+      if (options.force) {
+        flags.push("--force");
+        parts.push("--force");
+      }
+      if (options.setUpstream) {
+        flags.push("-u");
+        parts.push("-u");
+      }
+      if (options.tags) {
+        flags.push("--tags");
+        parts.push("--tags");
+      }
+      parts.push(remote);
+      if (options.branch) {
+        parts.push(String(options.branch));
+      }
+      return {
+        command: parts.join(" "),
+        explanation: `Pushes to remote "${remote}"${options.branch ? ` branch "${options.branch}"` : ""}${options.force ? " (force push)" : ""}${options.setUpstream ? ", setting upstream tracking" : ""}`,
+        flags
+      };
+    }
+    case "pull": {
+      const remote = options.remote || "origin";
+      const flags = [];
+      const parts = ["git", "pull"];
+      if (options.rebase) {
+        flags.push("--rebase");
+        parts.push("--rebase");
+      }
+      parts.push(remote);
+      if (options.branch) {
+        parts.push(String(options.branch));
+      }
+      return {
+        command: parts.join(" "),
+        explanation: `Pulls from remote "${remote}"${options.branch ? ` branch "${options.branch}"` : ""}${options.rebase ? " using rebase" : ""}`,
+        flags
+      };
+    }
+    case "fetch": {
+      const remote = options.remote || "origin";
+      const flags = [];
+      const parts = ["git", "fetch"];
+      if (options.all) {
+        flags.push("--all");
+        parts.push("--all");
+      } else {
+        parts.push(remote);
+      }
+      if (options.prune) {
+        flags.push("--prune");
+        parts.push("--prune");
+      }
+      if (options.tags) {
+        flags.push("--tags");
+        parts.push("--tags");
+      }
+      return {
+        command: parts.join(" "),
+        explanation: `Fetches from ${options.all ? "all remotes" : `remote "${remote}"`}${options.prune ? ", pruning deleted remote branches" : ""}${options.tags ? ", including tags" : ""}`,
+        flags
+      };
+    }
+    default:
+      return { error: `Unknown operation: ${operation}` };
+  }
+}
+function parseGitCommand(command) {
+  const trimmed = command.trim();
+  if (!trimmed.startsWith("git ")) {
+    return { error: "Not a git command" };
+  }
+  const tokens = trimmed.split(/\s+/);
+  const op = tokens[1];
+  const validOps = [
+    "commit",
+    "branch",
+    "checkout",
+    "merge",
+    "rebase",
+    "stash",
+    "tag",
+    "remote",
+    "reset",
+    "cherry-pick",
+    "log",
+    "diff",
+    "clone",
+    "push",
+    "pull",
+    "fetch"
+  ];
+  if (!validOps.includes(op)) {
+    return { error: "Unknown operation" };
+  }
+  const options = {};
+  const rest = tokens.slice(2);
+  switch (op) {
+    case "log": {
+      for (let i = 0; i < rest.length; i++) {
+        if (rest[i] === "--oneline") options.oneline = true;
+        else if (rest[i] === "--graph") options.graph = true;
+        else if (rest[i] === "-n" && rest[i + 1]) options.count = Number(rest[++i]);
+        else if (rest[i].startsWith("--author=")) options.author = rest[i].replace("--author=", "").replace(/^"|"$/g, "");
+        else if (rest[i].startsWith("--since=")) options.since = rest[i].replace("--since=", "").replace(/^"|"$/g, "");
+      }
+      break;
+    }
+    case "commit": {
+      for (let i = 0; i < rest.length; i++) {
+        if (rest[i] === "--amend") options.amend = true;
+        else if (rest[i] === "--no-verify") options.noVerify = true;
+        else if (rest[i] === "-a" || rest[i] === "--all") options.all = true;
+        else if ((rest[i] === "-m" || rest[i] === "--message") && rest[i + 1]) options.message = rest[++i].replace(/^"|"$/g, "");
+      }
+      break;
+    }
+    case "push": {
+      const positional = [];
+      for (let i = 0; i < rest.length; i++) {
+        if (rest[i] === "--force") options.force = true;
+        else if (rest[i] === "-u" || rest[i] === "--set-upstream") options.setUpstream = true;
+        else if (rest[i] === "--tags") options.tags = true;
+        else if (!rest[i].startsWith("-")) positional.push(rest[i]);
+      }
+      if (positional[0]) options.remote = positional[0];
+      if (positional[1]) options.branch = positional[1];
+      break;
+    }
+    case "pull": {
+      const positional = [];
+      for (let i = 0; i < rest.length; i++) {
+        if (rest[i] === "--rebase") options.rebase = true;
+        else if (!rest[i].startsWith("-")) positional.push(rest[i]);
+      }
+      if (positional[0]) options.remote = positional[0];
+      if (positional[1]) options.branch = positional[1];
+      break;
+    }
+    case "fetch": {
+      const positional = [];
+      for (let i = 0; i < rest.length; i++) {
+        if (rest[i] === "--all") options.all = true;
+        else if (rest[i] === "--prune" || rest[i] === "-p") options.prune = true;
+        else if (rest[i] === "--tags") options.tags = true;
+        else if (!rest[i].startsWith("-")) positional.push(rest[i]);
+      }
+      if (positional[0]) options.remote = positional[0];
+      break;
+    }
+    case "checkout": {
+      for (let i = 0; i < rest.length; i++) {
+        if (rest[i] === "-b") options.newBranch = true;
+        else if (rest[i] === "--" && rest[i + 1]) options.file = rest[++i];
+        else if (!rest[i].startsWith("-")) options.branch = rest[i];
+      }
+      break;
+    }
+    case "branch": {
+      const positional = [];
+      for (let i = 0; i < rest.length; i++) {
+        if (rest[i] === "-d") {
+          options.action = "delete";
+        } else if (rest[i] === "-D") {
+          options.action = "delete";
+          options.force = true;
+        } else if (rest[i] === "-m") {
+          options.action = "rename";
+          if (rest[i + 1]) positional.push(rest[++i]);
+          if (rest[i + 1]) positional.push(rest[++i]);
+        } else if (!rest[i].startsWith("-")) positional.push(rest[i]);
+      }
+      if (!options.action) {
+        options.action = positional.length > 0 ? "create" : "list";
+      }
+      if (positional[0]) options.name = positional[0];
+      if (positional[1]) options.newName = positional[1];
+      break;
+    }
+    case "merge": {
+      const positional = [];
+      for (let i = 0; i < rest.length; i++) {
+        if (rest[i] === "--no-ff") options.noFF = true;
+        else if (rest[i] === "--squash") options.squash = true;
+        else if ((rest[i] === "-m" || rest[i] === "--message") && rest[i + 1]) options.message = rest[++i].replace(/^"|"$/g, "");
+        else if (!rest[i].startsWith("-")) positional.push(rest[i]);
+      }
+      if (positional[0]) options.branch = positional[0];
+      break;
+    }
+    case "rebase": {
+      const positional = [];
+      for (let i = 0; i < rest.length; i++) {
+        if (rest[i] === "-i" || rest[i] === "--interactive") options.interactive = true;
+        else if (rest[i] === "--onto" && rest[i + 1]) options.onto = rest[++i];
+        else if (!rest[i].startsWith("-")) positional.push(rest[i]);
+      }
+      if (positional[0]) options.branch = positional[0];
+      break;
+    }
+    case "reset": {
+      const positional = [];
+      for (let i = 0; i < rest.length; i++) {
+        if (rest[i] === "--soft") options.mode = "soft";
+        else if (rest[i] === "--mixed") options.mode = "mixed";
+        else if (rest[i] === "--hard") options.mode = "hard";
+        else if (rest[i] === "--" && rest[i + 1]) options.file = rest[++i];
+        else if (!rest[i].startsWith("-")) positional.push(rest[i]);
+      }
+      if (positional[0]) options.ref = positional[0];
+      break;
+    }
+    case "stash": {
+      if (rest[0] === "pop") options.action = "pop";
+      else if (rest[0] === "list") options.action = "list";
+      else if (rest[0] === "drop") options.action = "drop";
+      else if (rest[0] === "apply") options.action = "apply";
+      else options.action = "push";
+      break;
+    }
+    case "tag": {
+      const positional = [];
+      for (let i = 0; i < rest.length; i++) {
+        if (rest[i] === "-d") options.delete = true;
+        else if ((rest[i] === "-m" || rest[i] === "--message") && rest[i + 1]) options.message = rest[++i].replace(/^"|"$/g, "");
+        else if (!rest[i].startsWith("-")) positional.push(rest[i]);
+      }
+      if (positional[0]) options.name = positional[0];
+      if (positional[1]) options.ref = positional[1];
+      break;
+    }
+    case "clone": {
+      const positional = [];
+      for (let i = 0; i < rest.length; i++) {
+        if (rest[i] === "--depth" && rest[i + 1]) options.depth = Number(rest[++i]);
+        else if ((rest[i] === "-b" || rest[i] === "--branch") && rest[i + 1]) options.branch = rest[++i];
+        else if (!rest[i].startsWith("-")) positional.push(rest[i]);
+      }
+      if (positional[0]) options.url = positional[0];
+      if (positional[1]) options.directory = positional[1];
+      break;
+    }
+    case "diff": {
+      const positional = [];
+      for (let i = 0; i < rest.length; i++) {
+        if (rest[i] === "--cached") options.cached = true;
+        else if (rest[i] === "--stat") options.stat = true;
+        else if (rest[i] === "--" && rest[i + 1]) options.file = rest[++i];
+        else if (!rest[i].startsWith("-")) positional.push(rest[i]);
+      }
+      if (positional[0]) options.ref1 = positional[0];
+      if (positional[1]) options.ref2 = positional[1];
+      break;
+    }
+    case "cherry-pick": {
+      for (let i = 0; i < rest.length; i++) {
+        if (rest[i] === "-n" || rest[i] === "--no-commit") options.noCommit = true;
+        else if (!rest[i].startsWith("-")) options.commit = rest[i];
+      }
+      break;
+    }
+    case "remote": {
+      if (rest[0] === "add") {
+        options.action = "add";
+        options.name = rest[1];
+        options.url = rest[2];
+      } else if (rest[0] === "remove") {
+        options.action = "remove";
+        options.name = rest[1];
+      } else if (rest[0] === "rename") {
+        options.action = "rename";
+        options.name = rest[1];
+        options.newName = rest[2];
+      } else options.action = "list";
+      break;
+    }
+  }
+  return { operation: op, options };
+}
+var OFFICIAL_REGISTRY = "docker.io";
+var OFFICIAL_NAMESPACE = "library";
+var DEFAULT_DOCKER_TAG = "latest";
+function parseDockerImage(ref) {
+  if (!ref || typeof ref !== "string" || ref.trim() === "") {
+    return { error: "Empty image reference" };
+  }
+  const trimmed = ref.trim();
+  if (/\s/.test(trimmed)) {
+    return { error: "Image reference must not contain whitespace" };
+  }
+  let registry = OFFICIAL_REGISTRY;
+  let namespace = "";
+  let repository = "";
+  let tag = DEFAULT_DOCKER_TAG;
+  let digest = "";
+  let remaining = trimmed;
+  const digestIdx = remaining.indexOf("@");
+  if (digestIdx !== -1) {
+    digest = remaining.slice(digestIdx + 1);
+    remaining = remaining.slice(0, digestIdx);
+    if (!/^sha256:[a-fA-F0-9]+$/.test(digest)) {
+      return { error: `Invalid digest format: ${digest}` };
+    }
+    tag = "";
+  }
+  const tagIdx = remaining.indexOf(":");
+  if (tagIdx !== -1) {
+    const potentialTag = remaining.slice(tagIdx + 1);
+    const potentialHost = remaining.slice(0, tagIdx);
+    const looksLikeHost = /^(localhost|[a-zA-Z0-9-]+\.[a-zA-Z0-9-]+)$/.test(potentialHost);
+    if (!looksLikeHost || remaining.slice(tagIdx + 1).includes("/")) {
+      const slashAfterColon = remaining.indexOf("/", tagIdx);
+      if (slashAfterColon === -1) {
+        tag = potentialTag;
+        remaining = potentialHost;
+      }
+    }
+  }
+  const parts = remaining.split("/");
+  if (parts.length === 1) {
+    registry = OFFICIAL_REGISTRY;
+    namespace = OFFICIAL_NAMESPACE;
+    repository = parts[0];
+  } else if (parts.length === 2) {
+    const firstPart = parts[0];
+    if (firstPart.includes(".") || firstPart.includes(":") || firstPart === "localhost") {
+      registry = firstPart;
+      namespace = "";
+      repository = parts[1];
+    } else {
+      registry = OFFICIAL_REGISTRY;
+      namespace = firstPart;
+      repository = parts[1];
+    }
+  } else {
+    const firstPart = parts[0];
+    if (firstPart.includes(".") || firstPart.includes(":") || firstPart === "localhost") {
+      registry = firstPart;
+      namespace = parts[1];
+      repository = parts.slice(2).join("/");
+    } else {
+      registry = OFFICIAL_REGISTRY;
+      namespace = parts[0];
+      repository = parts.slice(1).join("/");
+    }
+  }
+  if (repository.includes(":") && tag === DEFAULT_DOCKER_TAG && digest === "") {
+    const repoTagIdx = repository.lastIndexOf(":");
+    tag = repository.slice(repoTagIdx + 1);
+    repository = repository.slice(0, repoTagIdx);
+  }
+  if (!repository) {
+    return { error: "Could not determine repository name" };
+  }
+  if (tag && !isValidTag(tag)) {
+    return { error: `Invalid tag: ${tag}` };
+  }
+  if (digest && tag === DEFAULT_DOCKER_TAG) {
+    tag = "";
+  }
+  const isOfficial = registry === OFFICIAL_REGISTRY && namespace === OFFICIAL_NAMESPACE;
+  return {
+    registry,
+    namespace,
+    repository,
+    tag: tag || (digest ? "" : DEFAULT_DOCKER_TAG),
+    digest,
+    isOfficial
+  };
+}
+function buildDockerImageRef(parsed) {
+  let ref = "";
+  if (parsed.registry === OFFICIAL_REGISTRY && parsed.namespace === OFFICIAL_NAMESPACE) {
+    ref = parsed.repository;
+  } else if (parsed.registry === OFFICIAL_REGISTRY) {
+    ref = parsed.namespace ? `${parsed.namespace}/${parsed.repository}` : parsed.repository;
+  } else {
+    if (parsed.namespace) {
+      ref = `${parsed.registry}/${parsed.namespace}/${parsed.repository}`;
+    } else {
+      ref = `${parsed.registry}/${parsed.repository}`;
+    }
+  }
+  if (parsed.digest) {
+    ref += `@${parsed.digest}`;
+  } else if (parsed.tag) {
+    ref += `:${parsed.tag}`;
+  }
+  return ref;
+}
+function buildDockerPull(parsed) {
+  return `docker pull ${buildDockerImageRef(parsed)}`;
+}
+function buildDockerRun(parsed, containerName) {
+  const image = buildDockerImageRef(parsed);
+  const name = containerName ?? parsed.repository.replace(/[^a-zA-Z0-9_.-]/g, "-");
+  return `docker run -d --name ${name} ${image}`;
+}
+function isValidTag(tag) {
+  if (!tag || tag.length === 0 || tag.length > 128) return false;
+  if (tag.startsWith(".") || tag.startsWith("-")) return false;
+  return /^[a-zA-Z0-9._-]+$/.test(tag);
+}
+function normalizeRef(ref) {
+  const parsed = parseDockerImage(ref);
+  if ("error" in parsed) return ref;
+  const ns = parsed.namespace ? `${parsed.namespace}/` : "";
+  const tagPart = parsed.digest ? `@${parsed.digest}` : parsed.tag ? `:${parsed.tag}` : "";
+  return `${parsed.registry}/${ns}${parsed.repository}${tagPart}`;
+}
+function removeJsComments(code) {
+  let result = "";
+  let i = 0;
+  while (i < code.length) {
+    if (code[i] === '"' || code[i] === "'" || code[i] === "`") {
+      const quote = code[i];
+      result += code[i++];
+      while (i < code.length) {
+        if (code[i] === "\\") {
+          result += code[i++];
+          if (i < code.length) result += code[i++];
+          continue;
+        }
+        result += code[i];
+        if (code[i] === quote) {
+          i++;
+          break;
+        }
+        i++;
+      }
+      continue;
+    }
+    if (code[i] === "/" && code[i + 1] === "/") {
+      while (i < code.length && code[i] !== "\n") i++;
+      continue;
+    }
+    if (code[i] === "/" && code[i + 1] === "*") {
+      i += 2;
+      while (i < code.length) {
+        if (code[i] === "*" && code[i + 1] === "/") {
+          i += 2;
+          break;
+        }
+        i++;
+      }
+      continue;
+    }
+    result += code[i++];
+  }
+  return result;
+}
+function collapseJsWhitespace(code) {
+  let result = code.replace(/[ \t]+/g, " ");
+  result = result.replace(/\n{2,}/g, "\n");
+  result = result.split("\n").map((line) => line.trim()).join("\n");
+  result = result.replace(/^\n+|\n+$/g, "").trim();
+  return result;
+}
+function removeConsoleCalls(code) {
+  return code.replace(/console\.(log|warn|error|debug|info)\s*\([^)]*\)\s*;?/g, "");
+}
+function getJsStats(code) {
+  const lines = code.split("\n").length;
+  const chars = code.length;
+  const functions = (code.match(/\bfunction\b/g) ?? []).length;
+  const variables = (code.match(/\b(var|let|const)\b/g) ?? []).length;
+  return { lines, chars, functions, variables };
+}
+function minifyJs(code, options) {
+  const opts = {
+    removeComments: options?.removeComments ?? true,
+    collapseWhitespace: options?.collapseWhitespace ?? true,
+    removeConsole: options?.removeConsole ?? false,
+    removeSemicolons: options?.removeSemicolons ?? false,
+    mangle: options?.mangle ?? false
+  };
+  const originalSize = code.length;
+  let minified = code;
+  if (opts.removeComments) minified = removeJsComments(minified);
+  if (opts.removeConsole) minified = removeConsoleCalls(minified);
+  if (opts.collapseWhitespace) minified = collapseJsWhitespace(minified);
+  if (opts.removeSemicolons) {
+    minified = minified.replace(/;\s*}/g, "}");
+    minified = minified.replace(/;(\s*\n)/g, "$1");
+  }
+  minified = minified.trim();
+  const minifiedSize = minified.length;
+  const savedBytes = originalSize - minifiedSize;
+  const savedPercent = originalSize === 0 ? 0 : Math.round(savedBytes / originalSize * 100 * 100) / 100;
+  return { original: code, minified, originalSize, minifiedSize, savedBytes, savedPercent };
+}
+var HTTP_METHODS = ["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD", "OPTIONS"];
+function detectSpecVersion(raw) {
+  if (typeof raw.openapi === "string" && raw.openapi.startsWith("3")) return "openapi-3";
+  if (typeof raw.swagger === "string" && raw.swagger.startsWith("2")) return "swagger-2";
+  return "unknown";
+}
+function parseOpenApi3Endpoints(raw) {
+  const endpoints = [];
+  const paths = raw.paths ?? {};
+  for (const [path, pathItem] of Object.entries(paths)) {
+    if (!pathItem || typeof pathItem !== "object") continue;
+    const pi = pathItem;
+    for (const method of HTTP_METHODS) {
+      const op = pi[method.toLowerCase()];
+      if (!op) continue;
+      const parameters = [];
+      const rawParams = op.parameters ?? [];
+      for (const p of rawParams) {
+        if (!p || typeof p !== "object") continue;
+        const param = p;
+        parameters.push({
+          name: String(param.name ?? ""),
+          in: String(param.in ?? ""),
+          required: Boolean(param.required ?? false),
+          description: param.description !== void 0 ? String(param.description) : void 0,
+          schema: param.schema
+        });
+      }
+      let requestBody;
+      if (op.requestBody && typeof op.requestBody === "object") {
+        const rb = op.requestBody;
+        const content = rb.content ?? {};
+        requestBody = { required: Boolean(rb.required ?? false), contentTypes: Object.keys(content) };
+      }
+      const responses = {};
+      const rawResponses = op.responses ?? {};
+      for (const [statusCode, resp] of Object.entries(rawResponses)) {
+        if (!resp || typeof resp !== "object") continue;
+        const r = resp;
+        const content = r.content ?? {};
+        responses[statusCode] = { description: String(r.description ?? ""), contentTypes: Object.keys(content) };
+      }
+      endpoints.push({
+        method,
+        path,
+        summary: op.summary !== void 0 ? String(op.summary) : void 0,
+        description: op.description !== void 0 ? String(op.description) : void 0,
+        tags: Array.isArray(op.tags) ? op.tags.map(String) : [],
+        parameters,
+        requestBody,
+        responses,
+        deprecated: Boolean(op.deprecated ?? false)
+      });
+    }
+  }
+  return endpoints;
+}
+function parseSwagger2Endpoints(raw) {
+  const endpoints = [];
+  const paths = raw.paths ?? {};
+  for (const [path, pathItem] of Object.entries(paths)) {
+    if (!pathItem || typeof pathItem !== "object") continue;
+    const pi = pathItem;
+    for (const method of HTTP_METHODS) {
+      const op = pi[method.toLowerCase()];
+      if (!op) continue;
+      const parameters = [];
+      const rawParams = op.parameters ?? [];
+      let requestBody;
+      for (const p of rawParams) {
+        if (!p || typeof p !== "object") continue;
+        const param = p;
+        if (param.in === "body") {
+          const consumes = Array.isArray(op.consumes) ? op.consumes.map(String) : Array.isArray(raw.consumes) ? raw.consumes.map(String) : ["application/json"];
+          requestBody = { required: Boolean(param.required ?? false), contentTypes: consumes };
+        } else {
+          parameters.push({
+            name: String(param.name ?? ""),
+            in: String(param.in ?? ""),
+            required: Boolean(param.required ?? false),
+            description: param.description !== void 0 ? String(param.description) : void 0,
+            schema: param.schema
+          });
+        }
+      }
+      const responses = {};
+      const rawResponses = op.responses ?? {};
+      for (const [statusCode, resp] of Object.entries(rawResponses)) {
+        if (!resp || typeof resp !== "object") continue;
+        const r = resp;
+        const produces = Array.isArray(op.produces) ? op.produces.map(String) : Array.isArray(raw.produces) ? raw.produces.map(String) : [];
+        responses[statusCode] = { description: String(r.description ?? ""), contentTypes: produces };
+      }
+      endpoints.push({
+        method,
+        path,
+        summary: op.summary !== void 0 ? String(op.summary) : void 0,
+        description: op.description !== void 0 ? String(op.description) : void 0,
+        tags: Array.isArray(op.tags) ? op.tags.map(String) : [],
+        parameters,
+        requestBody,
+        responses,
+        deprecated: Boolean(op.deprecated ?? false)
+      });
+    }
+  }
+  return endpoints;
+}
+function extractBaseUrl(raw, version) {
+  if (version === "openapi-3") {
+    const servers = raw.servers;
+    if (Array.isArray(servers) && servers.length > 0) return String(servers[0].url ?? "");
+    return void 0;
+  }
+  if (version === "swagger-2") {
+    const scheme = Array.isArray(raw.schemes) ? raw.schemes[0] : "https";
+    const host = raw.host ? String(raw.host) : void 0;
+    const basePath = raw.basePath ? String(raw.basePath) : "";
+    if (host) return `${scheme}://${host}${basePath}`;
+    return basePath || void 0;
+  }
+  return void 0;
+}
+function extractSchemas(raw, version) {
+  if (version === "openapi-3") {
+    const components = raw.components;
+    const schemas = components?.schemas;
+    return schemas ? Object.keys(schemas) : [];
+  }
+  if (version === "swagger-2") {
+    const definitions = raw.definitions;
+    return definitions ? Object.keys(definitions) : [];
+  }
+  return [];
+}
+function parseSpec(input) {
+  if (!input.trim()) return { error: "Empty input" };
+  let raw;
+  try {
+    raw = JSON.parse(input);
+  } catch {
+    try {
+      raw = load(input);
+    } catch (e) {
+      return { error: `Failed to parse input as JSON or YAML: ${String(e)}` };
+    }
+  }
+  if (!raw || typeof raw !== "object") return { error: "Input did not parse to an object" };
+  const version = detectSpecVersion(raw);
+  const infoRaw = raw.info ?? {};
+  const info = {
+    title: String(infoRaw.title ?? "Untitled"),
+    version: String(infoRaw.version ?? ""),
+    description: infoRaw.description !== void 0 ? String(infoRaw.description) : void 0,
+    baseUrl: extractBaseUrl(raw, version)
+  };
+  const endpoints = version === "openapi-3" ? parseOpenApi3Endpoints(raw) : version === "swagger-2" ? parseSwagger2Endpoints(raw) : [];
+  const tagSet = /* @__PURE__ */ new Set();
+  for (const ep of endpoints) {
+    for (const t of ep.tags) tagSet.add(t);
+  }
+  const rawTags = raw.tags;
+  if (Array.isArray(rawTags)) {
+    for (const t of rawTags) {
+      if (t.name) tagSet.add(String(t.name));
+    }
+  }
+  return { version, info, endpoints, tags: [...tagSet], schemas: extractSchemas(raw, version) };
+}
+function getEndpointsByTag(spec, tag) {
+  return spec.endpoints.filter((ep) => ep.tags.includes(tag));
+}
+function searchEndpoints(spec, query) {
+  const q = query.toLowerCase();
+  return spec.endpoints.filter(
+    (ep) => ep.path.toLowerCase().includes(q) || ep.method.toLowerCase().includes(q) || (ep.summary ?? "").toLowerCase().includes(q) || (ep.description ?? "").toLowerCase().includes(q) || ep.tags.some((t) => t.toLowerCase().includes(q))
+  );
+}
+function getMethodColor(method) {
+  const colors = {
+    GET: "green",
+    POST: "blue",
+    PUT: "amber",
+    PATCH: "purple",
+    DELETE: "red",
+    HEAD: "gray",
+    OPTIONS: "gray"
+  };
+  return colors[method.toUpperCase()] ?? "gray";
+}
+function parseEnv(input) {
+  const entries = [];
+  const comments = [];
+  const errors = [];
+  const keyCount = {};
+  const rawLines = input.split("\n");
+  const lines = [];
+  let i = 0;
+  while (i < rawLines.length) {
+    let line = rawLines[i];
+    while (line.endsWith("\\") && i + 1 < rawLines.length) {
+      line = line.slice(0, -1) + rawLines[i + 1];
+      i++;
+    }
+    lines.push(line);
+    i++;
+  }
+  for (let lineIdx = 0; lineIdx < lines.length; lineIdx++) {
+    const lineNum = lineIdx + 1;
+    const line = lines[lineIdx];
+    const trimmed = line.trim();
+    if (trimmed === "") continue;
+    if (trimmed.startsWith("#")) {
+      comments.push({ line: lineNum, text: trimmed.slice(1).trim() });
+      continue;
+    }
+    const eqIdx = trimmed.indexOf("=");
+    if (eqIdx === -1) {
+      errors.push({ line: lineNum, message: `Invalid line: missing '='` });
+      continue;
+    }
+    const key = trimmed.slice(0, eqIdx).trim();
+    if (!validateEnvKey(key)) {
+      errors.push({ line: lineNum, message: `Invalid key: '${key}'` });
+      continue;
+    }
+    const rest = trimmed.slice(eqIdx + 1);
+    let value = "";
+    let hasQuotes = false;
+    let inlineComment;
+    if (rest.startsWith('"')) {
+      hasQuotes = true;
+      const closeIdx = rest.indexOf('"', 1);
+      if (closeIdx === -1) {
+        errors.push({ line: lineNum, message: `Unclosed double quote for key '${key}'` });
+        continue;
+      }
+      value = rest.slice(1, closeIdx);
+      const afterQuote = rest.slice(closeIdx + 1).trim();
+      if (afterQuote.startsWith("#")) inlineComment = afterQuote.slice(1).trim();
+    } else if (rest.startsWith("'")) {
+      hasQuotes = true;
+      const closeIdx = rest.indexOf("'", 1);
+      if (closeIdx === -1) {
+        errors.push({ line: lineNum, message: `Unclosed single quote for key '${key}'` });
+        continue;
+      }
+      value = rest.slice(1, closeIdx);
+      const afterQuote = rest.slice(closeIdx + 1).trim();
+      if (afterQuote.startsWith("#")) inlineComment = afterQuote.slice(1).trim();
+    } else {
+      const hashIdx = rest.indexOf("#");
+      if (hashIdx !== -1) {
+        inlineComment = rest.slice(hashIdx + 1).trim();
+        value = rest.slice(0, hashIdx).trim();
+      } else {
+        value = rest.trim();
+      }
+    }
+    const interpolated = /\$\{[^}]+\}/.test(value);
+    keyCount[key] = (keyCount[key] ?? 0) + 1;
+    const entry = { key, value, line: lineNum, hasQuotes, interpolated };
+    if (inlineComment !== void 0) entry.comment = inlineComment;
+    entries.push(entry);
+  }
+  const duplicates = Object.entries(keyCount).filter(([, count]) => count > 1).map(([key]) => key);
+  return { entries, comments, errors, duplicates };
+}
+function envToJson(input) {
+  const result = parseEnv(input);
+  if (result.errors.length > 0) {
+    return { error: result.errors.map((e) => `Line ${e.line}: ${e.message}`).join("; ") };
+  }
+  const obj = {};
+  for (const entry of result.entries) {
+    obj[entry.key] = entry.value;
+  }
+  return JSON.stringify(obj, null, 2);
+}
+function envToExport(input) {
+  const result = parseEnv(input);
+  return result.entries.map((entry) => `export ${entry.key}="${entry.value.replace(/"/g, '\\"')}"`).join("\n");
+}
+function validateEnvKey(key) {
+  return /^[A-Za-z_][A-Za-z0-9_]*$/.test(key);
+}
+
+export { ALL_FLAGS, CHEATSHEET, OPERATIONS, SQL_DEFAULT_OPTIONS, buildDockerPull, buildDockerRun, buildGitCommand, code_exports, collapseHtmlWhitespace, collapseJsWhitespace, detectDialect, detectOperationType, envToExport, envToJson, formatGql, formatHtml, formatSql, getEndpointsByTag, getHtmlStats, getJsStats, getMethodColor, isValidTag, minifyGql, minifyHtml, minifyJs, minifySql, normalizeRef, parseDockerImage, parseEnv, parseGitCommand, parseSpec, removeConsoleCalls, removeEmptyAttributes, removeHtmlComments, removeJsComments, removeRedundantAttributes, searchCheatsheet, searchEndpoints, splitStatements, testPattern, testRegex, validateEnvKey };