@utilix-tech/sdk 0.1.0

package/dist/chunk-W4UBLYFU.js

@@ -0,0 +1,1219 @@
+import { __export } from './chunk-MLKGABMK.js';
+import { createHmac } from 'crypto';
+
+// src/tools/api.ts
+var api_exports = {};
+__export(api_exports, {
+  COMMON_HEADERS: () => COMMON_HEADERS,
+  COMMON_PRESETS: () => COMMON_PRESETS,
+  CORS_COMMON_HEADERS: () => CORS_COMMON_HEADERS,
+  DEFAULT_CORS_CONFIG: () => DEFAULT_CORS_CONFIG,
+  DIRECTIVE_DESCRIPTIONS: () => DIRECTIVE_DESCRIPTIONS,
+  HTTP_METHODS: () => HTTP_METHODS,
+  SUPPORTED_LANGUAGES: () => SUPPORTED_LANGUAGES,
+  addParam: () => addParam,
+  base64urlDecode: () => base64urlDecode,
+  base64urlEncode: () => base64urlEncode,
+  buildCurl: () => buildCurl,
+  buildCurlMultiline: () => buildCurlMultiline,
+  buildUrl: () => buildUrl,
+  convertToCode: () => convertToCode,
+  decodeJwt: () => decodeJwt,
+  decodeUrlComponent: () => decodeUrlComponent,
+  detectFormat: () => detectFormat,
+  encodeUrlComponent: () => encodeUrlComponent,
+  extractJsonPaths: () => extractJsonPaths,
+  formatJwtJson: () => formatJwtJson,
+  formatResponse: () => formatResponse,
+  generateCors: () => generateCors,
+  generateCspHeader: () => generateCspHeader,
+  generateFullHeader: () => generateFullHeader,
+  generateMetaHtml: () => generateMetaHtml,
+  getParam: () => getParam,
+  getStats: () => getStats,
+  isValidUrl: () => isValidUrl,
+  normalizeUrl: () => normalizeUrl,
+  parseCspHeader: () => parseCspHeader,
+  parseCurl: () => parseCurl,
+  parseCurlCommand: () => parseCurlCommand,
+  parseMetaTags: () => parseMetaTags,
+  parseUrl: () => parseUrl,
+  removeParam: () => removeParam,
+  signJwt: () => signJwt,
+  validateCorsConfig: () => validateCorsConfig,
+  validateCspConfig: () => validateCspConfig,
+  validateOgTags: () => validateOgTags
+});
+function escapeShell(value) {
+  return `'${value.replace(/'/g, "'\\''")}'`;
+}
+function buildCurl(config) {
+  const parts = ["curl"];
+  if (config.verbose) parts.push("-v");
+  if (config.silent) parts.push("-s");
+  if (config.followRedirects) parts.push("-L");
+  if (config.timeout !== void 0) parts.push(`--max-time ${config.timeout}`);
+  if (config.method !== "GET") {
+    parts.push(`-X ${config.method}`);
+  }
+  for (const header of config.headers) {
+    if (header.key.trim()) {
+      parts.push(`-H ${escapeShell(`${header.key}: ${header.value}`)}`);
+    }
+  }
+  if (config.body !== void 0 && config.body !== "") {
+    parts.push(`-d ${escapeShell(config.body)}`);
+  }
+  parts.push(escapeShell(config.url));
+  return parts.join(" ");
+}
+function buildCurlMultiline(config) {
+  const parts = ["curl"];
+  if (config.verbose) parts.push("-v");
+  if (config.silent) parts.push("-s");
+  if (config.followRedirects) parts.push("-L");
+  if (config.timeout !== void 0) parts.push(`--max-time ${config.timeout}`);
+  if (config.method !== "GET") {
+    parts.push(`-X ${config.method}`);
+  }
+  for (const header of config.headers) {
+    if (header.key.trim()) {
+      parts.push(`-H ${escapeShell(`${header.key}: ${header.value}`)}`);
+    }
+  }
+  if (config.body !== void 0 && config.body !== "") {
+    parts.push(`-d ${escapeShell(config.body)}`);
+  }
+  parts.push(escapeShell(config.url));
+  return parts.join(" \\\n  ");
+}
+function unquoteCurl(s) {
+  if (s.startsWith("'") && s.endsWith("'") || s.startsWith('"') && s.endsWith('"')) {
+    return s.slice(1, -1).replace(/\\'/g, "'").replace(/\\"/g, '"');
+  }
+  return s;
+}
+function parseCurl(command) {
+  const trimmed = command.trim().replace(/\\\n\s*/g, " ");
+  if (!trimmed.startsWith("curl ") && trimmed !== "curl") {
+    return { error: 'Command must start with "curl"' };
+  }
+  const config = {
+    method: "GET",
+    url: "",
+    headers: []
+  };
+  const tokenRe = /(?:'(?:[^'\\]|\\.)*'|"(?:[^"\\]|\\.)*"|\S)+/g;
+  const tokens = trimmed.match(tokenRe) || [];
+  let i = 1;
+  while (i < tokens.length) {
+    const token = tokens[i];
+    if (token === "-v" || token === "--verbose") {
+      config.verbose = true;
+      i++;
+    } else if (token === "-s" || token === "--silent") {
+      config.silent = true;
+      i++;
+    } else if (token === "-L" || token === "--location") {
+      config.followRedirects = true;
+      i++;
+    } else if (token === "--max-time" || token === "-m") {
+      i++;
+      if (i < tokens.length) {
+        config.timeout = parseFloat(tokens[i]);
+        i++;
+      }
+    } else if (token === "-X" || token === "--request") {
+      i++;
+      if (i < tokens.length) {
+        config.method = tokens[i].toUpperCase();
+        i++;
+      }
+    } else if (token === "-H" || token === "--header") {
+      i++;
+      if (i < tokens.length) {
+        const raw = unquoteCurl(tokens[i]);
+        const colonIdx = raw.indexOf(":");
+        if (colonIdx !== -1) {
+          config.headers.push({
+            key: raw.slice(0, colonIdx).trim(),
+            value: raw.slice(colonIdx + 1).trim()
+          });
+        }
+        i++;
+      }
+    } else if (token === "-d" || token === "--data" || token === "--data-raw") {
+      i++;
+      if (i < tokens.length) {
+        config.body = unquoteCurl(tokens[i]);
+        if (config.method === "GET") config.method = "POST";
+        i++;
+      }
+    } else if (!token.startsWith("-")) {
+      config.url = unquoteCurl(token);
+      i++;
+    } else {
+      i++;
+    }
+  }
+  if (!config.url) {
+    return { error: "No URL found in command" };
+  }
+  return config;
+}
+var HTTP_METHODS = ["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD", "OPTIONS"];
+var COMMON_HEADERS = [
+  { label: "JSON Content-Type", key: "Content-Type", value: "application/json" },
+  { label: "Form Content-Type", key: "Content-Type", value: "application/x-www-form-urlencoded" },
+  { label: "Accept JSON", key: "Accept", value: "application/json" },
+  { label: "Accept Any", key: "Accept", value: "*/*" },
+  { label: "Bearer Auth", key: "Authorization", value: "Bearer <token>" },
+  { label: "Basic Auth", key: "Authorization", value: "Basic <base64>" },
+  { label: "User Agent", key: "User-Agent", value: "Mozilla/5.0" },
+  { label: "Cache Control", key: "Cache-Control", value: "no-cache" },
+  { label: "CORS Origin", key: "Origin", value: "https://example.com" },
+  { label: "API Key Header", key: "X-API-Key", value: "<api-key>" }
+];
+var SUPPORTED_LANGUAGES = [
+  { value: "fetch", label: "JavaScript (fetch)" },
+  { value: "axios", label: "JavaScript (axios)" },
+  { value: "python-requests", label: "Python (requests)" },
+  { value: "go-http", label: "Go (net/http)" },
+  { value: "php-curl", label: "PHP (cURL)" },
+  { value: "ruby-net-http", label: "Ruby (Net::HTTP)" }
+];
+function tokenizeCurlCommand(curl) {
+  const tokens = [];
+  let i = 0;
+  const s = curl.trim();
+  while (i < s.length) {
+    while (i < s.length && /\s/.test(s[i])) i++;
+    if (i >= s.length) break;
+    if (s[i] === "'" || s[i] === '"') {
+      const quote = s[i];
+      i++;
+      let token = "";
+      while (i < s.length && s[i] !== quote) {
+        if (s[i] === "\\" && i + 1 < s.length) {
+          i++;
+          token += s[i];
+        } else {
+          token += s[i];
+        }
+        i++;
+      }
+      i++;
+      tokens.push(token);
+    } else {
+      let token = "";
+      while (i < s.length && !/\s/.test(s[i])) {
+        token += s[i];
+        i++;
+      }
+      tokens.push(token);
+    }
+  }
+  return tokens;
+}
+function parseCurlCommand(curl) {
+  const trimmed = curl.trim();
+  if (!trimmed.startsWith("curl")) {
+    return { error: 'Input must start with "curl"' };
+  }
+  const tokens = tokenizeCurlCommand(trimmed);
+  if (tokens[0] !== "curl") return { error: 'Input must start with "curl"' };
+  let method = "GET";
+  let url = "";
+  const headers = {};
+  let body;
+  let followRedirects = false;
+  let i = 1;
+  while (i < tokens.length) {
+    const token = tokens[i];
+    if (token === "-X" || token === "--request") {
+      i++;
+      method = tokens[i]?.toUpperCase() ?? "GET";
+    } else if (token === "-H" || token === "--header") {
+      i++;
+      const header = tokens[i] ?? "";
+      const colonIdx = header.indexOf(":");
+      if (colonIdx === -1) return { error: `Invalid header: ${header}` };
+      const key = header.slice(0, colonIdx).trim();
+      const val = header.slice(colonIdx + 1).trim();
+      headers[key] = val;
+    } else if (token === "-d" || token === "--data" || token === "--data-raw" || token === "--data-binary") {
+      i++;
+      body = tokens[i];
+      if (method === "GET") method = "POST";
+    } else if (token === "-L" || token === "--location") {
+      followRedirects = true;
+    } else if (token === "--compressed") ; else if (!token.startsWith("-")) {
+      url = token;
+    }
+    i++;
+  }
+  if (!url) return { error: "No URL found in curl command" };
+  const result = { method, url, headers };
+  if (body !== void 0) result.body = body;
+  if (followRedirects) result.followRedirects = true;
+  return result;
+}
+function generateFetch(cmd) {
+  const hasBody = cmd.body !== void 0;
+  const hasHeaders = Object.keys(cmd.headers).length > 0;
+  const options = [];
+  if (cmd.method !== "GET") options.push(`  method: '${cmd.method}'`);
+  if (hasHeaders) {
+    const entries = Object.entries(cmd.headers).map(([k, v]) => `    '${k}': '${v}'`).join(",\n");
+    options.push(`  headers: {
+${entries}
+  }`);
+  }
+  if (hasBody) options.push(`  body: ${JSON.stringify(cmd.body)}`);
+  if (options.length === 0) {
+    return `const response = await fetch('${cmd.url}');
+const data = await response.json();
+console.log(data);`;
+  }
+  return `const response = await fetch('${cmd.url}', {
+${options.join(",\n")}
+});
+const data = await response.json();
+console.log(data);`;
+}
+function generateAxios(cmd) {
+  const method = cmd.method.toLowerCase();
+  const hasHeaders = Object.keys(cmd.headers).length > 0;
+  const lines = ["import axios from 'axios';", ""];
+  const configParts = [];
+  if (hasHeaders) {
+    const entries = Object.entries(cmd.headers).map(([k, v]) => `    '${k}': '${v}'`).join(",\n");
+    configParts.push(`  headers: {
+${entries}
+  }`);
+  }
+  if (cmd.body !== void 0 && (method === "post" || method === "put" || method === "patch")) {
+    const config = configParts.length > 0 ? `,
+{
+${configParts.join(",\n")}
+}` : "";
+    lines.push(`const response = await axios.${method}('${cmd.url}', ${JSON.stringify(cmd.body)}${config});`);
+  } else if (configParts.length > 0) {
+    lines.push(`const response = await axios.${method}('${cmd.url}', {
+${configParts.join(",\n")}
+});`);
+  } else {
+    lines.push(`const response = await axios.${method}('${cmd.url}');`);
+  }
+  lines.push("console.log(response.data);");
+  return lines.join("\n");
+}
+function generatePythonRequests(cmd) {
+  const lines = ["import requests", ""];
+  const method = cmd.method.toLowerCase();
+  const hasHeaders = Object.keys(cmd.headers).length > 0;
+  const args = [`'${cmd.url}'`];
+  if (hasHeaders) {
+    const entries = Object.entries(cmd.headers).map(([k, v]) => `    '${k}': '${v}'`).join(",\n");
+    lines.push(`headers = {
+${entries}
+}`);
+    args.push("headers=headers");
+  }
+  if (cmd.body !== void 0) {
+    lines.push(`data = ${JSON.stringify(cmd.body)}`);
+    args.push("data=data");
+  }
+  if (cmd.followRedirects !== void 0) args.push(`allow_redirects=${cmd.followRedirects ? "True" : "False"}`);
+  if (hasHeaders || cmd.body !== void 0) lines.push("");
+  lines.push(`response = requests.${method}(${args.join(", ")})`);
+  lines.push("print(response.json())");
+  return lines.join("\n");
+}
+function generateGoHttp(cmd) {
+  const lines = [
+    "package main",
+    "",
+    "import (",
+    '	"fmt"',
+    '	"io"',
+    '	"net/http"'
+  ];
+  if (cmd.body !== void 0) lines.splice(5, 0, '	"strings"');
+  lines.push(")", "");
+  lines.push("func main() {");
+  if (cmd.body !== void 0) {
+    lines.push(`	body := strings.NewReader(${JSON.stringify(cmd.body)})`);
+    lines.push(`	req, err := http.NewRequest("${cmd.method}", "${cmd.url}", body)`);
+  } else {
+    lines.push(`	req, err := http.NewRequest("${cmd.method}", "${cmd.url}", nil)`);
+  }
+  lines.push("	if err != nil {");
+  lines.push("		panic(err)");
+  lines.push("	}");
+  for (const [k, v] of Object.entries(cmd.headers)) {
+    lines.push(`	req.Header.Set("${k}", "${v}")`);
+  }
+  lines.push("");
+  lines.push("	client := &http.Client{}");
+  lines.push("	resp, err := client.Do(req)");
+  lines.push("	if err != nil {");
+  lines.push("		panic(err)");
+  lines.push("	}");
+  lines.push("	defer resp.Body.Close()");
+  lines.push("	body2, _ := io.ReadAll(resp.Body)");
+  lines.push("	fmt.Println(string(body2))");
+  lines.push("}");
+  return lines.join("\n");
+}
+function generatePhpCurl(cmd) {
+  const lines = ["<?php", ""];
+  lines.push("$ch = curl_init();");
+  lines.push(`curl_setopt($ch, CURLOPT_URL, '${cmd.url}');`);
+  lines.push("curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);");
+  if (cmd.method !== "GET") {
+    lines.push(`curl_setopt($ch, CURLOPT_CUSTOMREQUEST, '${cmd.method}');`);
+  }
+  if (cmd.body !== void 0) {
+    lines.push(`curl_setopt($ch, CURLOPT_POSTFIELDS, ${JSON.stringify(cmd.body)});`);
+  }
+  if (Object.keys(cmd.headers).length > 0) {
+    const entries = Object.entries(cmd.headers).map(([k, v]) => `    '${k}: ${v}'`).join(",\n");
+    lines.push(`curl_setopt($ch, CURLOPT_HTTPHEADER, [
+${entries}
+]);`);
+  }
+  if (cmd.followRedirects) lines.push("curl_setopt($ch, CURLOPT_FOLLOWLOCATION, true);");
+  lines.push("");
+  lines.push("$response = curl_exec($ch);");
+  lines.push("curl_close($ch);");
+  lines.push("echo $response;");
+  return lines.join("\n");
+}
+function generateRubyNetHttp(cmd) {
+  const lines = [
+    "require 'net/http'",
+    "require 'uri'",
+    "require 'json'",
+    ""
+  ];
+  lines.push(`uri = URI.parse('${cmd.url}')`);
+  lines.push("http = Net::HTTP.new(uri.host, uri.port)");
+  lines.push("http.use_ssl = uri.scheme == 'https'");
+  lines.push("");
+  const methodClass = cmd.method.charAt(0).toUpperCase() + cmd.method.slice(1).toLowerCase();
+  lines.push(`request = Net::HTTP::${methodClass}.new(uri.request_uri)`);
+  for (const [k, v] of Object.entries(cmd.headers)) {
+    lines.push(`request['${k}'] = '${v}'`);
+  }
+  if (cmd.body !== void 0) {
+    lines.push(`request.body = ${JSON.stringify(cmd.body)}`);
+  }
+  lines.push("");
+  lines.push("response = http.request(request)");
+  lines.push("puts response.body");
+  return lines.join("\n");
+}
+function convertToCode(cmd, target) {
+  switch (target) {
+    case "fetch":
+      return generateFetch(cmd);
+    case "axios":
+      return generateAxios(cmd);
+    case "python-requests":
+      return generatePythonRequests(cmd);
+    case "go-http":
+      return generateGoHttp(cmd);
+    case "php-curl":
+      return generatePhpCurl(cmd);
+    case "ruby-net-http":
+      return generateRubyNetHttp(cmd);
+  }
+}
+function b64urlDecodeStr(str) {
+  const base64 = str.replace(/-/g, "+").replace(/_/g, "/");
+  const padded = base64 + "=".repeat((4 - base64.length % 4) % 4);
+  return Buffer.from(padded, "base64").toString("utf8");
+}
+function decodeSegment(segment) {
+  const json = b64urlDecodeStr(segment);
+  return JSON.parse(json);
+}
+function decodeJwt(token) {
+  const trimmed = token.trim();
+  if (!trimmed) return { ok: false, error: "No token provided" };
+  const parts = trimmed.split(".");
+  if (parts.length !== 3) {
+    return { ok: false, error: `Expected 3 parts (header.payload.signature), got ${parts.length}` };
+  }
+  const [rawHeader, rawPayload, rawSig] = parts;
+  let header;
+  try {
+    header = decodeSegment(rawHeader);
+  } catch {
+    return { ok: false, error: "Failed to decode header \u2014 not valid base64url JSON" };
+  }
+  let payload;
+  try {
+    payload = decodeSegment(rawPayload);
+  } catch {
+    return { ok: false, error: "Failed to decode payload \u2014 not valid base64url JSON" };
+  }
+  const algorithm = typeof header.alg === "string" ? header.alg : "unknown";
+  const now = Math.floor(Date.now() / 1e3);
+  const exp = typeof payload.exp === "number" ? payload.exp : null;
+  const iat = typeof payload.iat === "number" ? payload.iat : null;
+  let expiry;
+  if (exp === null) {
+    expiry = "no-exp";
+  } else if (exp < now) {
+    expiry = "expired";
+  } else {
+    expiry = "valid";
+  }
+  return {
+    ok: true,
+    header: { raw: rawHeader, decoded: header },
+    payload: { raw: rawPayload, decoded: payload },
+    signature: rawSig,
+    algorithm,
+    expiry,
+    expiresAt: exp !== null ? new Date(exp * 1e3) : null,
+    issuedAt: iat !== null ? new Date(iat * 1e3) : null
+  };
+}
+function formatJwtJson(obj) {
+  return JSON.stringify(obj, null, 2);
+}
+var ALG_TO_NODE_HASH = {
+  HS256: "sha256",
+  HS384: "sha384",
+  HS512: "sha512"
+};
+function base64urlEncode(str) {
+  return Buffer.from(str, "utf8").toString("base64").replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+}
+function base64urlDecode(str) {
+  const base64 = str.replace(/-/g, "+").replace(/_/g, "/");
+  const padded = base64 + "=".repeat((4 - base64.length % 4) % 4);
+  return Buffer.from(padded, "base64").toString("utf8");
+}
+async function signJwt(options) {
+  const { secret, payload, expiresInSeconds } = options;
+  const algorithm = options.algorithm ?? "HS256";
+  if (!secret) {
+    throw new Error("Secret is required for JWT signing");
+  }
+  const hashName = ALG_TO_NODE_HASH[algorithm];
+  const header = { alg: algorithm, typ: "JWT" };
+  const claims = { ...payload };
+  if (!("iat" in claims)) {
+    claims.iat = 0;
+  }
+  if (expiresInSeconds !== void 0) {
+    const iat = typeof claims.iat === "number" ? claims.iat : 0;
+    claims.exp = iat + expiresInSeconds;
+  }
+  const encodedHeader = base64urlEncode(JSON.stringify(header));
+  const encodedPayload = base64urlEncode(JSON.stringify(claims));
+  const signingInput = `${encodedHeader}.${encodedPayload}`;
+  const signatureBuffer = createHmac(hashName, secret).update(signingInput, "utf8").digest();
+  const encodedSignature = signatureBuffer.toString("base64").replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+  return `${signingInput}.${encodedSignature}`;
+}
+var CORS_COMMON_HEADERS = [
+  "Accept",
+  "Accept-Encoding",
+  "Accept-Language",
+  "Authorization",
+  "Cache-Control",
+  "Content-Length",
+  "Content-Type",
+  "Cookie",
+  "DNT",
+  "Host",
+  "If-Modified-Since",
+  "Keep-Alive",
+  "Origin",
+  "Pragma",
+  "Referer",
+  "TE",
+  "Upgrade-Insecure-Requests",
+  "User-Agent",
+  "Via",
+  "X-CustomHeader",
+  "X-Forwarded-For",
+  "X-Forwarded-Host",
+  "X-Forwarded-Proto",
+  "X-Requested-With"
+];
+var DEFAULT_CORS_CONFIG = {
+  allowedOrigins: ["*"],
+  allowedMethods: ["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD", "OPTIONS"],
+  allowedHeaders: ["Content-Type", "Authorization"],
+  exposedHeaders: [],
+  allowCredentials: false,
+  maxAge: 86400
+};
+function validateCorsConfig(config) {
+  const warnings = [];
+  if (config.allowCredentials && config.allowedOrigins.includes("*")) {
+    warnings.push(
+      'allowCredentials cannot be true when allowedOrigins includes "*". Browsers will reject this configuration.'
+    );
+  }
+  if (config.allowedOrigins.length === 0) {
+    warnings.push("No allowed origins specified. All cross-origin requests will be blocked.");
+  }
+  if (config.allowedMethods.length === 0) {
+    warnings.push("No allowed methods specified.");
+  }
+  if (config.maxAge < 0) {
+    warnings.push("maxAge should be a non-negative number.");
+  }
+  if (config.maxAge > 86400) {
+    warnings.push("maxAge exceeds 86400 seconds (24 hours). Some browsers cap this value.");
+  }
+  for (const origin of config.allowedOrigins) {
+    if (origin !== "*" && !origin.startsWith("http://") && !origin.startsWith("https://")) {
+      warnings.push(`Origin "${origin}" should start with http:// or https://.`);
+    }
+  }
+  const valid = warnings.every(
+    (w) => !w.includes("cannot be true when allowedOrigins includes")
+  );
+  return { valid, warnings };
+}
+function generateCors(config) {
+  const headers = {};
+  const originValue = config.allowedOrigins.includes("*") ? "*" : config.allowedOrigins.join(", ");
+  headers["Access-Control-Allow-Origin"] = originValue;
+  if (config.allowedMethods.length > 0) {
+    headers["Access-Control-Allow-Methods"] = config.allowedMethods.join(", ");
+  }
+  if (config.allowedHeaders.length > 0) {
+    headers["Access-Control-Allow-Headers"] = config.allowedHeaders.join(", ");
+  }
+  if (config.exposedHeaders.length > 0) {
+    headers["Access-Control-Expose-Headers"] = config.exposedHeaders.join(", ");
+  }
+  if (config.allowCredentials) {
+    headers["Access-Control-Allow-Credentials"] = "true";
+  }
+  if (config.maxAge > 0) {
+    headers["Access-Control-Max-Age"] = String(config.maxAge);
+  }
+  const nginxLines = [];
+  nginxLines.push("# Add inside your location block");
+  nginxLines.push(`add_header 'Access-Control-Allow-Origin' '${originValue}';`);
+  nginxLines.push(`add_header 'Access-Control-Allow-Methods' '${config.allowedMethods.join(", ")}';`);
+  if (config.allowedHeaders.length > 0) {
+    nginxLines.push(`add_header 'Access-Control-Allow-Headers' '${config.allowedHeaders.join(", ")}';`);
+  }
+  if (config.exposedHeaders.length > 0) {
+    nginxLines.push(`add_header 'Access-Control-Expose-Headers' '${config.exposedHeaders.join(", ")}';`);
+  }
+  if (config.allowCredentials) {
+    nginxLines.push(`add_header 'Access-Control-Allow-Credentials' 'true';`);
+  }
+  if (config.maxAge > 0) {
+    nginxLines.push(`add_header 'Access-Control-Max-Age' '${config.maxAge}';`);
+  }
+  nginxLines.push("");
+  nginxLines.push("if ($request_method = OPTIONS) {");
+  nginxLines.push("  return 204;");
+  nginxLines.push("}");
+  const nginxConfig = nginxLines.join("\n");
+  const originsArray = config.allowedOrigins.includes("*") ? "'*'" : config.allowedOrigins.map((o) => `'${o}'`).join(", ");
+  const expressLines = [];
+  expressLines.push('const cors = require("cors");');
+  expressLines.push("");
+  expressLines.push("app.use(cors({");
+  expressLines.push(`  origin: ${config.allowedOrigins.includes("*") ? "'*'" : `[${originsArray}]`},`);
+  expressLines.push(`  methods: [${config.allowedMethods.map((m) => `'${m}'`).join(", ")}],`);
+  if (config.allowedHeaders.length > 0) {
+    expressLines.push(`  allowedHeaders: [${config.allowedHeaders.map((h) => `'${h}'`).join(", ")}],`);
+  }
+  if (config.exposedHeaders.length > 0) {
+    expressLines.push(`  exposedHeaders: [${config.exposedHeaders.map((h) => `'${h}'`).join(", ")}],`);
+  }
+  expressLines.push(`  credentials: ${config.allowCredentials},`);
+  if (config.maxAge > 0) {
+    expressLines.push(`  maxAge: ${config.maxAge},`);
+  }
+  expressLines.push("}));");
+  const expressCode = expressLines.join("\n");
+  const apacheLines = [];
+  apacheLines.push("# Add to .htaccess or Apache config");
+  apacheLines.push("<IfModule mod_headers.c>");
+  if (config.allowedOrigins.includes("*")) {
+    apacheLines.push(`  Header set Access-Control-Allow-Origin "*"`);
+  } else {
+    for (const origin of config.allowedOrigins) {
+      apacheLines.push(`  Header set Access-Control-Allow-Origin "${origin}"`);
+    }
+  }
+  apacheLines.push(`  Header set Access-Control-Allow-Methods "${config.allowedMethods.join(", ")}"`);
+  if (config.allowedHeaders.length > 0) {
+    apacheLines.push(`  Header set Access-Control-Allow-Headers "${config.allowedHeaders.join(", ")}"`);
+  }
+  if (config.exposedHeaders.length > 0) {
+    apacheLines.push(`  Header set Access-Control-Expose-Headers "${config.exposedHeaders.join(", ")}"`);
+  }
+  if (config.allowCredentials) {
+    apacheLines.push(`  Header set Access-Control-Allow-Credentials "true"`);
+  }
+  if (config.maxAge > 0) {
+    apacheLines.push(`  Header set Access-Control-Max-Age "${config.maxAge}"`);
+  }
+  apacheLines.push("</IfModule>");
+  const apacheConfig = apacheLines.join("\n");
+  return { headers, nginxConfig, expressCode, apacheConfig };
+}
+var NO_SOURCE_DIRECTIVES = ["upgrade-insecure-requests", "block-all-mixed-content"];
+function generateCspHeader(config) {
+  const parts = [];
+  for (const d of config.directives) {
+    if (NO_SOURCE_DIRECTIVES.includes(d.directive) || d.sources.length === 0) {
+      parts.push(d.directive);
+    } else {
+      parts.push([d.directive, ...d.sources].join(" "));
+    }
+  }
+  if (config.reportUri) {
+    parts.push(`report-uri ${config.reportUri}`);
+  }
+  return parts.join("; ");
+}
+function generateFullHeader(config) {
+  return {
+    name: config.reportOnly ? "Content-Security-Policy-Report-Only" : "Content-Security-Policy",
+    value: generateCspHeader(config)
+  };
+}
+function parseCspHeader(headerValue) {
+  if (!headerValue || !headerValue.trim()) {
+    return { error: "Empty header" };
+  }
+  const directives = [];
+  let reportUri;
+  const parts = headerValue.split(";").map((p) => p.trim()).filter(Boolean);
+  for (const part of parts) {
+    const tokens = part.split(/\s+/).filter(Boolean);
+    if (tokens.length === 0) continue;
+    const directive = tokens[0].toLowerCase();
+    const sources = tokens.slice(1);
+    if (directive === "report-uri") {
+      reportUri = sources[0];
+    } else {
+      directives.push({ directive, sources });
+    }
+  }
+  const config = { directives };
+  if (reportUri) {
+    config.reportUri = reportUri;
+  }
+  return config;
+}
+function validateCspConfig(config) {
+  const warnings = [];
+  const hasDefaultSrc = config.directives.some((d) => d.directive === "default-src");
+  if (!hasDefaultSrc) {
+    warnings.push("No 'default-src' directive present. Browsers will not apply a fallback policy.");
+  }
+  for (const d of config.directives) {
+    if (d.sources.includes("'unsafe-inline'") && d.sources.includes("'strict-dynamic'")) {
+      warnings.push(`Directive '${d.directive}' has both 'unsafe-inline' and 'strict-dynamic'. 'unsafe-inline' is ignored when 'strict-dynamic' is present.`);
+    }
+    if (d.sources.includes("'unsafe-eval'")) {
+      warnings.push(`Directive '${d.directive}' uses 'unsafe-eval', which allows dynamic code execution and reduces security.`);
+    }
+  }
+  return { warnings };
+}
+var DIRECTIVE_DESCRIPTIONS = {
+  "default-src": "Fallback for fetch directives that are not explicitly set.",
+  "script-src": "Controls valid sources for JavaScript.",
+  "style-src": "Controls valid sources for stylesheets.",
+  "img-src": "Controls valid sources for images.",
+  "font-src": "Controls valid sources for fonts loaded via @font-face.",
+  "connect-src": "Restricts URLs for fetch, XHR, WebSocket, and EventSource connections.",
+  "media-src": "Controls valid sources for audio and video elements.",
+  "object-src": "Controls valid sources for plugin elements like <object> and <embed>.",
+  "frame-src": "Controls valid sources for nested browsing contexts like <frame> and <iframe>.",
+  "worker-src": "Controls valid sources for Worker, SharedWorker, and ServiceWorker scripts.",
+  "manifest-src": "Controls valid sources for application manifest files.",
+  "prefetch-src": "Controls valid sources for prefetch and prerender requests.",
+  "form-action": "Restricts URLs that can be used as form submission targets.",
+  "frame-ancestors": "Specifies valid parents that may embed the page using <frame>, <iframe>, etc.",
+  "base-uri": "Restricts URLs that can be used in the <base> element.",
+  "upgrade-insecure-requests": "Instructs the browser to treat all HTTP URLs as HTTPS.",
+  "block-all-mixed-content": "Prevents loading any assets using HTTP when the page is loaded over HTTPS.",
+  "report-uri": "Specifies a URL where the browser sends reports about policy violations.",
+  "report-to": "Specifies a reporting group for sending violation reports via the Reporting API."
+};
+var COMMON_PRESETS = [
+  {
+    name: "Strict",
+    description: "Maximum security. Only allows same-origin resources with no inline scripts or styles.",
+    config: {
+      directives: [
+        { directive: "default-src", sources: ["'none'"] },
+        { directive: "script-src", sources: ["'self'"] },
+        { directive: "style-src", sources: ["'self'"] },
+        { directive: "img-src", sources: ["'self'", "data:"] },
+        { directive: "font-src", sources: ["'self'"] },
+        { directive: "connect-src", sources: ["'self'"] }
+      ]
+    }
+  },
+  {
+    name: "Moderate",
+    description: "Balanced security allowing same-origin resources and inline styles/scripts.",
+    config: {
+      directives: [
+        { directive: "default-src", sources: ["'self'"] },
+        { directive: "script-src", sources: ["'self'", "'unsafe-inline'"] },
+        { directive: "style-src", sources: ["'self'", "'unsafe-inline'"] },
+        { directive: "img-src", sources: ["'self'", "data:", "https:"] }
+      ]
+    }
+  },
+  {
+    name: "Permissive",
+    description: "Very permissive policy suitable for development. Not recommended for production.",
+    config: {
+      directives: [
+        { directive: "default-src", sources: ["*"] },
+        { directive: "script-src", sources: ["*", "'unsafe-inline'", "'unsafe-eval'"] },
+        { directive: "style-src", sources: ["*", "'unsafe-inline'"] }
+      ]
+    }
+  },
+  {
+    name: "SPA",
+    description: "Suitable for single-page applications with API calls, fonts, and blob URLs.",
+    config: {
+      directives: [
+        { directive: "default-src", sources: ["'self'"] },
+        { directive: "script-src", sources: ["'self'", "'unsafe-inline'"] },
+        { directive: "style-src", sources: ["'self'", "'unsafe-inline'"] },
+        { directive: "img-src", sources: ["'self'", "data:", "blob:"] },
+        { directive: "connect-src", sources: ["'self'", "https:"] },
+        { directive: "font-src", sources: ["'self'", "data:"] }
+      ]
+    }
+  }
+];
+function detectFormat(content) {
+  const trimmed = content.trim();
+  if (!trimmed) return "unknown";
+  if (trimmed.startsWith("{") || trimmed.startsWith("[")) {
+    try {
+      JSON.parse(trimmed);
+      return "json";
+    } catch {
+    }
+  }
+  if (trimmed.startsWith("<") && trimmed.includes(">")) {
+    const lower = trimmed.toLowerCase();
+    if (lower.startsWith("<!doctype html") || lower.startsWith("<html") || lower.includes("<html") || lower.includes("<body")) {
+      return "html";
+    }
+    return "xml";
+  }
+  const lines = trimmed.split("\n");
+  if (lines.length >= 2) {
+    const firstLine = lines[0];
+    const allLinesHaveCommas = lines.every((line) => line.includes(","));
+    const firstLineIsHeaders = /^[a-zA-Z0-9_,\s"']+$/.test(firstLine) && firstLine.includes(",");
+    if (allLinesHaveCommas && firstLineIsHeaders) {
+      return "csv";
+    }
+  }
+  return "text";
+}
+function prettifyXml(xml) {
+  const tokens = xml.replace(/>\s*</g, "><").split(/(<[^>]+>)/);
+  let indent = 0;
+  const result = [];
+  for (const token of tokens) {
+    if (!token.trim()) continue;
+    if (/^<\//.test(token)) {
+      indent = Math.max(0, indent - 1);
+      result.push("  ".repeat(indent) + token);
+    } else if (/^<[^?!][^>]*[^/]>$/.test(token)) {
+      result.push("  ".repeat(indent) + token);
+      indent++;
+    } else if (/^<[^?!][^>]*\/>$/.test(token)) {
+      result.push("  ".repeat(indent) + token);
+    } else if (/^<[?!]/.test(token)) {
+      result.push("  ".repeat(indent) + token);
+    } else {
+      result.push("  ".repeat(indent) + token);
+    }
+  }
+  return result.join("\n");
+}
+function formatResponse(content, hint) {
+  const size = Buffer.byteLength(content, "utf8");
+  const lines = content.split("\n").length;
+  const format = hint ?? detectFormat(content);
+  if (format === "json") {
+    try {
+      const parsed = JSON.parse(content.trim());
+      const formatted = JSON.stringify(parsed, null, 2);
+      const minified = JSON.stringify(parsed);
+      return { format, formatted, minified, size, lines, valid: true };
+    } catch (e) {
+      return { format, formatted: content, size, lines, valid: false, error: e.message };
+    }
+  }
+  if (format === "xml") {
+    try {
+      const formatted = prettifyXml(content.trim());
+      return { format, formatted, size, lines, valid: true };
+    } catch (e) {
+      return { format, formatted: content, size, lines, valid: false, error: e.message };
+    }
+  }
+  if (format === "html") {
+    try {
+      const formatted = prettifyXml(content.trim());
+      return { format, formatted, size, lines, valid: true };
+    } catch (e) {
+      return { format, formatted: content, size, lines, valid: false, error: e.message };
+    }
+  }
+  return { format, formatted: content, size, lines, valid: true };
+}
+function getStats(content) {
+  const size = Buffer.byteLength(content, "utf8");
+  const lines = content.split("\n").length;
+  const format = detectFormat(content);
+  if (format === "json") {
+    try {
+      const parsed = JSON.parse(content.trim());
+      const jsonKeys = Array.isArray(parsed) ? parsed.length : Object.keys(parsed).length;
+      return { size, lines, format, jsonKeys };
+    } catch {
+      return { size, lines, format };
+    }
+  }
+  if (format === "xml") {
+    const xmlElements = (content.match(/<[a-zA-Z][^/!>][^>]*>/g) ?? []).length;
+    return { size, lines, format, xmlElements };
+  }
+  return { size, lines, format };
+}
+function extractJsonPaths(content) {
+  try {
+    const parsed = JSON.parse(content.trim());
+    if (Array.isArray(parsed)) {
+      return parsed.map((_, i) => `[${i}]`);
+    }
+    if (typeof parsed === "object" && parsed !== null) {
+      const paths = [];
+      for (const key of Object.keys(parsed)) {
+        paths.push(key);
+        const value = parsed[key];
+        if (typeof value === "object" && value !== null && !Array.isArray(value)) {
+          for (const subKey of Object.keys(value)) {
+            paths.push(`${key}.${subKey}`);
+          }
+        }
+      }
+      return paths;
+    }
+    return [];
+  } catch {
+    return [];
+  }
+}
+function parseUrl(url) {
+  const trimmed = url.trim();
+  if (!trimmed) {
+    return {
+      protocol: "",
+      hostname: "",
+      pathname: "",
+      search: "",
+      hash: "",
+      params: [],
+      isValid: false,
+      isAbsolute: false
+    };
+  }
+  try {
+    const parsed = new URL(trimmed);
+    const params = [];
+    parsed.searchParams.forEach((value, key) => {
+      params.push({ key, value });
+    });
+    return {
+      protocol: parsed.protocol.replace(":", ""),
+      username: parsed.username || void 0,
+      password: parsed.password || void 0,
+      hostname: parsed.hostname,
+      port: parsed.port || void 0,
+      pathname: parsed.pathname,
+      search: parsed.search,
+      hash: parsed.hash,
+      params,
+      isValid: true,
+      isAbsolute: true
+    };
+  } catch {
+    if (trimmed.startsWith("/") || trimmed.startsWith("./") || trimmed.startsWith("../")) {
+      const [pathAndQuery, hash] = trimmed.split("#");
+      const [pathname, queryString] = pathAndQuery.split("?");
+      const search = queryString ? `?${queryString}` : "";
+      const params = [];
+      if (queryString) {
+        for (const part of queryString.split("&")) {
+          const [k, v] = part.split("=");
+          if (k) params.push({ key: decodeURIComponent(k), value: decodeURIComponent(v ?? "") });
+        }
+      }
+      return {
+        protocol: "",
+        hostname: "",
+        pathname,
+        search,
+        hash: hash ? `#${hash}` : "",
+        params,
+        isValid: true,
+        isAbsolute: false
+      };
+    }
+    return {
+      protocol: "",
+      hostname: trimmed,
+      pathname: "",
+      search: "",
+      hash: "",
+      params: [],
+      isValid: false,
+      isAbsolute: false
+    };
+  }
+}
+function buildUrl(parsed) {
+  const protocol = parsed.protocol || "https";
+  const host = parsed.hostname;
+  const port = parsed.port ? `:${parsed.port}` : "";
+  const auth = parsed.username ? `${encodeURIComponent(parsed.username)}${parsed.password ? `:${encodeURIComponent(parsed.password)}` : ""}@` : "";
+  const pathname = parsed.pathname || "/";
+  const params = parsed.params || [];
+  let search = "";
+  if (params.length > 0) {
+    const sp = new URLSearchParams();
+    for (const { key, value } of params) {
+      sp.append(key, value);
+    }
+    search = `?${sp.toString()}`;
+  } else if (parsed.search && parsed.search !== "?") {
+    search = parsed.search.startsWith("?") ? parsed.search : `?${parsed.search}`;
+  }
+  const hash = parsed.hash || "";
+  return `${protocol}://${auth}${host}${port}${pathname}${search}${hash}`;
+}
+function addParam(url, key, value) {
+  try {
+    const parsed = new URL(url);
+    parsed.searchParams.append(key, value);
+    return parsed.toString();
+  } catch {
+    const sep = url.includes("?") ? "&" : "?";
+    return `${url}${sep}${encodeURIComponent(key)}=${encodeURIComponent(value)}`;
+  }
+}
+function removeParam(url, key) {
+  try {
+    const parsed = new URL(url);
+    parsed.searchParams.delete(key);
+    return parsed.toString();
+  } catch {
+    return url;
+  }
+}
+function getParam(url, key) {
+  try {
+    const parsed = new URL(url);
+    return parsed.searchParams.get(key);
+  } catch {
+    return null;
+  }
+}
+function encodeUrlComponent(value) {
+  return encodeURIComponent(value);
+}
+function decodeUrlComponent(value) {
+  try {
+    return decodeURIComponent(value);
+  } catch {
+    return value;
+  }
+}
+function isValidUrl(url) {
+  try {
+    new URL(url.trim());
+    return true;
+  } catch {
+    return false;
+  }
+}
+function normalizeUrl(url) {
+  try {
+    const parsed = new URL(url.trim());
+    parsed.hostname = parsed.hostname.toLowerCase();
+    const keys = Array.from(parsed.searchParams.keys()).sort();
+    const values = keys.map((k) => [k, parsed.searchParams.get(k)]);
+    parsed.search = "";
+    const sp = new URLSearchParams();
+    for (const [k, v] of values) {
+      sp.append(k, v);
+    }
+    if (values.length > 0) parsed.search = sp.toString();
+    let result = parsed.toString();
+    if (result.endsWith("/") && parsed.pathname === "/") {
+      result = result.replace(/\/$/, "");
+    }
+    return result;
+  } catch {
+    return url;
+  }
+}
+function getMetaContent(html, property) {
+  const escaped = property.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const patterns = [
+    new RegExp(
+      `<meta[^>]+property=["']${escaped}["'][^>]+content=["']([^"']*)["']`,
+      "i"
+    ),
+    new RegExp(
+      `<meta[^>]+content=["']([^"']*)["'][^>]+property=["']${escaped}["']`,
+      "i"
+    ),
+    new RegExp(
+      `<meta[^>]+name=["']${escaped}["'][^>]+content=["']([^"']*)["']`,
+      "i"
+    ),
+    new RegExp(
+      `<meta[^>]+content=["']([^"']*)["'][^>]+name=["']${escaped}["']`,
+      "i"
+    )
+  ];
+  for (const pattern of patterns) {
+    const match = html.match(pattern);
+    if (match) return match[1];
+  }
+  return void 0;
+}
+function parseMetaTags(html) {
+  const titleMatch = html.match(/<title[^>]*>([^<]*)<\/title>/i);
+  const canonicalMatch = html.match(
+    /<link[^>]+rel=["']canonical["'][^>]+href=["']([^"']*)["']/i
+  ) || html.match(
+    /<link[^>]+href=["']([^"']*)["'][^>]+rel=["']canonical["']/i
+  );
+  const charsetMatch = html.match(/<meta[^>]+charset=["']([^"']*)["']/i) || html.match(/<meta[^>]+charset=([^\s>]*)/i);
+  return {
+    og: {
+      title: getMetaContent(html, "og:title"),
+      description: getMetaContent(html, "og:description"),
+      image: getMetaContent(html, "og:image"),
+      imageAlt: getMetaContent(html, "og:image:alt"),
+      imageWidth: getMetaContent(html, "og:image:width"),
+      imageHeight: getMetaContent(html, "og:image:height"),
+      url: getMetaContent(html, "og:url"),
+      type: getMetaContent(html, "og:type"),
+      siteName: getMetaContent(html, "og:site_name"),
+      locale: getMetaContent(html, "og:locale")
+    },
+    twitter: {
+      card: getMetaContent(html, "twitter:card"),
+      site: getMetaContent(html, "twitter:site"),
+      creator: getMetaContent(html, "twitter:creator"),
+      title: getMetaContent(html, "twitter:title"),
+      description: getMetaContent(html, "twitter:description"),
+      image: getMetaContent(html, "twitter:image")
+    },
+    standard: {
+      title: titleMatch ? titleMatch[1].trim() : void 0,
+      description: getMetaContent(html, "description"),
+      keywords: getMetaContent(html, "keywords"),
+      canonical: canonicalMatch ? canonicalMatch[1] : void 0,
+      robots: getMetaContent(html, "robots"),
+      viewport: getMetaContent(html, "viewport"),
+      charset: charsetMatch ? charsetMatch[1] : void 0
+    }
+  };
+}
+function validateOgTags(tags) {
+  const warnings = [];
+  const missing = [];
+  const required = ["title", "description", "image", "url", "type"];
+  for (const field of required) {
+    if (!tags[field]) {
+      missing.push(`og:${field}`);
+    }
+  }
+  if (tags.image && !/^https?:\/\//i.test(tags.image)) {
+    warnings.push("og:image should be an absolute URL");
+  }
+  if (tags.url && !/^https?:\/\//i.test(tags.url)) {
+    warnings.push("og:url should be an absolute URL");
+  }
+  if (tags.title && tags.title.length > 95) {
+    warnings.push("og:title is longer than 95 characters and may be truncated");
+  }
+  if (tags.description && tags.description.length > 300) {
+    warnings.push("og:description is longer than 300 characters and may be truncated");
+  }
+  if (tags.type && !["website", "article", "video.movie", "video.episode", "music.song", "music.album", "book", "profile"].includes(tags.type)) {
+    warnings.push(`og:type value "${tags.type}" is not a standard type`);
+  }
+  return { warnings, missing };
+}
+function generateMetaHtml(tags) {
+  const lines = [];
+  const ogMap = {
+    title: "og:title",
+    description: "og:description",
+    image: "og:image",
+    imageAlt: "og:image:alt",
+    imageWidth: "og:image:width",
+    imageHeight: "og:image:height",
+    url: "og:url",
+    type: "og:type",
+    siteName: "og:site_name",
+    locale: "og:locale"
+  };
+  const twitterMap = {
+    card: "twitter:card",
+    site: "twitter:site",
+    creator: "twitter:creator"
+  };
+  for (const [key, property] of Object.entries(ogMap)) {
+    const value = tags[key];
+    if (value) {
+      lines.push(`<meta property="${property}" content="${value}" />`);
+    }
+  }
+  for (const [key, name] of Object.entries(twitterMap)) {
+    const value = tags[key];
+    if (value) {
+      lines.push(`<meta name="${name}" content="${value}" />`);
+    }
+  }
+  if (tags.title && !tags.title) {
+    lines.push(`<meta name="twitter:title" content="${tags.title}" />`);
+  }
+  if (tags.description && !tags.description) {
+    lines.push(`<meta name="twitter:description" content="${tags.description}" />`);
+  }
+  return lines.join("\n");
+}
+
+export { COMMON_HEADERS, COMMON_PRESETS, CORS_COMMON_HEADERS, DEFAULT_CORS_CONFIG, DIRECTIVE_DESCRIPTIONS, HTTP_METHODS, SUPPORTED_LANGUAGES, addParam, api_exports, base64urlDecode, base64urlEncode, buildCurl, buildCurlMultiline, buildUrl, convertToCode, decodeJwt, decodeUrlComponent, detectFormat, encodeUrlComponent, extractJsonPaths, formatJwtJson, formatResponse, generateCors, generateCspHeader, generateFullHeader, generateMetaHtml, getParam, getStats, isValidUrl, normalizeUrl, parseCspHeader, parseCurl, parseCurlCommand, parseMetaTags, parseUrl, removeParam, signJwt, validateCorsConfig, validateCspConfig, validateOgTags };