@oaspect/core 0.1.0

package/dist/index.js

@@ -0,0 +1,2585 @@
+// src/refs.ts
+function resolvePointer(spec, ref) {
+  if (typeof ref !== "string" || !ref.startsWith("#/")) return void 0;
+  return ref.slice(2).split("/").map((part) => part.replace(/~1/g, "/").replace(/~0/g, "~")).reduce((node, key) => node?.[key], spec);
+}
+function refName(ref) {
+  return ref.split("/").pop() ?? ref;
+}
+function deref(spec, node) {
+  let ref;
+  let hops = 0;
+  while (node?.$ref && hops++ < 32) {
+    ref = node.$ref;
+    node = resolvePointer(spec, ref);
+  }
+  return { node: node ?? {}, ref };
+}
+
+// src/schema.ts
+function mergeInto(target, source) {
+  for (const [key, value] of Object.entries(source)) {
+    if (key === "properties") {
+      target.properties = { ...target.properties, ...value };
+    } else if (key === "required") {
+      target.required = [.../* @__PURE__ */ new Set([...target.required ?? [], ...value])];
+    } else {
+      target[key] = value;
+    }
+  }
+}
+function resolveSchema(spec, input) {
+  const { node, ref } = deref(spec, input);
+  let schema = node;
+  let name = ref ? refName(ref) : void 0;
+  if (Array.isArray(schema.allOf)) {
+    const { allOf, ...rest } = schema;
+    const merged = {};
+    for (const part of allOf) {
+      mergeInto(merged, resolveSchema(spec, part).schema);
+    }
+    mergeInto(merged, rest);
+    if (!name && allOf.length === 1 && allOf[0].$ref) {
+      name = refName(allOf[0].$ref);
+    }
+    schema = merged;
+  }
+  return { schema, name };
+}
+function inferType(schema) {
+  if (schema.type) return Array.isArray(schema.type) ? schema.type.join(" | ") : schema.type;
+  if (schema.properties || schema.additionalProperties) return "object";
+  if (schema.items) return "array";
+  if (schema.oneOf) return "oneOf";
+  if (schema.anyOf) return "anyOf";
+  return "any";
+}
+function typeLabel(spec, schema, name) {
+  const type = inferType(schema);
+  if (type === "array" && schema.items) {
+    const item = resolveSchema(spec, schema.items);
+    return `array<${item.name ?? typeLabel(spec, item.schema)}>`;
+  }
+  if (type === "object" && name) return name;
+  if (schema.format) return `${type}<${schema.format}>`;
+  return type;
+}
+function constraintsOf(schema) {
+  const list = [];
+  const add = (label, value) => value !== void 0 && list.push(`${label} ${value}`);
+  add("min length", schema.minLength);
+  add("max length", schema.maxLength);
+  add(schema.exclusiveMinimum === true ? ">" : "\u2265", schema.minimum);
+  add(schema.exclusiveMaximum === true ? "<" : "\u2264", schema.maximum);
+  if (typeof schema.exclusiveMinimum === "number") add(">", schema.exclusiveMinimum);
+  if (typeof schema.exclusiveMaximum === "number") add("<", schema.exclusiveMaximum);
+  add("multiple of", schema.multipleOf);
+  add("min items", schema.minItems);
+  add("max items", schema.maxItems);
+  if (schema.uniqueItems) list.push("unique items");
+  return list;
+}
+function childrenOf(spec, schema) {
+  const type = inferType(schema);
+  if (type === "array" && schema.items) {
+    const item = resolveSchema(spec, schema.items);
+    return childrenOf(spec, item.schema) ? { kind: "items", ...item } : null;
+  }
+  if (schema.oneOf || schema.anyOf) {
+    const variants = (schema.oneOf ?? schema.anyOf).map((variant) => resolveSchema(spec, variant));
+    return { kind: schema.oneOf ? "oneOf" : "anyOf", variants };
+  }
+  if (schema.properties && Object.keys(schema.properties).length > 0) {
+    return { kind: "properties" };
+  }
+  if (schema.additionalProperties && typeof schema.additionalProperties === "object") {
+    const value = resolveSchema(spec, schema.additionalProperties);
+    return childrenOf(spec, value.schema) ? { kind: "map", ...value } : null;
+  }
+  return null;
+}
+
+// src/example.ts
+var STRING_FORMATS = {
+  "date-time": "2026-01-01T09:00:00Z",
+  date: "2026-01-01",
+  time: "09:00:00",
+  email: "user@example.com",
+  uri: "https://example.com",
+  url: "https://example.com",
+  uuid: "3fa85f64-5717-4562-b3fc-2c963f66afa6",
+  ipv4: "192.168.0.1",
+  ipv6: "::1",
+  password: "********",
+  byte: "U3dhZ2dlcg=="
+};
+function exampleFromSchema(spec, input, seen = /* @__PURE__ */ new Set(), depth = 0) {
+  if (!input || depth > 8) return void 0;
+  const { schema, name } = resolveSchema(spec, input);
+  if (name && seen.has(name)) return {};
+  const nextSeen = name ? new Set(seen).add(name) : seen;
+  if (schema.example !== void 0) return schema.example;
+  if (Array.isArray(schema.examples) && schema.examples.length) return schema.examples[0];
+  if (schema.default !== void 0) return schema.default;
+  if (Array.isArray(schema.enum) && schema.enum.length) return schema.enum[0];
+  if (schema.const !== void 0) return schema.const;
+  const variants = schema.oneOf ?? schema.anyOf;
+  if (variants?.length) return exampleFromSchema(spec, variants[0], nextSeen, depth + 1);
+  switch (inferType(schema)) {
+    case "object": {
+      const result = {};
+      for (const [key, value] of Object.entries(schema.properties ?? {})) {
+        if (resolveSchema(spec, value).schema.writeOnly) continue;
+        result[key] = exampleFromSchema(spec, value, nextSeen, depth + 1);
+      }
+      if (!schema.properties && typeof schema.additionalProperties === "object") {
+        result.key = exampleFromSchema(spec, schema.additionalProperties, nextSeen, depth + 1);
+      }
+      return result;
+    }
+    case "array":
+      return schema.items ? [exampleFromSchema(spec, schema.items, nextSeen, depth + 1)] : [];
+    case "integer":
+      return schema.minimum ?? 0;
+    case "number":
+      return schema.minimum ?? 0;
+    case "boolean":
+      return true;
+    case "string":
+      return STRING_FORMATS[schema.format] ?? "string";
+    default:
+      return null;
+  }
+}
+function mediaExample(spec, media) {
+  if (!media) return void 0;
+  if (media.example !== void 0) return media.example;
+  const named = media.examples && Object.values(media.examples)[0];
+  if (named) return deref(spec, named).node.value;
+  return exampleFromSchema(spec, media.schema);
+}
+function mediaExamples(spec, media) {
+  if (!media?.examples) return [];
+  return Object.entries(media.examples).map(([key, value]) => {
+    const { node } = deref(spec, value);
+    return { key, summary: node.summary ?? key, value: node.value };
+  });
+}
+
+// src/model.ts
+var HTTP_METHODS = ["get", "put", "post", "delete", "options", "head", "patch", "trace"];
+function slugify(value) {
+  return String(value).toLowerCase().replace(/[{}]/g, "").replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+}
+var tagAnchor = (name) => `tag/${slugify(name)}`;
+var modelAnchor = (name) => `model/${name}`;
+function operationAnchor(method, path2, operationId) {
+  return `operation/${operationId ? slugify(operationId) : `${method}-${slugify(path2)}`}`;
+}
+function mergeParameters(spec, pathParams = [], opParams = []) {
+  const byKey = /* @__PURE__ */ new Map();
+  for (const raw of [...pathParams, ...opParams]) {
+    const { node } = deref(spec, raw);
+    if (node.name) byKey.set(`${node.in}:${node.name}`, node);
+  }
+  return [...byKey.values()];
+}
+function resolveLinks(spec, links = {}) {
+  return Object.entries(links).map(([name, raw]) => {
+    const { node } = deref(spec, raw);
+    return {
+      name,
+      operationId: node.operationId,
+      operationRef: node.operationRef,
+      parameters: node.parameters ?? {},
+      requestBody: node.requestBody,
+      description: node.description ?? ""
+    };
+  });
+}
+function resolveResponses(spec, responses = {}) {
+  return Object.entries(responses).map(([status, raw]) => {
+    const { node } = deref(spec, raw);
+    return {
+      status,
+      description: node.description ?? "",
+      "x-i18n": node["x-i18n"],
+      content: node.content ?? {},
+      headers: Object.fromEntries(
+        Object.entries(node.headers ?? {}).map(([key, value]) => [key, deref(spec, value).node])
+      ),
+      links: resolveLinks(spec, node.links)
+    };
+  });
+}
+function buildOperation(spec, method, path2, pathItem, op, kind, anchorPrefix) {
+  const requestBody = op.requestBody ? deref(spec, op.requestBody).node : null;
+  const anchor = kind === "operation" ? operationAnchor(method, path2, op.operationId) : `${anchorPrefix}/${slugify(op.operationId ?? `${path2}-${method}`)}`;
+  return {
+    anchor,
+    kind,
+    method,
+    path: path2,
+    summary: op.summary ?? "",
+    description: op.description ?? "",
+    "x-i18n": op["x-i18n"],
+    operationId: op.operationId,
+    deprecated: Boolean(op.deprecated),
+    tags: op.tags?.length ? op.tags : ["Default"],
+    parameters: mergeParameters(spec, pathItem.parameters, op.parameters),
+    requestBody,
+    responses: resolveResponses(spec, op.responses),
+    callbacks: kind === "callback" ? [] : resolveCallbacks(spec, op.callbacks, anchor),
+    security: op.security ?? spec.security ?? [],
+    servers: op.servers ?? pathItem.servers ?? spec.servers ?? []
+  };
+}
+function operationsOf(spec, path2, item, kind, anchorPrefix) {
+  const pathItem = deref(spec, item).node;
+  return HTTP_METHODS.filter((method) => pathItem[method]).map(
+    (method) => buildOperation(spec, method, path2, pathItem, pathItem[method], kind, anchorPrefix)
+  );
+}
+function resolveCallbacks(spec, callbacks = {}, parentAnchor) {
+  return Object.entries(callbacks).map(([name, raw]) => {
+    const { node } = deref(spec, raw);
+    const operations = Object.entries(node).filter(([expression]) => !expression.startsWith("x-")).flatMap(([expression, item]) => operationsOf(spec, expression, item, "callback", `${parentAnchor}/callback/${slugify(name)}`));
+    return { name, operations };
+  });
+}
+function buildModel(spec) {
+  const tagMeta = new Map((spec.tags ?? []).map((tag) => [tag.name, tag]));
+  const groups = new Map([...tagMeta.keys()].map((name) => [name, []]));
+  const operations = [];
+  for (const [path2, item] of Object.entries(spec.paths ?? {})) {
+    for (const operation of operationsOf(spec, path2, item, "operation", "operation")) {
+      operations.push(operation);
+      for (const tag of operation.tags) {
+        if (!groups.has(tag)) groups.set(tag, []);
+        groups.get(tag).push(operation);
+      }
+    }
+  }
+  const webhooks = Object.entries(spec.webhooks ?? {}).flatMap(
+    ([name, item]) => operationsOf(spec, name, item, "webhook", `webhook/${slugify(name)}`)
+  );
+  const tags = [...groups.entries()].filter(([, list]) => list.length > 0).map(([name, list]) => ({
+    name,
+    anchor: tagAnchor(name),
+    description: tagMeta.get(name)?.description ?? "",
+    // Display name translations go under x-i18n.<locale>.name; `name`
+    // stays the grouping key operations refer to.
+    "x-i18n": tagMeta.get(name)?.["x-i18n"],
+    operations: list
+  }));
+  const schemas = Object.entries(spec.components?.schemas ?? {}).map(([name, schema]) => ({
+    name,
+    anchor: modelAnchor(name),
+    schema
+  }));
+  return {
+    openapi: spec.openapi ?? spec.swagger ?? "",
+    info: spec.info ?? {},
+    servers: spec.servers?.length ? spec.servers : [{ url: "/" }],
+    securitySchemes: spec.components?.securitySchemes ?? {},
+    tags,
+    operations,
+    webhooks,
+    schemas
+  };
+}
+function serverUrl(server, values = {}) {
+  return server.url.replace(/\{([^}]+)\}/g, (match, key) => values[key] || server.variables?.[key]?.default || match);
+}
+function linkTarget(model, link) {
+  if (link.operationId) return model.operations.find((operation) => operation.operationId === link.operationId);
+  const match = /^#\/paths\/([^/]+)\/(\w+)$/.exec(link.operationRef ?? "");
+  if (!match) return void 0;
+  const path2 = match[1].replace(/~1/g, "/").replace(/~0/g, "~");
+  return model.operations.find((operation) => operation.path === path2 && operation.method === match[2]);
+}
+
+// src/request.ts
+function jsonMediaType(content = {}) {
+  const types = Object.keys(content);
+  return types.find((type) => /json/i.test(type)) ?? types[0];
+}
+function parameterExample(spec, param) {
+  if (param.example !== void 0) return param.example;
+  const named = param.examples && Object.values(param.examples)[0];
+  if (named?.value !== void 0) return named.value;
+  return exampleFromSchema(spec, param.schema);
+}
+function defaultValues(spec, operation) {
+  const values = { path: {}, query: {}, header: {}, cookie: {} };
+  for (const param of operation.parameters) {
+    const example = parameterExample(spec, param);
+    const include = param.in === "path" || param.required;
+    values[param.in] ??= {};
+    values[param.in][param.name] = include && example !== void 0 && example !== null ? String(example) : "";
+  }
+  return values;
+}
+var isMultipart = (contentType) => /^multipart\/form-data/i.test(contentType ?? "");
+var isBinary = (schema) => schema.type === "string" && (schema.format === "binary" || schema.format === "base64" || Boolean(schema.contentMediaType));
+function defaultForm(spec, media) {
+  const { schema } = resolveSchema(spec, media?.schema ?? {});
+  const example = mediaExample(spec, media) ?? {};
+  const fields = [];
+  for (const [name, raw] of Object.entries(schema.properties ?? {})) {
+    const property = resolveSchema(spec, raw).schema;
+    const items = property.type === "array" && property.items ? resolveSchema(spec, property.items).schema : null;
+    if (isBinary(property) || items && isBinary(items)) {
+      fields.push({ name, file: { name: `${name}.bin`, type: media?.encoding?.[name]?.contentType } });
+      continue;
+    }
+    const value = example[name];
+    for (const entry of Array.isArray(value) ? value : [value]) {
+      if (entry === void 0 || entry === null) continue;
+      fields.push({ name, value: typeof entry === "object" ? JSON.stringify(entry) : String(entry) });
+    }
+  }
+  return fields;
+}
+function defaultBody(spec, operation) {
+  const content = operation.requestBody?.content;
+  const type = jsonMediaType(content);
+  if (!type) return { contentType: null, body: "" };
+  if (isMultipart(type)) return { contentType: type, body: "", form: defaultForm(spec, content[type]) };
+  const example = mediaExample(spec, content[type]);
+  if (example === void 0) return { contentType: type, body: "" };
+  return { contentType: type, body: /x-www-form-urlencoded/i.test(type) ? formEncode(example) : JSON.stringify(example, null, 2) };
+}
+function formEncode(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return "";
+  const params = new URLSearchParams();
+  for (const [key, item] of Object.entries(value)) {
+    for (const entry of Array.isArray(item) ? item : [item]) {
+      if (entry === void 0 || entry === null) continue;
+      params.append(key, typeof entry === "object" ? JSON.stringify(entry) : String(entry));
+    }
+  }
+  return params.toString();
+}
+function buildRequest(operation, { server, values, body, form, contentType, headers = {} }) {
+  const base = (server ? serverUrl(server) : "").replace(/\/+$/, "");
+  const path2 = operation.path.replace(/\{([^}]+)\}/g, (match, key) => {
+    const value = values.path?.[key];
+    return value ? encodeURIComponent(value) : match;
+  });
+  const query = new URLSearchParams();
+  for (const [key, value] of Object.entries(values.query ?? {})) {
+    if (value !== "") query.append(key, value);
+  }
+  const search = query.toString();
+  const allHeaders = { ...headers };
+  for (const [key, value] of Object.entries(values.header ?? {})) {
+    if (value !== "") allHeaders[key] = value;
+  }
+  const cookies = Object.entries(values.cookie ?? {}).filter(([, value]) => value !== "").map(([key, value]) => `${key}=${value}`).join("; ");
+  if (cookies) allHeaders.Cookie = cookies;
+  const canHaveBody = !["get", "head"].includes(operation.method);
+  const multipart = canHaveBody && Boolean(form?.length) && isMultipart(contentType);
+  const hasBody = !multipart && canHaveBody && Boolean(body);
+  if (hasBody && contentType) allHeaders["Content-Type"] = contentType;
+  const request = {
+    method: operation.method.toUpperCase(),
+    url: `${base}${path2}${search ? `?${search.replace(/%5B/g, "[").replace(/%5D/g, "]")}` : ""}`,
+    headers: allHeaders,
+    body: hasBody ? body : void 0
+  };
+  if (multipart) request.form = form;
+  return request;
+}
+
+// src/multipart.ts
+var dq = (value) => JSON.stringify(String(value));
+var sq = (value) => `'${String(value).replace(/\\/g, "\\\\").replace(/'/g, "\\'")}'`;
+var shellQuote = (value) => `'${String(value).replace(/'/g, "'\\''")}'`;
+var psQuote = (value) => `'${String(value).replace(/'/g, "''")}'`;
+var dartQuote = (value) => sq(value).replace(/\$/g, "\\$");
+var kotlinQuote = (value) => dq(value).replace(/\$/g, "\\$");
+var indent = (text, prefix) => text.split("\n").join(`
+${prefix}`);
+var capitalize = (method) => method.charAt(0) + method.slice(1).toLowerCase();
+var path = (field) => `./${field.file.name}`;
+var fileType = (field) => field.file.type ?? "application/octet-stream";
+var files = (form) => form.filter((field) => field.file);
+var texts = (form) => form.filter((field) => !field.file);
+var headerList = (headers) => Object.entries(headers);
+var jsObject = (value, pad) => indent(JSON.stringify(value, null, 2), pad);
+function parseUrl(url) {
+  try {
+    return new URL(url);
+  } catch {
+    return new URL(url, "http://localhost");
+  }
+}
+var note = (comment, text) => `${comment} ${text}`;
+function curl({ method, url, headers, form = [] }) {
+  const parts = [`curl --request ${method}`, `--url ${shellQuote(url)}`];
+  for (const [key, value] of headerList(headers)) parts.push(`--header ${shellQuote(`${key}: ${value}`)}`);
+  for (const field of form) {
+    parts.push(field.file ? `--form ${shellQuote(`${field.name}=@${path(field)}`)}` : `--form-string ${shellQuote(`${field.name}=${field.value ?? ""}`)}`);
+  }
+  return parts.join(" \\\n  ");
+}
+function httpie({ method, url, headers, form = [] }) {
+  const parts = [`http --multipart ${method} ${shellQuote(url)}`];
+  for (const [key, value] of headerList(headers)) parts.push(shellQuote(`${key}:${value}`));
+  for (const field of form) parts.push(shellQuote(field.file ? `${field.name}@${path(field)}` : `${field.name}=${field.value ?? ""}`));
+  return parts.join(" \\\n  ");
+}
+function formData(form, node) {
+  const lines = ["const form = new FormData();"];
+  for (const field of form) {
+    if (!field.file) lines.push(`form.append(${dq(field.name)}, ${dq(field.value ?? "")});`);
+    else if (node) lines.push(`form.append(${dq(field.name)}, await openAsBlob(${dq(path(field))}), ${dq(field.file.name)});`);
+    else lines.push(`form.append(${dq(field.name)}, fileInput.files[0]); // <input type="file" id="fileInput">`);
+  }
+  return lines;
+}
+var nodeImports = (form) => files(form).length ? ['import { openAsBlob } from "node:fs";', ""] : [];
+function fetchClient(node) {
+  return ({ method, url, headers, form = [] }) => {
+    const options = [`  method: ${dq(method)},`];
+    if (headerList(headers).length) options.push(`  headers: ${jsObject(headers, "  ")},`);
+    options.push("  body: form,");
+    return [
+      ...node ? nodeImports(form) : [],
+      ...formData(form, node),
+      "",
+      `const response = await fetch(${dq(url)}, {`,
+      ...options,
+      "});",
+      "",
+      "const data = await response.json();",
+      "console.log(data);"
+    ].join("\n");
+  };
+}
+function axios(node) {
+  return ({ method, url, headers, form = [] }) => {
+    const options = [`  method: ${dq(method)},`, `  url: ${dq(url)},`];
+    if (headerList(headers).length) options.push(`  headers: ${jsObject(headers, "  ")},`);
+    options.push("  data: form,");
+    return [
+      'import axios from "axios";',
+      ...node && files(form).length ? ['import { openAsBlob } from "node:fs";'] : [],
+      "",
+      ...formData(form, node),
+      "",
+      "const { data } = await axios.request({",
+      ...options,
+      "});",
+      "",
+      "console.log(data);"
+    ].join("\n");
+  };
+}
+function jquery({ method, url, headers, form = [] }) {
+  const options = [`  url: ${dq(url)},`, `  method: ${dq(method)},`];
+  if (headerList(headers).length) options.push(`  headers: ${jsObject(headers, "  ")},`);
+  options.push("  data: form,", "  processData: false,", "  contentType: false,");
+  return [...formData(form, false), "", "$.ajax({", ...options, "}).done((response) => {", "  console.log(response);", "});"].join("\n");
+}
+function xhr({ method, url, headers, form = [] }) {
+  return [
+    ...formData(form, false),
+    "",
+    "const xhr = new XMLHttpRequest();",
+    `xhr.open(${dq(method)}, ${dq(url)});`,
+    ...headerList(headers).map(([key, value]) => `xhr.setRequestHeader(${dq(key)}, ${dq(value)});`),
+    "",
+    'xhr.addEventListener("load", () => {',
+    "  console.log(xhr.responseText);",
+    "});",
+    "",
+    "xhr.send(form);"
+  ].join("\n");
+}
+function undici({ method, url, headers, form = [] }) {
+  const options = [`  method: ${dq(method)},`];
+  if (headerList(headers).length) options.push(`  headers: ${jsObject(headers, "  ")},`);
+  options.push("  body: form,");
+  return [
+    'import { request, FormData } from "undici";',
+    ...files(form).length ? ['import { openAsBlob } from "node:fs";'] : [],
+    "",
+    ...formData(form, true),
+    "",
+    `const { statusCode, body } = await request(${dq(url)}, {`,
+    ...options,
+    "});",
+    "",
+    "console.log(statusCode, await body.json());"
+  ].join("\n");
+}
+var pyString = (value) => JSON.stringify(String(value));
+function pythonClient(library) {
+  return ({ method, url, headers, form = [] }) => {
+    const lines = [`import ${library}`, "", `url = ${pyString(url)}`];
+    const args = [pyString(method), "url"];
+    if (headerList(headers).length) {
+      lines.push(`headers = {${headerList(headers).map(([key, value]) => `${pyString(key)}: ${pyString(value)}`).join(", ")}}`);
+      args.push("headers=headers");
+    }
+    const grouped = /* @__PURE__ */ new Map();
+    for (const field of texts(form)) grouped.set(field.name, [...grouped.get(field.name) ?? [], field.value ?? ""]);
+    if (grouped.size) {
+      const entries = [...grouped].map(([name, values]) => `${pyString(name)}: ${values.length > 1 ? `[${values.map(pyString).join(", ")}]` : pyString(values[0])}`);
+      lines.push(`data = {${entries.join(", ")}}`);
+      args.push("data=data");
+    }
+    const fileFields = files(form);
+    lines.push(
+      `files = [${fileFields.map((field) => `(${pyString(field.name)}, (${pyString(field.file.name)}, open(${pyString(path(field))}, "rb"), ${pyString(fileType(field))}))`).join(", ")}]`
+    );
+    args.push("files=files");
+    lines.push("", `response = ${library}.request(${args.join(", ")})`, "", "print(response.json())");
+    return lines.join("\n");
+  };
+}
+function phpCurl({ method, url, headers, form = [] }) {
+  const lines = [
+    "<?php",
+    "",
+    "$curl = curl_init();",
+    "",
+    "curl_setopt_array($curl, [",
+    `    CURLOPT_URL => ${sq(url)},`,
+    "    CURLOPT_RETURNTRANSFER => true,",
+    `    CURLOPT_CUSTOMREQUEST => ${sq(method)},`
+  ];
+  const headerLines = headerList(headers).map(([key, value]) => `        ${sq(`${key}: ${value}`)},`);
+  if (headerLines.length) lines.push("    CURLOPT_HTTPHEADER => [", ...headerLines, "    ],");
+  const names = form.map((field) => field.name);
+  if (new Set(names).size !== names.length) {
+    lines.splice(1, 0, "", "// PHP arrays cannot repeat a key, so repeated fields keep only their last value; use the Guzzle example for those.");
+  }
+  lines.push(
+    "    CURLOPT_POSTFIELDS => [",
+    ...form.map(
+      (field) => field.file ? `        ${sq(field.name)} => new CURLFile(${sq(path(field))}, ${sq(fileType(field))}, ${sq(field.file.name)}),` : `        ${sq(field.name)} => ${sq(field.value ?? "")},`
+    ),
+    "    ],",
+    "]);",
+    "",
+    "$response = curl_exec($curl);",
+    "curl_close($curl);",
+    "",
+    "echo $response;"
+  );
+  return lines.join("\n");
+}
+function guzzle({ method, url, headers, form = [] }) {
+  const options = [];
+  if (headerList(headers).length) {
+    options.push("    'headers' => [", ...headerList(headers).map(([key, value]) => `        ${sq(key)} => ${sq(value)},`), "    ],");
+  }
+  options.push(
+    "    'multipart' => [",
+    ...form.map(
+      (field) => field.file ? `        ['name' => ${sq(field.name)}, 'contents' => fopen(${sq(path(field))}, 'r'), 'filename' => ${sq(field.file.name)}],` : `        ['name' => ${sq(field.name)}, 'contents' => ${sq(field.value ?? "")}],`
+    ),
+    "    ],"
+  );
+  return [
+    "<?php",
+    "",
+    "require 'vendor/autoload.php';",
+    "",
+    "$client = new \\GuzzleHttp\\Client();",
+    "",
+    `$response = $client->request(${sq(method)}, ${sq(url)}, [
+${options.join("\n")}
+]);`,
+    "",
+    "echo $response->getBody();"
+  ].join("\n");
+}
+function go({ method, url, headers, form = [] }) {
+  const fileFields = files(form);
+  const body = ["	body := &bytes.Buffer{}", "	writer := multipart.NewWriter(body)"];
+  for (const field of form) {
+    if (!field.file) {
+      body.push(`	writer.WriteField(${dq(field.name)}, ${dq(field.value ?? "")})`);
+      continue;
+    }
+    const variable = `file${body.length}`;
+    body.push(
+      "",
+      `	${variable}, err := os.Open(${dq(path(field))})`,
+      "	if err != nil {",
+      "		panic(err)",
+      "	}",
+      `	defer ${variable}.Close()`,
+      `	part${variable}, _ := writer.CreateFormFile(${dq(field.name)}, ${dq(field.file.name)})`,
+      `	io.Copy(part${variable}, ${variable})`
+    );
+  }
+  body.push("	writer.Close()");
+  const imports = ['"bytes"', '"fmt"', '"io"', '"mime/multipart"', '"net/http"', ...fileFields.length ? ['"os"'] : []];
+  return [
+    "package main",
+    "",
+    "import (",
+    ...imports.map((item) => `	${item}`),
+    ")",
+    "",
+    "func main() {",
+    ...body,
+    "",
+    `	req, _ := http.NewRequest(${dq(method)}, ${dq(url)}, body)`,
+    '	req.Header.Set("Content-Type", writer.FormDataContentType())',
+    ...headerList(headers).map(([key, value]) => `	req.Header.Add(${dq(key)}, ${dq(value)})`),
+    "",
+    "	res, err := http.DefaultClient.Do(req)",
+    "	if err != nil {",
+    "		panic(err)",
+    "	}",
+    "	defer res.Body.Close()",
+    "",
+    "	data, _ := io.ReadAll(res.Body)",
+    "	fmt.Println(string(data))",
+    "}"
+  ].join("\n");
+}
+function javaOkHttp({ method, url, headers, form = [] }) {
+  return [
+    "OkHttpClient client = new OkHttpClient();",
+    "",
+    "RequestBody body = new MultipartBody.Builder()",
+    "    .setType(MultipartBody.FORM)",
+    ...form.map(
+      (field) => field.file ? `    .addFormDataPart(${dq(field.name)}, ${dq(field.file.name)}, RequestBody.create(new File(${dq(path(field))}), MediaType.parse(${dq(fileType(field))})))` : `    .addFormDataPart(${dq(field.name)}, ${dq(field.value ?? "")})`
+    ),
+    "    .build();",
+    "Request request = new Request.Builder()",
+    `    .url(${dq(url)})`,
+    `    .method(${dq(method)}, body)`,
+    ...headerList(headers).map(([key, value]) => `    .addHeader(${dq(key)}, ${dq(value)})`),
+    "    .build();",
+    "",
+    "Response response = client.newCall(request).execute();",
+    "System.out.println(response.body().string());"
+  ].join("\n");
+}
+function kotlinOkHttp({ method, url, headers, form = [] }) {
+  return [
+    "val client = OkHttpClient()",
+    "",
+    "val body = MultipartBody.Builder()",
+    "    .setType(MultipartBody.FORM)",
+    ...form.map(
+      (field) => field.file ? `    .addFormDataPart(${kotlinQuote(field.name)}, ${kotlinQuote(field.file.name)}, File(${kotlinQuote(path(field))}).asRequestBody(${kotlinQuote(fileType(field))}.toMediaType()))` : `    .addFormDataPart(${kotlinQuote(field.name)}, ${kotlinQuote(field.value ?? "")})`
+    ),
+    "    .build()",
+    "val request = Request.Builder()",
+    `    .url(${kotlinQuote(url)})`,
+    `    .method(${kotlinQuote(method)}, body)`,
+    ...headerList(headers).map(([key, value]) => `    .addHeader(${kotlinQuote(key)}, ${kotlinQuote(value)})`),
+    "    .build()",
+    "",
+    "val response = client.newCall(request).execute()",
+    "println(response.body?.string())"
+  ].join("\n");
+}
+function csharpHttpClient({ method, url, headers, form = [] }) {
+  const lines = ["var client = new HttpClient();", "using var form = new MultipartFormDataContent();"];
+  for (const field of form) {
+    lines.push(
+      field.file ? `form.Add(new StreamContent(File.OpenRead(${dq(path(field))})), ${dq(field.name)}, ${dq(field.file.name)});` : `form.Add(new StringContent(${dq(field.value ?? "")}), ${dq(field.name)});`
+    );
+  }
+  lines.push("", "var request = new HttpRequestMessage", "{", `    Method = new HttpMethod(${dq(method)}),`, `    RequestUri = new Uri(${dq(url)}),`);
+  if (headerList(headers).length) {
+    lines.push("    Headers =", "    {", ...headerList(headers).map(([key, value]) => `        { ${dq(key)}, ${dq(value)} },`), "    },");
+  }
+  lines.push(
+    "    Content = form,",
+    "};",
+    "",
+    "using var response = await client.SendAsync(request);",
+    "Console.WriteLine(await response.Content.ReadAsStringAsync());"
+  );
+  return lines.join("\n");
+}
+function restSharp({ method, url, headers, form = [] }) {
+  return [
+    "using RestSharp;",
+    "",
+    `var client = new RestClient(${dq(url)});`,
+    `var request = new RestRequest("", Method.${capitalize(method)});`,
+    "request.AlwaysMultipartFormData = true;",
+    ...headerList(headers).map(([key, value]) => `request.AddHeader(${dq(key)}, ${dq(value)});`),
+    ...form.map(
+      (field) => field.file ? `request.AddFile(${dq(field.name)}, ${dq(path(field))});` : `request.AddParameter(${dq(field.name)}, ${dq(field.value ?? "")});`
+    ),
+    "",
+    "var response = await client.ExecuteAsync(request);",
+    "Console.WriteLine(response.Content);"
+  ].join("\n");
+}
+function ruby({ method, url, headers, form = [] }) {
+  const lines = ['require "uri"', 'require "net/http"', "", `url = URI(${sq(url)})`, "", "http = Net::HTTP.new(url.host, url.port)"];
+  if (parseUrl(url).protocol === "https:") lines.push("http.use_ssl = true");
+  lines.push("", `request = Net::HTTP::${capitalize(method)}.new(url)`);
+  for (const [key, value] of headerList(headers)) lines.push(`request[${sq(key)}] = ${sq(value)}`);
+  const parts = form.map((field) => field.file ? `[${sq(field.name)}, File.open(${sq(path(field))})]` : `[${sq(field.name)}, ${sq(field.value ?? "")}]`);
+  lines.push(`request.set_form([${parts.join(", ")}], "multipart/form-data")`, "", "response = http.request(request)", "puts response.read_body");
+  return lines.join("\n");
+}
+function swift({ method, url, headers, form = [] }) {
+  const lines = [
+    "import Foundation",
+    "",
+    `let url = URL(string: ${dq(url)})!`,
+    "var request = URLRequest(url: url)",
+    `request.httpMethod = ${dq(method)}`
+  ];
+  for (const [key, value] of headerList(headers)) lines.push(`request.setValue(${dq(value)}, forHTTPHeaderField: ${dq(key)})`);
+  lines.push(
+    "",
+    'let boundary = "Boundary-\\(UUID().uuidString)"',
+    'request.setValue("multipart/form-data; boundary=\\(boundary)", forHTTPHeaderField: "Content-Type")',
+    "",
+    "var body = Data()"
+  );
+  for (const field of form) {
+    const name = JSON.stringify(field.name).slice(1, -1);
+    if (field.file) {
+      const fileName = JSON.stringify(field.file.name).slice(1, -1);
+      lines.push(
+        `body.append("--\\(boundary)\\r\\nContent-Disposition: form-data; name=\\"${name}\\"; filename=\\"${fileName}\\"\\r\\nContent-Type: ${fileType(field)}\\r\\n\\r\\n".data(using: .utf8)!)`,
+        `body.append(try Data(contentsOf: URL(fileURLWithPath: ${dq(path(field))})))`,
+        'body.append("\\r\\n".data(using: .utf8)!)'
+      );
+    } else {
+      const value = JSON.stringify(field.value ?? "").slice(1, -1);
+      lines.push(`body.append("--\\(boundary)\\r\\nContent-Disposition: form-data; name=\\"${name}\\"\\r\\n\\r\\n${value}\\r\\n".data(using: .utf8)!)`);
+    }
+  }
+  lines.push(
+    'body.append("--\\(boundary)--\\r\\n".data(using: .utf8)!)',
+    "request.httpBody = body",
+    "",
+    "let (data, _) = try await URLSession.shared.data(for: request)",
+    "print(String(decoding: data, as: UTF8.self))"
+  );
+  return lines.join("\n");
+}
+function dart({ method, url, headers, form = [] }) {
+  const lines = ["import 'package:http/http.dart' as http;", "", "void main() async {"];
+  lines.push(`  final request = http.MultipartRequest(${dartQuote(method)}, Uri.parse(${dartQuote(url)}));`);
+  if (headerList(headers).length) {
+    lines.push("  request.headers.addAll({", ...headerList(headers).map(([key, value]) => `    ${dartQuote(key)}: ${dartQuote(value)},`), "  });");
+  }
+  const counts = /* @__PURE__ */ new Map();
+  for (const field of texts(form)) counts.set(field.name, (counts.get(field.name) ?? 0) + 1);
+  for (const field of form) {
+    if (field.file) lines.push(`  request.files.add(await http.MultipartFile.fromPath(${dartQuote(field.name)}, ${dartQuote(path(field))}));`);
+    else if (counts.get(field.name) > 1) lines.push(`  request.files.add(http.MultipartFile.fromString(${dartQuote(field.name)}, ${dartQuote(field.value ?? "")}));`);
+    else lines.push(`  request.fields[${dartQuote(field.name)}] = ${dartQuote(field.value ?? "")};`);
+  }
+  lines.push("", "  final response = await request.send();", "  print(await response.stream.bytesToString());", "}");
+  return lines.join("\n");
+}
+function rust({ method, url, headers, form = [] }) {
+  const standard = ["GET", "POST", "PUT", "DELETE", "HEAD", "OPTIONS", "PATCH", "TRACE"];
+  const methodExpr = standard.includes(method) ? `reqwest::Method::${method}` : `reqwest::Method::from_bytes(b${dq(method)})?`;
+  return [
+    '// reqwest with the "multipart" feature',
+    "#[tokio::main]",
+    "async fn main() -> Result<(), Box<dyn std::error::Error>> {",
+    "    let client = reqwest::Client::new();",
+    "",
+    "    let form = reqwest::multipart::Form::new()",
+    ...form.map(
+      (field) => field.file ? `        .part(${dq(field.name)}, reqwest::multipart::Part::bytes(std::fs::read(${dq(path(field))})?).file_name(${dq(field.file.name)}))` : `        .text(${dq(field.name)}, ${dq(field.value ?? "")})`
+    ),
+    "        ;",
+    "",
+    "    let response = client",
+    `        .request(${methodExpr}, ${dq(url)})`,
+    ...headerList(headers).map(([key, value]) => `        .header(${dq(key)}, ${dq(value)})`),
+    "        .multipart(form)",
+    "        .send()",
+    "        .await?;",
+    "",
+    '    println!("{}", response.text().await?);',
+    "    Ok(())",
+    "}"
+  ].join("\n");
+}
+function libcurl({ method, url, headers, form = [] }) {
+  const lines = [
+    "#include <curl/curl.h>",
+    "",
+    "int main(void) {",
+    "  CURL *curl = curl_easy_init();",
+    "",
+    `  curl_easy_setopt(curl, CURLOPT_CUSTOMREQUEST, ${dq(method)});`,
+    `  curl_easy_setopt(curl, CURLOPT_URL, ${dq(url)});`,
+    "",
+    "  struct curl_slist *headers = NULL;",
+    ...headerList(headers).map(([key, value]) => `  headers = curl_slist_append(headers, ${dq(`${key}: ${value}`)});`),
+    "  curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headers);",
+    "",
+    "  curl_mime *mime = curl_mime_init(curl);",
+    "  curl_mimepart *part;"
+  ];
+  for (const field of form) {
+    lines.push("  part = curl_mime_addpart(mime);", `  curl_mime_name(part, ${dq(field.name)});`);
+    lines.push(field.file ? `  curl_mime_filedata(part, ${dq(path(field))});` : `  curl_mime_data(part, ${dq(field.value ?? "")}, CURL_ZERO_TERMINATED);`);
+  }
+  lines.push(
+    "  curl_easy_setopt(curl, CURLOPT_MIMEPOST, mime);",
+    "",
+    "  CURLcode ret = curl_easy_perform(curl);",
+    "",
+    "  curl_mime_free(mime);",
+    "  curl_slist_free_all(headers);",
+    "  curl_easy_cleanup(curl);",
+    "  return (int) ret;",
+    "}"
+  );
+  return lines.join("\n");
+}
+function powershell({ method, url, headers, form = [] }) {
+  const lines = ["# PowerShell 7+ (-Form)"];
+  const args = [`-Uri ${psQuote(url)}`, `-Method ${method}`];
+  if (headerList(headers).length) {
+    lines.push("$headers = @{", ...headerList(headers).map(([key, value]) => `    ${psQuote(key)} = ${psQuote(value)}`), "}");
+    args.push("-Headers $headers");
+  }
+  const grouped = /* @__PURE__ */ new Map();
+  for (const field of form) {
+    const value = field.file ? `(Get-Item -Path ${psQuote(path(field))})` : psQuote(field.value ?? "");
+    grouped.set(field.name, [...grouped.get(field.name) ?? [], value]);
+  }
+  lines.push(
+    "$form = @{",
+    ...[...grouped].map(([name, values]) => `    ${psQuote(name)} = ${values.length > 1 ? `@(${values.join(", ")})` : values[0]}`),
+    "}",
+    ""
+  );
+  args.push("-Form $form");
+  lines.push(`$response = Invoke-RestMethod ${args.join(" ")}`, "$response | ConvertTo-Json -Depth 10");
+  return lines.join("\n");
+}
+var BOUNDARY = "oaspect-boundary";
+function rawHttp({ method, url, headers, form = [] }) {
+  const target = parseUrl(url);
+  const lines = [`${method} ${target.pathname}${target.search} HTTP/1.1`, `Host: ${target.host}`];
+  for (const [key, value] of headerList(headers)) lines.push(`${key}: ${value}`);
+  lines.push(`Content-Type: multipart/form-data; boundary=${BOUNDARY}`, "");
+  for (const field of form) {
+    lines.push(`--${BOUNDARY}`);
+    if (field.file) {
+      lines.push(`Content-Disposition: form-data; name="${field.name}"; filename="${field.file.name}"`, `Content-Type: ${fileType(field)}`, "", `(contents of ${field.file.name})`);
+    } else {
+      lines.push(`Content-Disposition: form-data; name="${field.name}"`, "", field.value ?? "");
+    }
+  }
+  lines.push(`--${BOUNDARY}--`);
+  return lines.join("\n");
+}
+var MULTIPART_BUILDERS = {
+  "shell:curl": curl,
+  "shell:wget": () => note("#", "wget cannot send multipart/form-data; use the cURL or HTTPie example."),
+  "shell:httpie": httpie,
+  "javascript:fetch": fetchClient(false),
+  "javascript:axios": axios(false),
+  "javascript:jquery": jquery,
+  "javascript:xhr": xhr,
+  "node:fetch": fetchClient(true),
+  "node:axios": axios(true),
+  "node:undici": undici,
+  "node:http": () => note("//", "node:http has no multipart/form-data encoder; use the fetch or undici example."),
+  "python:requests": pythonClient("requests"),
+  "python:httpx": pythonClient("httpx"),
+  "python:http.client": () => note("#", "http.client has no multipart/form-data encoder; use the requests or httpx example."),
+  "php:curl": phpCurl,
+  "php:guzzle": guzzle,
+  "go:native": go,
+  "java:httpclient": () => note("//", "java.net.http has no multipart/form-data encoder; use the OkHttp example."),
+  "java:okhttp": javaOkHttp,
+  "kotlin:okhttp": kotlinOkHttp,
+  "csharp:httpclient": csharpHttpClient,
+  "csharp:restsharp": restSharp,
+  "ruby:native": ruby,
+  "swift:urlsession": swift,
+  "dart:http": dart,
+  "rust:reqwest": rust,
+  "c:libcurl": libcurl,
+  "powershell:restmethod": powershell,
+  "http:raw": rawHttp
+};
+
+// src/snippets.ts
+var dq2 = (value) => JSON.stringify(String(value));
+var sq2 = (value) => `'${String(value).replace(/\\/g, "\\\\").replace(/'/g, "\\'")}'`;
+var shellQuote2 = (value) => `'${String(value).replace(/'/g, "'\\''")}'`;
+var psQuote2 = (value) => `'${String(value).replace(/'/g, "''")}'`;
+var dartQuote2 = (value) => sq2(value).replace(/\$/g, "\\$");
+var kotlinQuote2 = (value) => dq2(value).replace(/\$/g, "\\$");
+var indent2 = (text, prefix) => text.split("\n").join(`
+${prefix}`);
+function parseJson(body) {
+  if (body === void 0) return void 0;
+  try {
+    return JSON.parse(body);
+  } catch {
+    return void 0;
+  }
+}
+var compact = (body) => {
+  const json = parseJson(body);
+  return json === void 0 ? body : JSON.stringify(json);
+};
+var contentTypeOf = (headers) => Object.entries(headers).find(([key]) => key.toLowerCase() === "content-type")?.[1];
+var withoutContentType = (headers) => Object.fromEntries(Object.entries(headers).filter(([key]) => key.toLowerCase() !== "content-type"));
+function parseUrl2(url) {
+  try {
+    return new URL(url);
+  } catch {
+    return new URL(url, "http://localhost");
+  }
+}
+var capitalize2 = (method) => method.charAt(0) + method.slice(1).toLowerCase();
+function toPython(value, pad = "") {
+  if (value === null) return "None";
+  if (value === true) return "True";
+  if (value === false) return "False";
+  if (typeof value !== "object") return JSON.stringify(value);
+  const next = `${pad}    `;
+  if (Array.isArray(value)) {
+    return value.length ? `[
+${value.map((item) => next + toPython(item, next)).join(",\n")},
+${pad}]` : "[]";
+  }
+  const entries = Object.entries(value);
+  return entries.length ? `{
+${entries.map(([key, item]) => `${next}${JSON.stringify(key)}: ${toPython(item, next)}`).join(",\n")},
+${pad}}` : "{}";
+}
+function toPhp(value, pad = "") {
+  if (value === null) return "null";
+  if (typeof value === "boolean" || typeof value === "number") return String(value);
+  if (typeof value === "string") return sq2(value);
+  if (!Array.isArray(value) && Object.keys(value).length === 0) return "(object) []";
+  const next = `${pad}    `;
+  const items = Array.isArray(value) ? value.map((item) => next + toPhp(item, next)) : Object.entries(value).map(([key, item]) => `${next}${sq2(key)} => ${toPhp(item, next)}`);
+  return items.length ? `[
+${items.join(",\n")},
+${pad}]` : "[]";
+}
+function toRuby(value, pad = "") {
+  if (value === null) return "nil";
+  if (typeof value === "boolean" || typeof value === "number") return String(value);
+  if (typeof value === "string") return sq2(value);
+  const next = `${pad}  `;
+  if (Array.isArray(value)) {
+    return value.length ? `[
+${value.map((item) => next + toRuby(item, next)).join(",\n")}
+${pad}]` : "[]";
+  }
+  const entries = Object.entries(value);
+  return entries.length ? `{
+${entries.map(([key, item]) => `${next}${sq2(key)} => ${toRuby(item, next)}`).join(",\n")}
+${pad}}` : "{}";
+}
+var jsObject2 = (value, pad) => indent2(JSON.stringify(value, null, 2), pad);
+function jsBody(body, pad) {
+  const json = parseJson(body);
+  return json === void 0 ? dq2(body) : `JSON.stringify(${jsObject2(json, pad)})`;
+}
+function curl2({ method, url, headers, body }) {
+  const parts = [`curl --request ${method}`, `--url ${shellQuote2(url)}`];
+  for (const [key, value] of Object.entries(headers)) parts.push(`--header ${shellQuote2(`${key}: ${value}`)}`);
+  if (body !== void 0) parts.push(`--data ${shellQuote2(body)}`);
+  return parts.join(" \\\n  ");
+}
+function wget({ method, url, headers, body }) {
+  const parts = ["wget --quiet", `--method=${method}`];
+  for (const [key, value] of Object.entries(headers)) parts.push(`--header=${shellQuote2(`${key}: ${value}`)}`);
+  if (body !== void 0) parts.push(`--body-data=${shellQuote2(body)}`);
+  parts.push("--output-document=-", shellQuote2(url));
+  return parts.join(" \\\n  ");
+}
+function httpie2({ method, url, headers, body }) {
+  const command = `http ${method} ${shellQuote2(url)}`;
+  const parts = [body !== void 0 ? `printf '%s' ${shellQuote2(body)} | ${command}` : command];
+  for (const [key, value] of Object.entries(headers)) parts.push(shellQuote2(`${key}:${value}`));
+  return parts.join(" \\\n  ");
+}
+function fetchClient2({ method, url, headers, body }) {
+  const options = [`  method: ${dq2(method)},`];
+  if (Object.keys(headers).length) options.push(`  headers: ${jsObject2(headers, "  ")},`);
+  if (body !== void 0) options.push(`  body: ${jsBody(body, "  ")},`);
+  return [`const response = await fetch(${dq2(url)}, {`, ...options, "});", "", "const data = await response.json();", "console.log(data);"].join("\n");
+}
+function axios2({ method, url, headers, body }) {
+  const options = [`  method: ${dq2(method)},`, `  url: ${dq2(url)},`];
+  if (Object.keys(headers).length) options.push(`  headers: ${jsObject2(headers, "  ")},`);
+  if (body !== void 0) {
+    const json = parseJson(body);
+    options.push(`  data: ${json === void 0 ? dq2(body) : jsObject2(json, "  ")},`);
+  }
+  return ['import axios from "axios";', "", "const { data } = await axios.request({", ...options, "});", "", "console.log(data);"].join("\n");
+}
+function jquery2({ method, url, headers, body }) {
+  const options = [`  url: ${dq2(url)},`, `  method: ${dq2(method)},`];
+  if (Object.keys(headers).length) options.push(`  headers: ${jsObject2(headers, "  ")},`);
+  if (body !== void 0) options.push(`  data: ${jsBody(body, "  ")},`);
+  return ["$.ajax({", ...options, "}).done((response) => {", "  console.log(response);", "});"].join("\n");
+}
+function xhr2({ method, url, headers, body }) {
+  return [
+    "const xhr = new XMLHttpRequest();",
+    `xhr.open(${dq2(method)}, ${dq2(url)});`,
+    ...Object.entries(headers).map(([key, value]) => `xhr.setRequestHeader(${dq2(key)}, ${dq2(value)});`),
+    "",
+    'xhr.addEventListener("load", () => {',
+    "  console.log(xhr.responseText);",
+    "});",
+    "",
+    body !== void 0 ? `xhr.send(${jsBody(body, "")});` : "xhr.send();"
+  ].join("\n");
+}
+function undici2({ method, url, headers, body }) {
+  const options = [`  method: ${dq2(method)},`];
+  if (Object.keys(headers).length) options.push(`  headers: ${jsObject2(headers, "  ")},`);
+  if (body !== void 0) options.push(`  body: ${jsBody(body, "  ")},`);
+  return [
+    'import { request } from "undici";',
+    "",
+    `const { statusCode, body } = await request(${dq2(url)}, {`,
+    ...options,
+    "});",
+    "",
+    "console.log(statusCode, await body.json());"
+  ].join("\n");
+}
+function nodeHttp({ method, url, headers, body }) {
+  const lib = parseUrl2(url).protocol === "https:" ? "https" : "http";
+  const options = [`  method: ${dq2(method)},`];
+  if (Object.keys(headers).length) options.push(`  headers: ${jsObject2(headers, "  ")},`);
+  return [
+    `import ${lib} from "node:${lib}";`,
+    "",
+    `const req = ${lib}.request(${dq2(url)}, {`,
+    ...options,
+    "}, (res) => {",
+    '  let data = "";',
+    '  res.on("data", (chunk) => (data += chunk));',
+    '  res.on("end", () => console.log(data));',
+    "});",
+    "",
+    ...body !== void 0 ? [`req.write(${jsBody(body, "")});`] : [],
+    "req.end();"
+  ].join("\n");
+}
+function pythonClient2(library) {
+  return ({ method, url, headers, body }) => {
+    const json = parseJson(body);
+    const lines = [`import ${library}`, "", `url = ${dq2(url)}`];
+    const args = [dq2(method), "url"];
+    if (Object.keys(headers).length) {
+      lines.push(`headers = ${toPython(headers)}`);
+      args.push("headers=headers");
+    }
+    if (json !== void 0) {
+      lines.push(`payload = ${toPython(json)}`);
+      args.push("json=payload");
+    } else if (body !== void 0) {
+      lines.push(`payload = ${dq2(body)}`);
+      args.push("data=payload");
+    }
+    lines.push("", `response = ${library}.request(${args.join(", ")})`, "", "print(response.json())");
+    return lines.join("\n");
+  };
+}
+function pythonHttpClient({ method, url, headers, body }) {
+  const target = parseUrl2(url);
+  const connection = target.protocol === "https:" ? "HTTPSConnection" : "HTTPConnection";
+  const json = parseJson(body);
+  const lines = ["import http.client"];
+  if (json !== void 0) lines.push("import json");
+  lines.push("", `conn = http.client.${connection}(${dq2(target.host)})`);
+  let payload = "None";
+  if (json !== void 0) {
+    lines.push(`payload = json.dumps(${toPython(json)})`);
+    payload = "payload";
+  } else if (body !== void 0) {
+    lines.push(`payload = ${dq2(body)}`);
+    payload = "payload";
+  }
+  lines.push(`headers = ${toPython(headers)}`);
+  lines.push(
+    "",
+    `conn.request(${dq2(method)}, ${dq2(target.pathname + target.search)}, ${payload}, headers)`,
+    "res = conn.getresponse()",
+    "",
+    'print(res.read().decode("utf-8"))'
+  );
+  return lines.join("\n");
+}
+function phpCurl2({ method, url, headers, body }) {
+  const json = parseJson(body);
+  const lines = [
+    "<?php",
+    "",
+    "$curl = curl_init();",
+    "",
+    "curl_setopt_array($curl, [",
+    `    CURLOPT_URL => ${sq2(url)},`,
+    "    CURLOPT_RETURNTRANSFER => true,",
+    `    CURLOPT_CUSTOMREQUEST => ${sq2(method)},`
+  ];
+  const headerLines = Object.entries(headers).map(([key, value]) => `        ${sq2(`${key}: ${value}`)},`);
+  if (headerLines.length) lines.push("    CURLOPT_HTTPHEADER => [", ...headerLines, "    ],");
+  if (json !== void 0) lines.push(`    CURLOPT_POSTFIELDS => json_encode(${toPhp(json, "    ")}),`);
+  else if (body !== void 0) lines.push(`    CURLOPT_POSTFIELDS => ${sq2(body)},`);
+  lines.push("]);", "", "$response = curl_exec($curl);", "curl_close($curl);", "", "echo $response;");
+  return lines.join("\n");
+}
+function guzzle2({ method, url, headers, body }) {
+  const json = parseJson(body);
+  const options = [];
+  const sentHeaders = json !== void 0 ? withoutContentType(headers) : headers;
+  if (Object.keys(sentHeaders).length) options.push(`    'headers' => ${toPhp(sentHeaders, "    ")},`);
+  if (json !== void 0) options.push(`    'json' => ${toPhp(json, "    ")},`);
+  else if (body !== void 0) options.push(`    'body' => ${sq2(body)},`);
+  return [
+    "<?php",
+    "",
+    "require 'vendor/autoload.php';",
+    "",
+    "$client = new \\GuzzleHttp\\Client();",
+    "",
+    options.length ? `$response = $client->request(${sq2(method)}, ${sq2(url)}, [
+${options.join("\n")}
+]);` : `$response = $client->request(${sq2(method)}, ${sq2(url)});`,
+    "",
+    "echo $response->getBody();"
+  ].join("\n");
+}
+function go2({ method, url, headers, body }) {
+  const hasBody = body !== void 0;
+  const literal = hasBody && !body.includes("`") ? `\`${body}\`` : hasBody ? dq2(body) : "";
+  const imports = ['"fmt"', '"io"', '"net/http"', ...hasBody ? ['"strings"'] : []];
+  return [
+    "package main",
+    "",
+    "import (",
+    ...imports.map((item) => `	${item}`),
+    ")",
+    "",
+    "func main() {",
+    ...hasBody ? [`	payload := strings.NewReader(${literal})`, ""] : [],
+    `	req, _ := http.NewRequest(${dq2(method)}, ${dq2(url)}, ${hasBody ? "payload" : "nil"})`,
+    ...Object.keys(headers).length ? ["", ...Object.entries(headers).map(([key, value]) => `	req.Header.Add(${dq2(key)}, ${dq2(value)})`)] : [],
+    "",
+    "	res, err := http.DefaultClient.Do(req)",
+    "	if err != nil {",
+    "		panic(err)",
+    "	}",
+    "	defer res.Body.Close()",
+    "",
+    "	data, _ := io.ReadAll(res.Body)",
+    "	fmt.Println(string(data))",
+    "}"
+  ].join("\n");
+}
+var textBlock = (body, pad) => `"""
+${pad}${indent2(body, pad)}
+${pad}"""`;
+function javaHttpClient({ method, url, headers, body }) {
+  const publisher = body !== void 0 ? `HttpRequest.BodyPublishers.ofString(${textBlock(body.replace(/\\/g, "\\\\"), "        ")})` : "HttpRequest.BodyPublishers.noBody()";
+  return [
+    "import java.net.URI;",
+    "import java.net.http.HttpClient;",
+    "import java.net.http.HttpRequest;",
+    "import java.net.http.HttpResponse;",
+    "",
+    "HttpRequest request = HttpRequest.newBuilder()",
+    `    .uri(URI.create(${dq2(url)}))`,
+    ...Object.entries(headers).map(([key, value]) => `    .header(${dq2(key)}, ${dq2(value)})`),
+    `    .method(${dq2(method)}, ${publisher})`,
+    "    .build();",
+    "",
+    "HttpResponse<String> response = HttpClient.newHttpClient()",
+    "    .send(request, HttpResponse.BodyHandlers.ofString());",
+    "",
+    "System.out.println(response.body());"
+  ].join("\n");
+}
+function javaOkHttp2({ method, url, headers, body }) {
+  const hasBody = body !== void 0;
+  return [
+    "OkHttpClient client = new OkHttpClient();",
+    "",
+    ...hasBody ? [
+      `MediaType mediaType = MediaType.parse(${dq2(contentTypeOf(headers) ?? "text/plain")});`,
+      `RequestBody body = RequestBody.create(${dq2(compact(body))}, mediaType);`
+    ] : [],
+    "Request request = new Request.Builder()",
+    `    .url(${dq2(url)})`,
+    `    .method(${dq2(method)}, ${hasBody ? "body" : "null"})`,
+    ...Object.entries(headers).map(([key, value]) => `    .addHeader(${dq2(key)}, ${dq2(value)})`),
+    "    .build();",
+    "",
+    "Response response = client.newCall(request).execute();",
+    "System.out.println(response.body().string());"
+  ].join("\n");
+}
+function kotlinOkHttp2({ method, url, headers, body }) {
+  const hasBody = body !== void 0;
+  return [
+    "val client = OkHttpClient()",
+    "",
+    ...hasBody ? [
+      `val mediaType = ${kotlinQuote2(contentTypeOf(headers) ?? "text/plain")}.toMediaType()`,
+      `val body = """
+${body.replace(/\$/g, () => "${'$'}")}
+""".trimIndent().toRequestBody(mediaType)`
+    ] : [],
+    "val request = Request.Builder()",
+    `    .url(${kotlinQuote2(url)})`,
+    `    .method(${kotlinQuote2(method)}, ${hasBody ? "body" : "null"})`,
+    ...Object.entries(headers).map(([key, value]) => `    .addHeader(${kotlinQuote2(key)}, ${kotlinQuote2(value)})`),
+    "    .build()",
+    "",
+    "val response = client.newCall(request).execute()",
+    "println(response.body?.string())"
+  ].join("\n");
+}
+function csharpHttpClient2({ method, url, headers, body }) {
+  const requestHeaders = Object.entries(withoutContentType(headers));
+  const contentType = contentTypeOf(headers);
+  const lines = [
+    "using System.Net.Http.Headers;",
+    "",
+    "var client = new HttpClient();",
+    "var request = new HttpRequestMessage",
+    "{",
+    `    Method = new HttpMethod(${dq2(method)}),`,
+    `    RequestUri = new Uri(${dq2(url)}),`
+  ];
+  if (requestHeaders.length) {
+    lines.push("    Headers =", "    {", ...requestHeaders.map(([key, value]) => `        { ${dq2(key)}, ${dq2(value)} },`), "    },");
+  }
+  if (body !== void 0) {
+    lines.push(`    Content = new StringContent(${textBlock(body, "        ")})`);
+    if (contentType) {
+      lines.push(
+        "    {",
+        "        Headers =",
+        "        {",
+        `            ContentType = new MediaTypeHeaderValue(${dq2(contentType)})`,
+        "        }",
+        "    }"
+      );
+    }
+  }
+  lines.push(
+    "};",
+    "",
+    "using var response = await client.SendAsync(request);",
+    "Console.WriteLine(await response.Content.ReadAsStringAsync());"
+  );
+  return lines.join("\n");
+}
+function restSharp2({ method, url, headers, body }) {
+  const contentType = contentTypeOf(headers) ?? "application/json";
+  return [
+    "using RestSharp;",
+    "",
+    `var client = new RestClient(${dq2(url)});`,
+    `var request = new RestRequest("", Method.${capitalize2(method)});`,
+    ...Object.entries(withoutContentType(headers)).map(([key, value]) => `request.AddHeader(${dq2(key)}, ${dq2(value)});`),
+    ...body !== void 0 ? [`request.AddStringBody(${dq2(compact(body))}, ${dq2(contentType)});`] : [],
+    "",
+    "var response = await client.ExecuteAsync(request);",
+    "Console.WriteLine(response.Content);"
+  ].join("\n");
+}
+function ruby2({ method, url, headers, body }) {
+  const json = parseJson(body);
+  const lines = ['require "uri"', 'require "net/http"'];
+  if (json !== void 0) lines.push('require "json"');
+  lines.push("", `url = URI(${sq2(url)})`, "", "http = Net::HTTP.new(url.host, url.port)");
+  if (parseUrl2(url).protocol === "https:") lines.push("http.use_ssl = true");
+  lines.push("", `request = Net::HTTP::${capitalize2(method)}.new(url)`);
+  for (const [key, value] of Object.entries(headers)) lines.push(`request[${sq2(key)}] = ${sq2(value)}`);
+  if (json !== void 0) lines.push(`request.body = JSON.dump(${toRuby(json)})`);
+  else if (body !== void 0) lines.push(`request.body = ${sq2(body)}`);
+  lines.push("", "response = http.request(request)", "puts response.read_body");
+  return lines.join("\n");
+}
+function swift2({ method, url, headers, body }) {
+  const lines = ["import Foundation", "", `let url = URL(string: ${dq2(url)})!`, "var request = URLRequest(url: url)", `request.httpMethod = ${dq2(method)}`];
+  const entries = Object.entries(headers);
+  if (entries.length) {
+    lines.push("request.allHTTPHeaderFields = [", ...entries.map(([key, value]) => `    ${dq2(key)}: ${dq2(value)},`), "]");
+  }
+  if (body !== void 0) lines.push(`request.httpBody = """
+${body.replace(/\\/g, "\\\\")}
+""".data(using: .utf8)`);
+  lines.push("", "let (data, _) = try await URLSession.shared.data(for: request)", "print(String(decoding: data, as: UTF8.self))");
+  return lines.join("\n");
+}
+function dart2({ method, url, headers, body }) {
+  const entries = Object.entries(headers);
+  const lines = ["import 'package:http/http.dart' as http;", "", "void main() async {"];
+  lines.push(`  final request = http.Request(${dartQuote2(method)}, Uri.parse(${dartQuote2(url)}));`);
+  if (entries.length) {
+    lines.push("  request.headers.addAll({", ...entries.map(([key, value]) => `    ${dartQuote2(key)}: ${dartQuote2(value)},`), "  });");
+  }
+  if (body !== void 0) lines.push(`  request.body = r'''
+${body}
+''';`);
+  lines.push("", "  final response = await request.send();", "  print(await response.stream.bytesToString());", "}");
+  return lines.join("\n");
+}
+function rust2({ method, url, headers, body }) {
+  const standard = ["GET", "POST", "PUT", "DELETE", "HEAD", "OPTIONS", "PATCH", "TRACE"];
+  const methodExpr = standard.includes(method) ? `reqwest::Method::${method}` : `reqwest::Method::from_bytes(b${dq2(method)}).unwrap()`;
+  let hashes = "#";
+  while (body !== void 0 && body.includes(`"${hashes}`)) hashes += "#";
+  return [
+    "#[tokio::main]",
+    "async fn main() -> Result<(), reqwest::Error> {",
+    "    let client = reqwest::Client::new();",
+    "",
+    "    let response = client",
+    `        .request(${methodExpr}, ${dq2(url)})`,
+    ...Object.entries(headers).map(([key, value]) => `        .header(${dq2(key)}, ${dq2(value)})`),
+    ...body !== void 0 ? [`        .body(r${hashes}"${body}"${hashes})`] : [],
+    "        .send()",
+    "        .await?;",
+    "",
+    '    println!("{}", response.text().await?);',
+    "    Ok(())",
+    "}"
+  ].join("\n");
+}
+function libcurl2({ method, url, headers, body }) {
+  const entries = Object.entries(headers);
+  return [
+    "#include <curl/curl.h>",
+    "",
+    "int main(void) {",
+    "  CURL *curl = curl_easy_init();",
+    "",
+    `  curl_easy_setopt(curl, CURLOPT_CUSTOMREQUEST, ${dq2(method)});`,
+    `  curl_easy_setopt(curl, CURLOPT_URL, ${dq2(url)});`,
+    "",
+    "  struct curl_slist *headers = NULL;",
+    ...entries.map(([key, value]) => `  headers = curl_slist_append(headers, ${dq2(`${key}: ${value}`)});`),
+    "  curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headers);",
+    ...body !== void 0 ? ["", `  curl_easy_setopt(curl, CURLOPT_POSTFIELDS, ${dq2(compact(body))});`] : [],
+    "",
+    "  CURLcode ret = curl_easy_perform(curl);",
+    "",
+    "  curl_slist_free_all(headers);",
+    "  curl_easy_cleanup(curl);",
+    "  return (int) ret;",
+    "}"
+  ].join("\n");
+}
+function powershell2({ method, url, headers, body }) {
+  const entries = Object.entries(withoutContentType(headers));
+  const contentType = contentTypeOf(headers);
+  const lines = [];
+  const args = [`-Uri ${psQuote2(url)}`, `-Method ${method}`];
+  if (entries.length) {
+    lines.push("$headers = @{", ...entries.map(([key, value]) => `    ${psQuote2(key)} = ${psQuote2(value)}`), "}");
+    args.push("-Headers $headers");
+  }
+  if (contentType) args.push(`-ContentType ${psQuote2(contentType)}`);
+  if (body !== void 0) {
+    lines.push(`$body = @'
+${body}
+'@`);
+    args.push("-Body $body");
+  }
+  if (lines.length) lines.push("");
+  lines.push(`$response = Invoke-RestMethod ${args.join(" ")}`, "$response | ConvertTo-Json -Depth 10");
+  return lines.join("\n");
+}
+function rawHttp2({ method, url, headers, body }) {
+  const target = parseUrl2(url);
+  const lines = [`${method} ${target.pathname}${target.search} HTTP/1.1`, `Host: ${target.host}`];
+  for (const [key, value] of Object.entries(headers)) lines.push(`${key}: ${value}`);
+  if (body !== void 0) lines.push(`Content-Length: ${new TextEncoder().encode(body).length}`, "", body);
+  return lines.join("\n");
+}
+var LANGUAGES = [
+  {
+    key: "shell",
+    label: "Shell",
+    highlight: "shell",
+    clients: [
+      { key: "curl", label: "cURL", build: curl2 },
+      { key: "wget", label: "Wget", build: wget },
+      { key: "httpie", label: "HTTPie", build: httpie2 }
+    ]
+  },
+  {
+    key: "javascript",
+    label: "JavaScript",
+    highlight: "javascript",
+    clients: [
+      { key: "fetch", label: "fetch", build: fetchClient2 },
+      { key: "axios", label: "Axios", build: axios2 },
+      { key: "jquery", label: "jQuery", build: jquery2 },
+      { key: "xhr", label: "XHR", build: xhr2 }
+    ]
+  },
+  {
+    key: "node",
+    label: "Node.js",
+    highlight: "javascript",
+    clients: [
+      { key: "fetch", label: "fetch", build: fetchClient2 },
+      { key: "axios", label: "Axios", build: axios2 },
+      { key: "undici", label: "undici", build: undici2 },
+      { key: "http", label: "http", build: nodeHttp }
+    ]
+  },
+  {
+    key: "python",
+    label: "Python",
+    highlight: "python",
+    clients: [
+      { key: "requests", label: "requests", build: pythonClient2("requests") },
+      { key: "httpx", label: "httpx", build: pythonClient2("httpx") },
+      { key: "http.client", label: "http.client", build: pythonHttpClient }
+    ]
+  },
+  {
+    key: "php",
+    label: "PHP",
+    highlight: "php",
+    clients: [
+      { key: "curl", label: "cURL", build: phpCurl2 },
+      { key: "guzzle", label: "Guzzle", build: guzzle2 }
+    ]
+  },
+  { key: "go", label: "Go", highlight: "go", clients: [{ key: "native", label: "net/http", build: go2 }] },
+  {
+    key: "java",
+    label: "Java",
+    highlight: "java",
+    clients: [
+      { key: "httpclient", label: "HttpClient", build: javaHttpClient },
+      { key: "okhttp", label: "OkHttp", build: javaOkHttp2 }
+    ]
+  },
+  { key: "kotlin", label: "Kotlin", highlight: "kotlin", clients: [{ key: "okhttp", label: "OkHttp", build: kotlinOkHttp2 }] },
+  {
+    key: "csharp",
+    label: "C#",
+    highlight: "csharp",
+    clients: [
+      { key: "httpclient", label: "HttpClient", build: csharpHttpClient2 },
+      { key: "restsharp", label: "RestSharp", build: restSharp2 }
+    ]
+  },
+  { key: "ruby", label: "Ruby", highlight: "ruby", clients: [{ key: "native", label: "net/http", build: ruby2 }] },
+  { key: "swift", label: "Swift", highlight: "swift", clients: [{ key: "urlsession", label: "URLSession", build: swift2 }] },
+  { key: "dart", label: "Dart", highlight: "dart", clients: [{ key: "http", label: "http", build: dart2 }] },
+  { key: "rust", label: "Rust", highlight: "rust", clients: [{ key: "reqwest", label: "reqwest", build: rust2 }] },
+  { key: "c", label: "C", highlight: "c", clients: [{ key: "libcurl", label: "libcurl", build: libcurl2 }] },
+  {
+    key: "powershell",
+    label: "PowerShell",
+    highlight: "powershell",
+    clients: [{ key: "restmethod", label: "Invoke-RestMethod", build: powershell2 }]
+  },
+  { key: "http", label: "HTTP", highlight: "http", clients: [{ key: "raw", label: "HTTP/1.1", build: rawHttp2 }] }
+];
+var SNIPPET_LANGUAGES = LANGUAGES.map((language) => ({
+  ...language,
+  clients: language.clients.map((client) => {
+    const multipart = MULTIPART_BUILDERS[`${language.key}:${client.key}`];
+    return { ...client, build: (request) => request.form && multipart ? multipart(request) : client.build(request) };
+  })
+}));
+function resolveSnippet(selection) {
+  const [languageKey, clientKey] = String(selection ?? "").split(":");
+  const language = SNIPPET_LANGUAGES.find((item) => item.key === languageKey) ?? SNIPPET_LANGUAGES[0];
+  const client = language.clients.find((item) => item.key === clientKey) ?? language.clients[0];
+  return { language, client, selection: `${language.key}:${client.key}` };
+}
+
+// src/i18n.ts
+function localize(node, field, locale) {
+  const translations = node?.["x-i18n"];
+  if (translations && locale) {
+    const target = String(locale).toLowerCase();
+    const base = target.split("-")[0];
+    for (const [tag, values] of Object.entries(translations)) {
+      const normalized = tag.toLowerCase().replace("_", "-");
+      if ((normalized === target || normalized === base) && typeof values?.[field] === "string") return values[field];
+    }
+  }
+  return node?.[field];
+}
+
+// src/markdown.ts
+var FENCE = /^ {0,3}(`{3,}|~{3,})\s*([^\s`]*)[^`]*$/;
+var LANG_OPEN = /^ {0,3}:{3,}[ \t]*lang[ \t]+([A-Za-z]{2,3}(?:[-_][A-Za-z0-9]+)*(?:[ \t]*,[ \t]*[A-Za-z]{2,3}(?:[-_][A-Za-z0-9]+)*)*)[ \t]*$/;
+var CONTAINER_OPEN = /^ {0,3}:{3,}[ \t]*\S/;
+var CONTAINER_CLOSE = /^ {0,3}:{3,}[ \t]*$/;
+var HEADING = /^ {0,3}(#{1,6})(?:[ \t]+(.*?))?(?:[ \t]+#+)?[ \t]*$/;
+var THEMATIC_BREAK = /^ {0,3}([-*_])(?:[ \t]*\1){2,}[ \t]*$/;
+var BLOCKQUOTE = /^ {0,3}> ?/;
+var LIST_ITEM = /^( *)([-*+]|\d{1,9}[.)])([ \t]+|$)(.*)$/;
+var TABLE_DELIMITER = /^ {0,3}\|?[ \t]*:?-+:?[ \t]*(\|[ \t]*:?-+:?[ \t]*)*\|?[ \t]*$/;
+var isBlank = (line) => line.trim() === "";
+var indentOf = (line) => line.match(/^ */)[0].length;
+var expandTabs = (line) => line.replace(/\t/g, "    ");
+function splitRow(line) {
+  let row = line.trim();
+  if (row.startsWith("|")) row = row.slice(1);
+  if (row.endsWith("|") && !row.endsWith("\\|")) row = row.slice(0, -1);
+  const cells = [];
+  let current = "";
+  let inCode = false;
+  for (let index = 0; index < row.length; index += 1) {
+    const char = row[index];
+    if (char === "\\" && row[index + 1] === "|") {
+      current += "|";
+      index += 1;
+    } else if (char === "`") {
+      inCode = !inCode;
+      current += char;
+    } else if (char === "|" && !inCode) {
+      cells.push(current.trim());
+      current = "";
+    } else {
+      current += char;
+    }
+  }
+  cells.push(current.trim());
+  return cells;
+}
+function isTableStart(lines, index) {
+  return index + 1 < lines.length && lines[index].includes("|") && TABLE_DELIMITER.test(lines[index + 1]) && splitRow(lines[index]).length === splitRow(lines[index + 1]).length;
+}
+function parseTable(lines, index) {
+  const header = splitRow(lines[index]);
+  const align = splitRow(lines[index + 1]).map((cell) => {
+    const left = cell.startsWith(":");
+    const right = cell.endsWith(":");
+    return left && right ? "center" : right ? "right" : left ? "left" : null;
+  });
+  const rows = [];
+  let next = index + 2;
+  while (next < lines.length && !isBlank(lines[next]) && lines[next].includes("|")) {
+    const cells = splitRow(lines[next]);
+    rows.push(header.map((_, column) => parseInline(cells[column] ?? "")));
+    next += 1;
+  }
+  return {
+    block: { type: "table", align, header: header.map((cell) => parseInline(cell)), rows },
+    next
+  };
+}
+function listMarker(line) {
+  const match = LIST_ITEM.exec(line);
+  if (!match) return null;
+  const [, indent3, marker, spacing, rest] = match;
+  const ordered = /\d/.test(marker);
+  const gap = spacing.length === 0 || spacing.length > 4 ? 1 : spacing.length;
+  return {
+    indent: indent3.length,
+    ordered,
+    bullet: ordered ? marker.slice(-1) : marker,
+    start: ordered ? Number.parseInt(marker, 10) : null,
+    contentOffset: indent3.length + marker.length + gap,
+    firstLine: spacing.length > 4 ? `${" ".repeat(spacing.length - 1)}${rest}` : rest
+  };
+}
+function parseList(lines, index) {
+  const first = listMarker(lines[index]);
+  const items = [];
+  let loose = false;
+  let next = index;
+  while (next < lines.length) {
+    const marker = listMarker(lines[next]);
+    if (!marker || marker.ordered !== first.ordered || marker.bullet !== first.bullet || marker.indent >= first.contentOffset) break;
+    const content = [marker.firstLine];
+    next += 1;
+    let sawBlank = false;
+    while (next < lines.length) {
+      const line = lines[next];
+      if (isBlank(line)) {
+        sawBlank = true;
+        content.push("");
+        next += 1;
+        continue;
+      }
+      if (indentOf(line) >= marker.contentOffset) {
+        content.push(line.slice(marker.contentOffset));
+        next += 1;
+        continue;
+      }
+      if (!sawBlank && !listMarker(line) && !startsBlock(lines, next)) {
+        content.push(line.trim());
+        next += 1;
+        continue;
+      }
+      break;
+    }
+    while (content.length && isBlank(content[content.length - 1])) content.pop();
+    if (sawBlank && next < lines.length && listMarker(lines[next])?.bullet === first.bullet) loose = true;
+    if (content.some((line, lineIndex) => isBlank(line) && lineIndex < content.length - 1)) loose = true;
+    let checked = null;
+    const task = /^\[([ xX])\][ \t]+/.exec(content[0]);
+    if (task) {
+      checked = task[1] !== " ";
+      content[0] = content[0].slice(task[0].length);
+    }
+    items.push({ checked, children: parseBlocks(content) });
+    if (sawBlank && !(next < lines.length && listMarker(lines[next]))) break;
+  }
+  return {
+    block: { type: "list", ordered: first.ordered, start: first.start, loose, items },
+    next
+  };
+}
+function startsBlock(lines, index) {
+  const line = lines[index];
+  return FENCE.test(line) || LANG_OPEN.test(line) || HEADING.test(line) || THEMATIC_BREAK.test(line) || BLOCKQUOTE.test(line) || isTableStart(lines, index);
+}
+function interruptsParagraph(lines, index) {
+  if (startsBlock(lines, index)) return true;
+  const marker = listMarker(lines[index]);
+  return Boolean(marker && marker.firstLine.trim() && (!marker.ordered || marker.start === 1));
+}
+function parseBlocks(lines) {
+  const blocks = [];
+  let index = 0;
+  while (index < lines.length) {
+    const line = lines[index];
+    if (isBlank(line)) {
+      index += 1;
+      continue;
+    }
+    const fence = FENCE.exec(line);
+    if (fence) {
+      const [, marker, language] = fence;
+      const indent3 = indentOf(line);
+      const code = [];
+      index += 1;
+      while (index < lines.length) {
+        const closing = lines[index].trim();
+        if (closing.startsWith(marker[0].repeat(marker.length)) && /^[`~]+$/.test(closing)) break;
+        code.push(lines[index].slice(Math.min(indent3, indentOf(lines[index]))));
+        index += 1;
+      }
+      index += 1;
+      blocks.push({ type: "code", language: language.toLowerCase(), text: code.join("\n") });
+      continue;
+    }
+    const lang = LANG_OPEN.exec(line);
+    if (lang) {
+      const inner = [];
+      let depth = 1;
+      index += 1;
+      let inFence = null;
+      while (index < lines.length) {
+        const current = lines[index];
+        const fence2 = FENCE.exec(current);
+        if (fence2 && (!inFence || current.trim().startsWith(inFence))) inFence = inFence ? null : fence2[1];
+        if (!inFence) {
+          if (CONTAINER_OPEN.test(current)) depth += 1;
+          else if (CONTAINER_CLOSE.test(current) && --depth === 0) break;
+        }
+        inner.push(current);
+        index += 1;
+      }
+      index += 1;
+      blocks.push({
+        type: "lang",
+        locales: lang[1].split(",").map((item) => normalizeTag(item)),
+        children: parseBlocks(inner)
+      });
+      continue;
+    }
+    const heading = HEADING.exec(line);
+    if (heading) {
+      blocks.push({ type: "heading", level: heading[1].length, children: parseInline(heading[2] ?? "") });
+      index += 1;
+      continue;
+    }
+    if (THEMATIC_BREAK.test(line)) {
+      blocks.push({ type: "hr" });
+      index += 1;
+      continue;
+    }
+    if (BLOCKQUOTE.test(line)) {
+      const quoted = [];
+      while (index < lines.length && !isBlank(lines[index])) {
+        quoted.push(lines[index].replace(BLOCKQUOTE, ""));
+        index += 1;
+      }
+      blocks.push({ type: "blockquote", children: parseBlocks(quoted) });
+      continue;
+    }
+    if (isTableStart(lines, index)) {
+      const { block, next } = parseTable(lines, index);
+      blocks.push(block);
+      index = next;
+      continue;
+    }
+    if (listMarker(line)) {
+      const { block, next } = parseList(lines, index);
+      blocks.push(block);
+      index = next;
+      continue;
+    }
+    const paragraph = [line.trim()];
+    index += 1;
+    while (index < lines.length && !isBlank(lines[index]) && !interruptsParagraph(lines, index)) {
+      paragraph.push(lines[index].trim());
+      index += 1;
+    }
+    const raw = paragraph.map((text, lineIndex) => {
+      const original = lines[index - paragraph.length + lineIndex];
+      return / {2,}$/.test(original) ? `${text}  ` : text;
+    });
+    blocks.push({ type: "paragraph", children: parseInline(raw.join("\n")) });
+  }
+  return blocks;
+}
+var PUNCTUATION = /[!"#$%&'()*+,\-./:;<=>?@[\\\]^_`{|}~]/;
+var BARE_URL = /^https?:\/\/[^\s<]*[^\s<.,:;"')\]!?*_~]/;
+var AUTOLINK = /^<((?:https?:\/\/|mailto:)[^\s<>]+)>/;
+function closingBracket(text, start) {
+  let depth = 0;
+  for (let index = start; index < text.length; index += 1) {
+    const char = text[index];
+    if (char === "\\") index += 1;
+    else if (char === "`") {
+      const end = text.indexOf("`", index + 1);
+      if (end !== -1) index = end;
+    } else if (char === "[") depth += 1;
+    else if (char === "]" && --depth === 0) return index;
+  }
+  return -1;
+}
+function linkTarget2(text, start) {
+  if (text[start] !== "(") return null;
+  let index = start + 1;
+  while (text[index] === " ") index += 1;
+  let href = "";
+  if (text[index] === "<") {
+    const end = text.indexOf(">", index);
+    if (end === -1) return null;
+    href = text.slice(index + 1, end);
+    index = end + 1;
+  } else {
+    let depth = 0;
+    while (index < text.length) {
+      const char = text[index];
+      if (char === "\\" && PUNCTUATION.test(text[index + 1] ?? "")) {
+        href += text[index + 1];
+        index += 2;
+        continue;
+      }
+      if (/\s/.test(char)) break;
+      if (char === "(") depth += 1;
+      if (char === ")") {
+        if (depth === 0) break;
+        depth -= 1;
+      }
+      href += char;
+      index += 1;
+    }
+  }
+  while (text[index] === " ") index += 1;
+  let title;
+  const quote = text[index];
+  if (quote === '"' || quote === "'") {
+    const end = text.indexOf(quote, index + 1);
+    if (end === -1) return null;
+    title = text.slice(index + 1, end);
+    index = end + 1;
+    while (text[index] === " ") index += 1;
+  }
+  return text[index] === ")" ? { href, title, end: index + 1 } : null;
+}
+function closingDelimiter(text, delimiter, from) {
+  let index = from;
+  while ((index = text.indexOf(delimiter, index)) !== -1) {
+    const before = text[index - 1];
+    const after = text[index + delimiter.length];
+    const doubled = delimiter.length === 1 && (after === delimiter || before === delimiter);
+    const escaped = before === "\\";
+    const intraword = delimiter[0] === "_" && /\w/.test(after ?? "");
+    if (index > from && !/\s/.test(before) && !doubled && !escaped && !intraword) return index;
+    index += doubled ? 2 : 1;
+  }
+  return -1;
+}
+function pushText(nodes, value) {
+  const last = nodes[nodes.length - 1];
+  if (last?.type === "text") last.value += value;
+  else nodes.push({ type: "text", value });
+}
+function parseInline(text, { links = true } = {}) {
+  const nodes = [];
+  let index = 0;
+  while (index < text.length) {
+    const char = text[index];
+    const rest = text.slice(index);
+    if (char === "\\" && PUNCTUATION.test(text[index + 1] ?? "")) {
+      pushText(nodes, text[index + 1]);
+      index += 2;
+      continue;
+    }
+    if (char === "\n") {
+      const hard = /( {2,}|\\)$/.test(text.slice(0, index));
+      if (hard && nodes[nodes.length - 1]?.type === "text") {
+        const last = nodes[nodes.length - 1];
+        last.value = last.value.replace(/( {2,}|\\)$/, "");
+      }
+      if (hard) nodes.push({ type: "br" });
+      else pushText(nodes, " ");
+      index += 1;
+      continue;
+    }
+    if (char === "`") {
+      const run = /^`+/.exec(rest)[0];
+      const closing = new RegExp(`(?<!\`)${run}(?!\`)`, "g");
+      closing.lastIndex = index + run.length;
+      const match = closing.exec(text);
+      if (match) {
+        let value = text.slice(index + run.length, match.index).replace(/\n/g, " ");
+        if (/^ .* $/.test(value) && value.trim()) value = value.slice(1, -1);
+        nodes.push({ type: "code", value });
+        index = match.index + run.length;
+      } else {
+        pushText(nodes, run);
+        index += run.length;
+      }
+      continue;
+    }
+    if (links && char === "[" || char === "!" && text[index + 1] === "[") {
+      const image = char === "!";
+      const open = image ? index + 1 : index;
+      const close = closingBracket(text, open);
+      const target = close !== -1 ? linkTarget2(text, close + 1) : null;
+      if (target) {
+        const label = text.slice(open + 1, close);
+        nodes.push(
+          image ? { type: "image", src: target.href, alt: label, title: target.title } : { type: "link", href: target.href, title: target.title, children: parseInline(label, { links: false }) }
+        );
+        index = target.end;
+        continue;
+      }
+    }
+    const autolink = links && char === "<" ? AUTOLINK.exec(rest) : null;
+    if (autolink) {
+      nodes.push({ type: "link", href: autolink[1], children: [{ type: "text", value: autolink[1].replace(/^mailto:/, "") }] });
+      index += autolink[0].length;
+      continue;
+    }
+    if (links && char === "h" && !/\w/.test(text[index - 1] ?? "")) {
+      const url = BARE_URL.exec(rest);
+      if (url) {
+        nodes.push({ type: "link", href: url[0], children: [{ type: "text", value: url[0] }] });
+        index += url[0].length;
+        continue;
+      }
+    }
+    const delimiter = ["**", "__", "~~"].find((item) => rest.startsWith(item)) ?? (char === "*" || char === "_" ? char : null);
+    const leftFlanking = delimiter && rest[delimiter.length] && !/\s/.test(rest[delimiter.length]);
+    const wordBefore = /\w/.test(text[index - 1] ?? "");
+    if (delimiter && leftFlanking && !(delimiter[0] === "_" && wordBefore)) {
+      const end = closingDelimiter(text, delimiter, index + delimiter.length);
+      if (end !== -1) {
+        const type = delimiter === "~~" ? "del" : delimiter.length === 2 ? "strong" : "em";
+        nodes.push({ type, children: parseInline(text.slice(index + delimiter.length, end), { links }) });
+        index = end + delimiter.length;
+        continue;
+      }
+    }
+    pushText(nodes, delimiter && !leftFlanking ? delimiter : char);
+    index += delimiter && !leftFlanking ? delimiter.length : 1;
+  }
+  return nodes;
+}
+function normalizeTag(tag) {
+  return tag.trim().replace("_", "-").toLowerCase();
+}
+function matches(tag, locale) {
+  return tag === locale || tag.split("-")[0] === locale.split("-")[0];
+}
+function selectLocale(blocks, locale, fallbacks = ["en"]) {
+  const result = [];
+  let index = 0;
+  while (index < blocks.length) {
+    const block = blocks[index];
+    if (block.type !== "lang") {
+      result.push(block);
+      index += 1;
+      continue;
+    }
+    const group = [];
+    while (index < blocks.length && blocks[index].type === "lang") group.push(blocks[index++]);
+    const target = normalizeTag(locale);
+    const chosen = group.find((item) => item.locales.some((tag) => tag === target)) ?? group.find((item) => item.locales.some((tag) => matches(tag, target))) ?? fallbacks.map((fallback) => group.find((item) => item.locales.some((tag) => matches(tag, normalizeTag(fallback))))).find(Boolean) ?? group[0];
+    result.push({
+      type: "lang-selected",
+      locale: chosen.locales.find((tag) => matches(tag, target)) ?? chosen.locales[0],
+      children: selectLocale(chosen.children, locale, fallbacks)
+    });
+  }
+  return result;
+}
+function parseMarkdown(source) {
+  if (!source) return [];
+  return parseBlocks(expandTabs(String(source).replace(/\r\n?/g, "\n")).split("\n"));
+}
+function safeUrl(url, { image = false } = {}) {
+  const value = String(url ?? "").trim();
+  if (/^(https?:|\/(?!\/)|#|\.{1,2}\/)/i.test(value)) return value;
+  if (!image && /^mailto:/i.test(value)) return value;
+  if (!/^[a-z][a-z0-9+.-]*:/i.test(value) && !value.startsWith("//")) return value;
+  return null;
+}
+
+// src/highlight.ts
+var STRING_DOUBLE = /"(?:\\.|[^"\\\n])*"/y;
+var STRING_SINGLE = /'(?:\\.|[^'\\])*'/y;
+var NUMBER = /-?\b\d+(?:\.\d+)?(?:[eE][+-]?\d+)?\b/y;
+var words = (list) => new RegExp(`\\b(?:${list.join("|")})\\b`, "y");
+var LANGUAGES2 = {
+  json: [
+    ["key", /"(?:\\.|[^"\\\n])*"(?=\s*:)/y],
+    ["string", STRING_DOUBLE],
+    ["number", NUMBER],
+    ["literal", words(["true", "false", "null"])]
+  ],
+  shell: [
+    ["comment", /#[^\n]*/y],
+    // No escapes inside single quotes in shell; '\'' closes the string, adds
+    // an escaped quote and reopens, so the backslash escape is its own token.
+    ["string", /\\./y],
+    ["string", /'[^']*'/y],
+    ["string", STRING_DOUBLE],
+    ["keyword", /(?<![\w-])(?:curl|wget|http|printf)\b/y],
+    ["attr", /(?<![\w-])--?[a-zA-Z][\w-]*/y],
+    ["variable", /\$\{?\w+\}?/y]
+  ],
+  javascript: [
+    ["comment", /\/\/[^\n]*|\/\*[\s\S]*?\*\//y],
+    ["string", /`(?:\\.|[^`\\])*`/y],
+    ["key", /"(?:\\.|[^"\\\n])*"(?=\s*:)/y],
+    ["string", STRING_DOUBLE],
+    ["string", STRING_SINGLE],
+    ["key", /\b[A-Za-z_$][\w$]*(?=\s*:(?!:))/y],
+    ["keyword", words(["const", "let", "var", "await", "async", "function", "return", "new", "if", "else", "import", "from", "export"])],
+    ["literal", words(["true", "false", "null", "undefined"])],
+    ["function", /\b[A-Za-z_$][\w$]*(?=\s*\()/y],
+    ["number", NUMBER]
+  ],
+  php: [
+    ["comment", /\/\/[^\n]*|#[^\n]*|\/\*[\s\S]*?\*\//y],
+    ["keyword", /<\?php|\?>/y],
+    ["string", STRING_DOUBLE],
+    ["string", STRING_SINGLE],
+    ["variable", /\$\w+/y],
+    ["constant", /\b[A-Z][A-Z0-9_]{2,}\b/y],
+    ["keyword", words(["echo", "return", "new", "function", "if", "else", "use", "array"])],
+    ["literal", words(["true", "false", "null"])],
+    ["function", /\b[A-Za-z_]\w*(?=\s*\()/y],
+    ["number", NUMBER]
+  ],
+  python: [
+    ["comment", /#[^\n]*/y],
+    ["string", STRING_DOUBLE],
+    ["string", STRING_SINGLE],
+    ["keyword", words(["import", "from", "as", "def", "return", "if", "else", "for", "in", "print", "with"])],
+    ["literal", words(["True", "False", "None"])],
+    ["attr", /\b[a-z_]\w*(?==)/y],
+    ["function", /\b[A-Za-z_]\w*(?=\s*\()/y],
+    ["number", NUMBER]
+  ]
+};
+var C_COMMENT = /\/\/[^\n]*|\/\*[\s\S]*?\*\//y;
+var TRIPLE_DOUBLE = /"""[\s\S]*?"""/y;
+var TYPE = /\b[A-Z][a-z]\w*\b/y;
+var CALL = /\b[A-Za-z_]\w*(?=\s*\()/y;
+function cFamily({
+  keywords,
+  literals = ["true", "false", "null"],
+  strings = [],
+  extra = []
+}) {
+  return [
+    ["comment", C_COMMENT],
+    ...strings.map((regex) => ["string", regex]),
+    ["string", STRING_DOUBLE],
+    ["string", STRING_SINGLE],
+    ...extra,
+    ["keyword", words(keywords)],
+    ["literal", words(literals)],
+    ["function", CALL],
+    ["type", TYPE],
+    ["number", NUMBER]
+  ];
+}
+Object.assign(LANGUAGES2, {
+  go: cFamily({
+    keywords: ["package", "import", "func", "var", "const", "if", "else", "return", "defer", "for", "range", "type", "struct", "go", "map", "chan"],
+    literals: ["true", "false", "nil"],
+    strings: [/`[^`]*`/y]
+  }),
+  java: cFamily({
+    keywords: ["import", "package", "new", "public", "private", "class", "static", "void", "final", "var", "return", "throws", "try", "catch"],
+    strings: [TRIPLE_DOUBLE]
+  }),
+  kotlin: cFamily({
+    keywords: ["import", "val", "var", "fun", "return", "if", "else", "class", "object"],
+    strings: [TRIPLE_DOUBLE]
+  }),
+  csharp: cFamily({
+    keywords: ["using", "var", "new", "await", "async", "return", "public", "class", "static", "void"],
+    strings: [TRIPLE_DOUBLE]
+  }),
+  swift: cFamily({
+    keywords: ["import", "let", "var", "try", "await", "func", "return", "if", "else"],
+    literals: ["true", "false", "nil"],
+    strings: [TRIPLE_DOUBLE]
+  }),
+  dart: cFamily({
+    keywords: ["import", "as", "final", "var", "void", "async", "await", "return"],
+    strings: [/r?'''[\s\S]*?'''/y]
+  }),
+  rust: cFamily({
+    keywords: ["use", "let", "mut", "fn", "async", "await", "pub", "struct", "impl", "match", "return"],
+    strings: [/r(#+)"[\s\S]*?"\1/y],
+    extra: [
+      ["attr", /#\[[^\]]*\]/y],
+      ["function", /\b[a-z_]\w*!/y]
+    ]
+  }),
+  c: cFamily({
+    keywords: ["int", "char", "void", "struct", "return", "if", "else", "const", "static"],
+    literals: ["NULL"],
+    extra: [
+      ["keyword", /#\w+(?:\s+<[^>\n]*>)?/y],
+      ["constant", /\b[A-Z][A-Z0-9_]{2,}\b/y]
+    ]
+  }),
+  ruby: [
+    ["comment", /#[^\n]*/y],
+    ["string", STRING_DOUBLE],
+    ["string", STRING_SINGLE],
+    ["literal", /:\w+/y],
+    ["keyword", words(["require", "def", "end", "do", "if", "else", "puts", "return", "new"])],
+    ["literal", words(["true", "false", "nil"])],
+    ["type", TYPE],
+    ["number", NUMBER]
+  ],
+  powershell: [
+    ["comment", /#[^\n]*/y],
+    ["string", /@'[\s\S]*?'@|@"[\s\S]*?"@/y],
+    ["string", /'(?:''|[^'])*'/y],
+    ["string", STRING_DOUBLE],
+    ["literal", /\$(?:true|false|null)\b/y],
+    ["variable", /\$\w+/y],
+    ["function", /\b[A-Z][a-z]+-[A-Z][A-Za-z]+\b/y],
+    ["attr", /(?<![\w-])-[A-Za-z]+/y],
+    ["number", NUMBER]
+  ],
+  // Request line, header names, then JSON-ish body tokens.
+  http: [
+    ["keyword", /^[A-Z]+(?= \S+ HTTP\/)/my],
+    ["attr", /HTTP\/\d(?:\.\d)?/y],
+    ["key", /^[\w-]+(?=:)/my],
+    ["key", /"(?:\\.|[^"\\\n])*"(?=\s*:)/y],
+    ["string", STRING_DOUBLE],
+    ["literal", words(["true", "false", "null"])],
+    ["number", NUMBER]
+  ]
+});
+LANGUAGES2.curl = LANGUAGES2.shell;
+function tokenize(code, language) {
+  const rules = LANGUAGES2[language];
+  if (!rules) return [{ type: null, text: code }];
+  const tokens = [];
+  let plain = "";
+  let index = 0;
+  outer: while (index < code.length) {
+    for (const [type, regex] of rules) {
+      regex.lastIndex = index;
+      const match = regex.exec(code);
+      if (match && match[0].length > 0) {
+        if (plain) {
+          tokens.push({ type: null, text: plain });
+          plain = "";
+        }
+        tokens.push({ type, text: match[0] });
+        index += match[0].length;
+        continue outer;
+      }
+    }
+    const word = /[\w$]+|[^\w$]/y;
+    word.lastIndex = index;
+    const chunk = word.exec(code)[0];
+    plain += chunk;
+    index += chunk.length;
+  }
+  if (plain) tokens.push({ type: null, text: plain });
+  return tokens;
+}
+
+// src/security.ts
+function securityRequirements(operation) {
+  return (operation.security ?? []).map((requirement) => ({
+    schemes: Object.keys(requirement),
+    scopes: requirement
+  }));
+}
+function base64(text) {
+  let binary = "";
+  for (const byte of new TextEncoder().encode(text)) binary += String.fromCharCode(byte);
+  return btoa(binary);
+}
+function hasCredential(scheme, credential) {
+  if (!scheme || !credential) return false;
+  if (scheme.type === "http" && String(scheme.scheme).toLowerCase() === "basic") return Boolean(credential.username || credential.password);
+  return Boolean(credential.token);
+}
+function applyScheme(parts, scheme, credential) {
+  if (scheme.type === "http") {
+    const kind = String(scheme.scheme ?? "").toLowerCase();
+    if (kind === "basic") parts.headers.Authorization = `Basic ${base64(`${credential.username ?? ""}:${credential.password ?? ""}`)}`;
+    else if (kind === "bearer") parts.headers.Authorization = `Bearer ${credential.token}`;
+    else parts.headers.Authorization = `${scheme.scheme} ${credential.token}`;
+  } else if (scheme.type === "apiKey") {
+    const target = scheme.in === "query" ? parts.query : scheme.in === "cookie" ? parts.cookies : parts.headers;
+    target[scheme.name] = credential.token ?? "";
+  } else if (scheme.type === "oauth2" || scheme.type === "openIdConnect") {
+    parts.headers.Authorization = `Bearer ${credential.token}`;
+  }
+}
+function applySecurity(schemes, requirements, credentials) {
+  const parts = { headers: {}, query: {}, cookies: {} };
+  const usable = requirements.find(
+    (requirement) => requirement.schemes.length > 0 && requirement.schemes.every((name) => hasCredential(schemes[name], credentials[name]))
+  );
+  for (const name of usable?.schemes ?? []) applyScheme(parts, schemes[name], credentials[name]);
+  return parts;
+}
+function describeScheme(scheme) {
+  if (scheme.type === "http") {
+    const kind = String(scheme.scheme ?? "");
+    return kind.toLowerCase() === "bearer" ? `Bearer${scheme.bearerFormat ? ` (${scheme.bearerFormat})` : ""}` : `HTTP ${kind}`;
+  }
+  if (scheme.type === "apiKey") return `API key (${scheme.in}: ${scheme.name})`;
+  if (scheme.type === "oauth2") return `OAuth 2.0 (${Object.keys(scheme.flows ?? {}).join(", ")})`;
+  if (scheme.type === "openIdConnect") return "OpenID Connect";
+  if (scheme.type === "mutualTLS") return "Mutual TLS";
+  return String(scheme.type ?? "");
+}
+var TOKEN_FLOWS = ["clientCredentials", "password"];
+function buildTokenRequest(flowName, flow, credential) {
+  const params = new URLSearchParams({ grant_type: flowName === "password" ? "password" : "client_credentials" });
+  if (flowName === "password") {
+    params.set("username", credential.username ?? "");
+    params.set("password", credential.password ?? "");
+  }
+  if (credential.scopes?.trim()) params.set("scope", credential.scopes.trim());
+  const headers = { "Content-Type": "application/x-www-form-urlencoded", Accept: "application/json" };
+  if (credential.clientId) headers.Authorization = `Basic ${base64(`${credential.clientId}:${credential.clientSecret ?? ""}`)}`;
+  return { method: "POST", url: String(flow.tokenUrl ?? ""), headers, body: params.toString() };
+}
+
+// src/convert.ts
+var REF_PREFIXES = [
+  ["#/definitions/", "#/components/schemas/"],
+  ["#/responses/", "#/components/responses/"]
+];
+var SCHEMA_KEYS = [
+  "format",
+  "items",
+  "enum",
+  "default",
+  "minimum",
+  "maximum",
+  "exclusiveMinimum",
+  "exclusiveMaximum",
+  "minLength",
+  "maxLength",
+  "pattern",
+  "minItems",
+  "maxItems",
+  "uniqueItems",
+  "multipleOf"
+];
+var FORM_TYPES = ["application/x-www-form-urlencoded", "multipart/form-data"];
+function convertRef(ref, bodyParameters) {
+  if (ref.startsWith("#/parameters/")) {
+    const name = ref.slice("#/parameters/".length);
+    return bodyParameters.has(name) ? `#/components/requestBodies/${name}` : `#/components/parameters/${name}`;
+  }
+  for (const [from, to] of REF_PREFIXES) if (ref.startsWith(from)) return to + ref.slice(from.length);
+  return ref;
+}
+function convertSchema(schema) {
+  if (!schema || typeof schema !== "object") return schema;
+  if (Array.isArray(schema)) return schema.map(convertSchema);
+  const result = {};
+  for (const [key, value] of Object.entries(schema)) {
+    switch (key) {
+      case "$ref":
+        result.$ref = convertRef(String(value), /* @__PURE__ */ new Set());
+        break;
+      case "x-nullable":
+        if (value) result.nullable = true;
+        break;
+      case "discriminator":
+        result.discriminator = typeof value === "string" ? { propertyName: value } : value;
+        break;
+      case "properties":
+      case "patternProperties":
+        result[key] = Object.fromEntries(Object.entries(value).map(([name, child]) => [name, convertSchema(child)]));
+        break;
+      case "items":
+      case "additionalProperties":
+      case "not":
+        result[key] = typeof value === "object" ? convertSchema(value) : value;
+        break;
+      case "allOf":
+      case "anyOf":
+      case "oneOf":
+        result[key] = value.map(convertSchema);
+        break;
+      default:
+        result[key] = value;
+    }
+  }
+  if (result.type === "file") {
+    result.type = "string";
+    result.format = "binary";
+  }
+  return result;
+}
+function convertParameter(parameter) {
+  const { type, collectionFormat, "x-example": example, allowEmptyValue, ...rest } = parameter;
+  const schema = type === "file" ? { type: "string", format: "binary" } : { type };
+  const result = {};
+  for (const [key, value] of Object.entries(rest)) {
+    if (SCHEMA_KEYS.includes(key)) schema[key] = key === "items" ? convertSchema(value) : value;
+    else result[key] = value;
+  }
+  result.schema = convertSchema(schema);
+  if (example !== void 0) result.example = example;
+  if (allowEmptyValue) result.allowEmptyValue = true;
+  if (type === "array") {
+    const format = collectionFormat ?? "csv";
+    if (format === "multi") Object.assign(result, { style: "form", explode: true });
+    else if (format === "ssv") Object.assign(result, { style: "spaceDelimited", explode: false });
+    else if (format === "pipes") Object.assign(result, { style: "pipeDelimited", explode: false });
+    else Object.assign(result, { style: parameter.in === "query" || parameter.in === "cookie" ? "form" : "simple", explode: false });
+  }
+  return result;
+}
+function bodyContent(schema, types, description, required) {
+  const body = { content: Object.fromEntries(types.map((type) => [type, { schema: convertSchema(schema) }])) };
+  if (description) body.description = description;
+  if (required) body.required = true;
+  return body;
+}
+function formBody(parameters, consumes) {
+  const types = consumes.filter((type) => FORM_TYPES.includes(type));
+  const hasFile = parameters.some((parameter) => parameter.type === "file");
+  const contentTypes = types.length ? types : [hasFile ? "multipart/form-data" : "application/x-www-form-urlencoded"];
+  const schema = { type: "object", properties: {} };
+  const required = [];
+  for (const parameter of parameters) {
+    const { schema: propertySchema } = convertParameter({ ...parameter, in: "query" });
+    if (parameter.description) propertySchema.description = parameter.description;
+    schema.properties[parameter.name] = propertySchema;
+    if (parameter.required) required.push(parameter.name);
+  }
+  if (required.length) schema.required = required;
+  return { content: Object.fromEntries(contentTypes.map((type) => [type, { schema }])) };
+}
+function convertResponse(response, produces) {
+  if (response.$ref) return { $ref: convertRef(response.$ref, /* @__PURE__ */ new Set()) };
+  const { schema, examples, headers, ...rest } = response;
+  const result = { ...rest, description: rest.description ?? "" };
+  if (headers) {
+    result.headers = Object.fromEntries(
+      Object.entries(headers).map(([name, header]) => {
+        const { schema: headerSchema, description } = convertParameter({ ...header, in: "header" });
+        return [name, { ...description ? { description } : {}, schema: headerSchema }];
+      })
+    );
+  }
+  if (schema) {
+    const types = produces.length ? produces : ["application/json"];
+    result.content = Object.fromEntries(
+      types.map((type) => [type, { schema: convertSchema(schema), ...examples?.[type] !== void 0 ? { example: examples[type] } : {} }])
+    );
+  }
+  return result;
+}
+function convertSecurityScheme(scheme) {
+  const description = scheme.description ? { description: scheme.description } : {};
+  if (scheme.type === "basic") return { type: "http", scheme: "basic", ...description };
+  if (scheme.type === "apiKey") return { type: "apiKey", name: scheme.name, in: scheme.in, ...description };
+  if (scheme.type === "oauth2") {
+    const scopes = scheme.scopes ?? {};
+    const flow = {
+      implicit: { implicit: { authorizationUrl: scheme.authorizationUrl, scopes } },
+      password: { password: { tokenUrl: scheme.tokenUrl, scopes } },
+      application: { clientCredentials: { tokenUrl: scheme.tokenUrl, scopes } },
+      accessCode: { authorizationCode: { authorizationUrl: scheme.authorizationUrl, tokenUrl: scheme.tokenUrl, scopes } }
+    }[scheme.flow] ?? {};
+    return { type: "oauth2", flows: flow, ...description };
+  }
+  return { ...scheme };
+}
+var resolveParameter = (doc, parameter) => parameter.$ref?.startsWith("#/parameters/") ? doc.parameters?.[parameter.$ref.slice("#/parameters/".length)] ?? parameter : parameter;
+function convertSwagger2(doc) {
+  const bodyParameters = new Set(
+    Object.entries(doc.parameters ?? {}).filter(([, parameter]) => parameter.in === "body").map(([name]) => name)
+  );
+  const globalConsumes = doc.consumes ?? ["application/json"];
+  const globalProduces = doc.produces ?? ["application/json"];
+  const schemes = doc.schemes?.length ? doc.schemes : ["https"];
+  const servers = doc.host ? schemes.map((scheme) => ({ url: `${scheme}://${doc.host}${doc.basePath ?? ""}` })) : [{ url: doc.basePath ?? "/" }];
+  const components = {};
+  if (doc.definitions) {
+    components.schemas = Object.fromEntries(Object.entries(doc.definitions).map(([name, schema]) => [name, convertSchema(schema)]));
+  }
+  if (doc.parameters) {
+    for (const [name, parameter] of Object.entries(doc.parameters)) {
+      if (parameter.in === "body") {
+        (components.requestBodies ??= {})[name] = bodyContent(parameter.schema, globalConsumes, parameter.description, parameter.required);
+      } else if (parameter.in !== "formData") {
+        (components.parameters ??= {})[name] = convertParameter(parameter);
+      }
+    }
+  }
+  if (doc.responses) {
+    components.responses = Object.fromEntries(
+      Object.entries(doc.responses).map(([name, response]) => [name, convertResponse(response, globalProduces)])
+    );
+  }
+  if (doc.securityDefinitions) {
+    components.securitySchemes = Object.fromEntries(
+      Object.entries(doc.securityDefinitions).map(([name, scheme]) => [name, convertSecurityScheme(scheme)])
+    );
+  }
+  const paths = {};
+  for (const [path2, item] of Object.entries(doc.paths ?? {})) {
+    const pathParameters = item.parameters ?? [];
+    const pathItem = {};
+    for (const [key, value] of Object.entries(item)) {
+      if (key === "parameters" || typeof value !== "object" || !["get", "put", "post", "delete", "options", "head", "patch"].includes(key)) {
+        if (key !== "parameters") pathItem[key] = value;
+        continue;
+      }
+      const operation = value;
+      const { parameters = [], consumes, produces, responses = {}, ...rest } = operation;
+      const opConsumes = consumes ?? globalConsumes;
+      const opProduces = produces ?? globalProduces;
+      const converted = { ...rest };
+      const merged = /* @__PURE__ */ new Map();
+      for (const raw of [...pathParameters, ...parameters]) {
+        const resolved = resolveParameter(doc, raw);
+        merged.set(`${resolved.in}:${resolved.name}`, raw);
+      }
+      const formData2 = [];
+      const outParameters = [];
+      for (const raw of merged.values()) {
+        const resolved = resolveParameter(doc, raw);
+        if (resolved.in === "body") {
+          converted.requestBody = raw.$ref ? { $ref: convertRef(raw.$ref, bodyParameters) } : bodyContent(resolved.schema, opConsumes.filter((type) => !FORM_TYPES.includes(type)).length ? opConsumes.filter((type) => !FORM_TYPES.includes(type)) : ["application/json"], resolved.description, resolved.required);
+        } else if (resolved.in === "formData") {
+          formData2.push(resolved);
+        } else {
+          outParameters.push(raw.$ref ? { $ref: convertRef(raw.$ref, bodyParameters) } : convertParameter(raw));
+        }
+      }
+      if (formData2.length) converted.requestBody = formBody(formData2, opConsumes);
+      if (outParameters.length) converted.parameters = outParameters;
+      converted.responses = Object.fromEntries(
+        Object.entries(responses).map(([status, response]) => [status, convertResponse(response, opProduces)])
+      );
+      pathItem[key] = converted;
+    }
+    paths[path2] = pathItem;
+  }
+  const result = { openapi: "3.0.3", info: doc.info ?? { title: "API", version: "" }, servers, paths };
+  for (const key of ["tags", "security", "externalDocs"]) if (doc[key] !== void 0) result[key] = doc[key];
+  for (const [key, value] of Object.entries(doc)) if (key.startsWith("x-")) result[key] = value;
+  if (Object.keys(components).length) result.components = components;
+  return result;
+}
+
+// src/parse.ts
+import { parse as parseYaml } from "yaml";
+
+// src/external.ts
+var EXTERNAL_KEY = "x-oaspect-external";
+var isExternal = (ref) => !ref.startsWith("#");
+function hasExternalRefs(node) {
+  if (!node || typeof node !== "object") return false;
+  if (Array.isArray(node)) return node.some(hasExternalRefs);
+  const ref = node.$ref;
+  if (typeof ref === "string" && isExternal(ref)) return true;
+  return Object.values(node).some(hasExternalRefs);
+}
+async function resolveExternalRefs(doc, { baseUrl, read, maxDocuments = 100 }) {
+  if (!hasExternalRefs(doc)) return doc;
+  const documents = /* @__PURE__ */ new Map();
+  const hoisted = /* @__PURE__ */ new Map();
+  const store = {};
+  const usedKeys = /* @__PURE__ */ new Set();
+  function load(url) {
+    if (!documents.has(url)) {
+      if (documents.size >= maxDocuments) throw new Error(`More than ${maxDocuments} external documents referenced`);
+      documents.set(url, read(url).then((text) => parseSpec(text)));
+    }
+    return documents.get(url);
+  }
+  function keyFor(url, pointer) {
+    const segment = pointer.split("/").filter(Boolean).pop() ?? url.split("/").pop().replace(/\.(ya?ml|json)$/i, "");
+    const base = decodeURIComponent(segment.replace(/~1/g, "/").replace(/~0/g, "~")).replace(/[^\w.-]/g, "_") || "external";
+    let key = base;
+    for (let index = 2; usedKeys.has(key); index += 1) key = `${base}_${index}`;
+    usedKeys.add(key);
+    return key;
+  }
+  async function hoist(url, pointer) {
+    const id = `${url}#${pointer}`;
+    const existing = hoisted.get(id);
+    if (existing) return existing;
+    const key = keyFor(url, pointer);
+    hoisted.set(id, key);
+    const target = pointer ? resolvePointer(await load(url), `#${pointer}`) : await load(url);
+    if (target === void 0) throw new Error(`${id} not found`);
+    store[key] = await walk(target, url, false);
+    return key;
+  }
+  async function walk(node, base, isRoot) {
+    if (!node || typeof node !== "object") return node;
+    if (Array.isArray(node)) return Promise.all(node.map((item) => walk(item, base, isRoot)));
+    const object = node;
+    if (typeof object.$ref === "string" && (isExternal(object.$ref) || !isRoot)) {
+      const [file, pointer = ""] = object.$ref.split("#");
+      const url = file ? new URL(file, base).href : base;
+      const key = await hoist(url, pointer.startsWith("/") ? pointer : pointer ? `/${pointer}` : "");
+      const { $ref: _ref, ...siblings } = object;
+      return { ...await walk(siblings, base, isRoot), $ref: `#/components/${EXTERNAL_KEY}/${key}` };
+    }
+    const result = {};
+    for (const [key, value] of Object.entries(object)) result[key] = await walk(value, base, isRoot);
+    return result;
+  }
+  const resolved = await walk(doc, baseUrl, true);
+  resolved.components = { ...resolved.components, [EXTERNAL_KEY]: store };
+  return resolved;
+}
+
+// src/parse.ts
+function parseSpec(text) {
+  const trimmed = text.trimStart();
+  if (trimmed.startsWith("{") || trimmed.startsWith("[")) {
+    try {
+      return JSON.parse(text);
+    } catch (error) {
+      throw new Error(`Invalid JSON: ${error.message}`);
+    }
+  }
+  try {
+    return parseYaml(text, { maxAliasCount: 1e3 });
+  } catch (error) {
+    throw new Error(`Invalid YAML: ${error.message}`);
+  }
+}
+function isOpenApiDocument(value) {
+  const doc = value;
+  return Boolean(doc && typeof doc === "object" && (doc.openapi || doc.swagger) && doc.paths);
+}
+function normalizeSpec(doc) {
+  return String(doc.swagger ?? "").startsWith("2") ? convertSwagger2(doc) : doc;
+}
+function loadSpecText(text) {
+  const doc = parseSpec(text);
+  if (!isOpenApiDocument(doc)) throw new Error('Not an OpenAPI document (missing "openapi"/"swagger" or "paths").');
+  return normalizeSpec(doc);
+}
+async function loadSpec(text, options) {
+  const doc = loadSpecText(text);
+  if (!options?.read || !options.baseUrl) return doc;
+  return resolveExternalRefs(doc, options);
+}
+export {
+  EXTERNAL_KEY,
+  HTTP_METHODS,
+  SNIPPET_LANGUAGES,
+  TOKEN_FLOWS,
+  applySecurity,
+  buildModel,
+  buildRequest,
+  buildTokenRequest,
+  childrenOf,
+  constraintsOf,
+  convertSchema,
+  convertSwagger2,
+  defaultBody,
+  defaultForm,
+  defaultValues,
+  deref,
+  describeScheme,
+  exampleFromSchema,
+  formEncode,
+  hasCredential,
+  hasExternalRefs,
+  inferType,
+  isMultipart,
+  isOpenApiDocument,
+  jsonMediaType,
+  linkTarget,
+  loadSpec,
+  loadSpecText,
+  localize,
+  mediaExample,
+  mediaExamples,
+  modelAnchor,
+  normalizeSpec,
+  parameterExample,
+  parseBlocks,
+  parseInline,
+  parseMarkdown,
+  parseSpec,
+  refName,
+  resolveExternalRefs,
+  resolvePointer,
+  resolveSchema,
+  resolveSnippet,
+  safeUrl,
+  securityRequirements,
+  selectLocale,
+  serverUrl,
+  slugify,
+  tagAnchor,
+  tokenize,
+  typeLabel
+};
+//# sourceMappingURL=index.js.map