oapiex 0.1.0

package/dist/index.cjs

@@ -0,0 +1,1424 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+//#region \0rolldown/runtime.js
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") {
+		for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+			key = keys[i];
+			if (!__hasOwnProp.call(to, key) && key !== except) {
+				__defProp(to, key, {
+					get: ((k) => from[k]).bind(null, key),
+					enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+				});
+			}
+		}
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+
+//#endregion
+let jsdom = require("jsdom");
+let happy_dom = require("happy-dom");
+let axios = require("axios");
+axios = __toESM(axios);
+let _h3ravel_shared = require("@h3ravel/shared");
+let node_path = require("node:path");
+node_path = __toESM(node_path);
+let node_fs_promises = require("node:fs/promises");
+node_fs_promises = __toESM(node_fs_promises);
+let _h3ravel_musket = require("@h3ravel/musket");
+let url = require("url");
+let prettier = require("prettier");
+prettier = __toESM(prettier);
+let node_url = require("node:url");
+
+//#region src/Manager.ts
+const supportedBrowsers = [
+	"axios",
+	"happy-dom",
+	"jsdom",
+	"puppeteer"
+];
+const defaultConfig = {
+	outputFormat: "pretty",
+	outputShape: "raw",
+	requestTimeout: 5e4,
+	maxRedirects: 5,
+	userAgent: "Mozilla/5.0 (X11; Linux x64) AppleWebKit/537.36 (KHTML, like Gecko) OpenApiExtractor/1.0.0",
+	retryCount: 3,
+	retryDelay: 1e3,
+	browser: "puppeteer",
+	happyDom: {
+		enableJavaScriptEvaluation: true,
+		suppressInsecureJavaScriptEnvironmentWarning: true
+	},
+	puppeteer: {
+		headless: true,
+		args: ["--no-sandbox", "--disable-setuid-sandbox"]
+	}
+};
+let globalConfig = defaultConfig;
+const getBrowserSession = () => globalThis.__oapieBrowserSession;
+const startBrowserSession = async (config = globalConfig) => {
+	const activeSession = getBrowserSession();
+	if (activeSession?.browser === config.browser) return activeSession;
+	if (activeSession) await endBrowserSession();
+	const nextSession = {
+		browser: config.browser,
+		closers: []
+	};
+	if (config.browser === "puppeteer") nextSession.puppeteerBrowser = await (await import("puppeteer")).launch({
+		headless: config.puppeteer?.headless ?? true,
+		args: config.puppeteer?.args ?? ["--no-sandbox", "--disable-setuid-sandbox"]
+	});
+	globalThis.__oapieBrowserSession = nextSession;
+	return nextSession;
+};
+const endBrowserSession = async () => {
+	const activeSession = getBrowserSession();
+	if (!activeSession) return;
+	globalThis.__oapieBrowserSession = void 0;
+	for (const closer of activeSession.closers.reverse()) await closer();
+	if (activeSession.puppeteerBrowser) await activeSession.puppeteerBrowser.close();
+};
+const registerDeferredCloser = (browserName, closer) => {
+	const activeSession = getBrowserSession();
+	if (!activeSession || activeSession.browser !== browserName) return false;
+	activeSession.closers.push(closer);
+	return true;
+};
+const defineConfig = (config) => {
+	const userConfig = {
+		...defaultConfig,
+		...config,
+		happyDom: {
+			...defaultConfig.happyDom,
+			...config.happyDom
+		}
+	};
+	globalConfig = userConfig;
+	return userConfig;
+};
+const isSupportedBrowser = (value) => {
+	return supportedBrowsers.includes(value);
+};
+/**
+* Loads HTML content from a given source URL using the configured browser.
+* 
+* @param source    The URL of the source to load HTML from.
+* @param config    Optional user configuration to override global settings for this load operation.
+* @returns         A promise that resolves to the HTML content as a string.
+*/
+const browser = async (source, config = globalConfig, initial = false) => {
+	const { data } = config.browser !== "puppeteer" ? await axios.default.get(source, {
+		timeout: config.requestTimeout,
+		maxRedirects: config.maxRedirects,
+		headers: {
+			"User-Agent": config.userAgent,
+			"Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8"
+		}
+	}) : { data: "" };
+	if (config.browser === "axios") return data;
+	else if (config.browser === "happy-dom") {
+		const window = new happy_dom.Window({
+			url: source,
+			innerWidth: 1024,
+			innerHeight: 768,
+			settings: config.happyDom
+		});
+		window.document.write(data);
+		await window.happyDOM.waitUntilComplete();
+		const html = window.document.documentElement.outerHTML;
+		if (!html) {
+			await window.happyDOM.close();
+			throw new Error(`Unable to extract HTML from remote source: ${source}`);
+		}
+		if (!registerDeferredCloser("happy-dom", () => window.happyDOM.close())) await window.happyDOM.close();
+		return html;
+	} else if (config.browser === "jsdom") {
+		let window;
+		try {
+			({window} = new jsdom.JSDOM(data, {
+				url: source,
+				contentType: "text/html",
+				runScripts: "dangerously",
+				includeNodeLocations: true
+			}));
+			const html = window.document.documentElement.outerHTML;
+			if (!html) throw new Error(`Unable to extract HTML from remote source: ${source}`);
+			const currentWindow = window;
+			if (!registerDeferredCloser("jsdom", () => currentWindow.close())) {
+				window.close();
+				window = void 0;
+			} else window = void 0;
+			return html;
+		} finally {
+			if (window) window.close();
+		}
+	} else if (config.browser === "puppeteer") {
+		const activeSession = getBrowserSession();
+		let browserInstance = activeSession?.browser === "puppeteer" ? activeSession.puppeteerBrowser : void 0;
+		let shouldClose = false;
+		let page;
+		try {
+			if (!browserInstance) {
+				browserInstance = await (await import("puppeteer")).launch({
+					headless: config.puppeteer?.headless ?? true,
+					args: config.puppeteer?.args ?? ["--no-sandbox", "--disable-setuid-sandbox"]
+				});
+				shouldClose = true;
+			}
+			page = await browserInstance.newPage();
+			await page.setUserAgent({ userAgent: config.userAgent });
+			await page.setRequestInterception(true);
+			page.on("request", (e) => {
+				const type = e.resourceType();
+				if ([
+					"image",
+					"font",
+					"media",
+					"stylesheet"
+				].includes(type)) return void e.abort();
+				e.continue();
+			});
+			try {
+				await page.goto(source, {
+					waitUntil: "domcontentloaded",
+					timeout: config.requestTimeout
+				});
+			} catch (error) {
+				if (!page || !await hasExtractableReadmeContent(page)) throw error;
+			}
+			await waitForExtractableReadmeContent(page, config.requestTimeout, initial);
+			await waitForOperationHydration(page, config.requestTimeout);
+			let html = await page.content();
+			if (!html) throw new Error(`Unable to extract HTML from remote source: ${source}`);
+			if (!html.includes("id=\"ssr-props\"")) {
+				const { data: rawHtml } = await axios.default.get(source, {
+					timeout: config.requestTimeout,
+					maxRedirects: config.maxRedirects,
+					headers: {
+						"User-Agent": config.userAgent,
+						"Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8"
+					}
+				});
+				html = mergeSsrPropsIntoRenderedHtml(html, rawHtml);
+			}
+			return html;
+		} finally {
+			if (page && !page.isClosed()) await page.close();
+			if (shouldClose && browserInstance) await browserInstance.close();
+		}
+	} else throw new Error(`Unsupported browser specified in configuration: ${globalConfig.browser}`);
+};
+const waitForExtractableReadmeContent = async (page, timeout, initial = false) => {
+	try {
+		if (initial) await page.waitForSelector(".hub-sidebar-content .rm-Sidebar-link");
+		await page.waitForSelector("[data-testid=\"http-method\"], article#content, script#ssr-props", { timeout });
+	} catch {}
+};
+const waitForOperationHydration = async (page, timeout) => {
+	try {
+		await page.waitForFunction(() => {
+			const hasMethod = !!document.querySelector("[data-testid=\"http-method\"]");
+			const hasRequestForm = !!document.querySelector("form[name=\"Parameters\"]");
+			const hasReqPlayground = !!document.querySelector(".rm-PlaygroundRequest");
+			const hasResPlayground = !!document.querySelector(".rm-PlaygroundResponse");
+			const hasSsrProps = !!document.querySelector("script#ssr-props");
+			if (!hasMethod) return false;
+			return hasRequestForm || hasReqPlayground || hasResPlayground || hasSsrProps;
+		}, { timeout });
+	} catch {}
+	try {
+		await page.waitForSelector(".rm-PlaygroundRequest, .rm-PlaygroundResponse, form[name=\"Parameters\"], script#ssr-props", { timeout: Math.min(timeout, 5e3) });
+	} catch {}
+	try {
+		await page.waitForNetworkIdle?.({
+			idleTime: 500,
+			timeout: Math.min(timeout, 5e3)
+		});
+	} catch {}
+};
+const hasExtractableReadmeContent = async (page) => {
+	return Boolean(await page.$("[data-testid=\"http-method\"], article#content, script#ssr-props"));
+};
+const mergeSsrPropsIntoRenderedHtml = (renderedHtml, rawHtml) => {
+	if (renderedHtml.includes("id=\"ssr-props\"")) return renderedHtml;
+	const ssrPropsScript = extractSsrPropsScript(rawHtml);
+	if (!ssrPropsScript) return renderedHtml;
+	if (renderedHtml.includes("</body>")) return renderedHtml.replace("</body>", `${ssrPropsScript}</body>`);
+	if (renderedHtml.includes("</html>")) return renderedHtml.replace("</html>", `${ssrPropsScript}</html>`);
+	return `${renderedHtml}${ssrPropsScript}`;
+};
+const extractSsrPropsScript = (html) => {
+	return html.match(/<script id="ssr-props"[^>]*>[\s\S]*?<\/script>/i)?.[0] ?? null;
+};
+
+//#endregion
+//#region src/Core.ts
+const isRecord = (value) => {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+};
+
+//#endregion
+//#region src/JsonRepair.ts
+const parsePossiblyTruncatedJson = (value) => {
+	const trimmed = value.trim();
+	if (!/^(?:\{|\[)/.test(trimmed)) return null;
+	try {
+		return JSON.parse(trimmed);
+	} catch {
+		const repaired = repairCommonJsonIssues(trimmed);
+		try {
+			return JSON.parse(repaired);
+		} catch {
+			return null;
+		}
+	}
+};
+const repairCommonJsonIssues = (value) => {
+	const withMissingCommasInserted = insertMissingCommas(value);
+	return `${withMissingCommasInserted}${buildMissingJsonClosers(withMissingCommasInserted)}`;
+};
+const insertMissingCommas = (value) => {
+	let result = "";
+	let inString = false;
+	let isEscaped = false;
+	let previousSignificantCharacter = "";
+	for (let index = 0; index < value.length; index += 1) {
+		const character = value[index];
+		if (inString) {
+			result += character;
+			if (isEscaped) {
+				isEscaped = false;
+				continue;
+			}
+			if (character === "\\") {
+				isEscaped = true;
+				continue;
+			}
+			if (character === "\"") {
+				inString = false;
+				previousSignificantCharacter = "\"";
+			}
+			continue;
+		}
+		if (character === "\"") {
+			const remainder = value.slice(index);
+			if (/^"(?:\\.|[^"\\])*"\s*:/.test(remainder) && shouldInsertCommaBeforeKey(previousSignificantCharacter, result)) result += ",";
+			result += character;
+			inString = true;
+			continue;
+		}
+		result += character;
+		if (!/\s/.test(character)) previousSignificantCharacter = character;
+	}
+	return result;
+};
+const shouldInsertCommaBeforeKey = (previousSignificantCharacter, currentOutput) => {
+	if (!previousSignificantCharacter) return false;
+	if (![
+		"\"",
+		"}",
+		"]",
+		"e",
+		"l",
+		"0",
+		"1",
+		"2",
+		"3",
+		"4",
+		"5",
+		"6",
+		"7",
+		"8",
+		"9"
+	].includes(previousSignificantCharacter)) return false;
+	const trimmedOutput = currentOutput.trimEnd();
+	return !trimmedOutput.endsWith(",") && !trimmedOutput.endsWith("{");
+};
+const buildMissingJsonClosers = (value) => {
+	const stack = [];
+	let inString = false;
+	let isEscaped = false;
+	for (const character of value) {
+		if (isEscaped) {
+			isEscaped = false;
+			continue;
+		}
+		if (character === "\\") {
+			isEscaped = true;
+			continue;
+		}
+		if (character === "\"") {
+			inString = !inString;
+			continue;
+		}
+		if (inString) continue;
+		if (character === "{") {
+			stack.push("}");
+			continue;
+		}
+		if (character === "[") {
+			stack.push("]");
+			continue;
+		}
+		if ((character === "}" || character === "]") && stack[stack.length - 1] === character) stack.pop();
+	}
+	return stack.reverse().join("");
+};
+
+//#endregion
+//#region src/ReadmeExtractor.ts
+const extractReadmeOperationFromHtml = (html) => {
+	const window = new happy_dom.Window();
+	window.document.write(html);
+	const { document } = window;
+	const contentRoot = document.querySelector("article#content") ?? document.body;
+	const requestParamsForm = contentRoot.querySelector("form[name=\"Parameters\"]");
+	const requestPlayground = document.querySelector(".rm-PlaygroundRequest");
+	const responsePlayground = document.querySelector(".rm-PlaygroundResponse");
+	const requestCodeSnippets = extractRequestCodeSnippets(requestPlayground);
+	const requestExampleNormalized = normalizeRequestCodeSnippet(requestCodeSnippets[0] ?? null);
+	const responseBodies = extractResponseBodies(responsePlayground);
+	return mergeReadmeOperations({
+		method: readText(contentRoot.querySelector("[data-testid=\"http-method\"]"))?.toUpperCase() ?? null,
+		url: readText(contentRoot.querySelector("[data-testid=\"serverurl\"]")),
+		description: extractOperationDescription(contentRoot),
+		sidebarLinks: extractSidebarLinks(document.querySelector(".rm-Sidebar.hub-sidebar-content")),
+		requestParams: extractRequestParams(requestParamsForm),
+		requestCodeSnippets,
+		requestExample: requestCodeSnippets[0]?.body ?? null,
+		requestExampleNormalized,
+		responseSchemas: extractResponseSchemas(contentRoot),
+		responseBodies,
+		responseExample: responseBodies[0]?.body ?? null,
+		responseExampleRaw: responseBodies[0]?.rawBody ?? null
+	}, extractReadmeOperationFromSsrProps(document));
+};
+const mergeReadmeOperations = (primary, fallback) => {
+	if (!fallback) return primary;
+	return {
+		method: primary.method ?? fallback.method,
+		url: primary.url ?? fallback.url,
+		description: primary.description ?? fallback.description,
+		sidebarLinks: primary.sidebarLinks.length > 0 ? primary.sidebarLinks : fallback.sidebarLinks,
+		requestParams: primary.requestParams.length > 0 ? primary.requestParams : fallback.requestParams,
+		requestCodeSnippets: primary.requestCodeSnippets.length > 0 ? primary.requestCodeSnippets : fallback.requestCodeSnippets,
+		requestExample: primary.requestExample ?? fallback.requestExample,
+		requestExampleNormalized: primary.requestExampleNormalized ?? fallback.requestExampleNormalized,
+		responseSchemas: primary.responseSchemas.length > 0 ? primary.responseSchemas : fallback.responseSchemas,
+		responseBodies: primary.responseBodies.length > 0 ? primary.responseBodies : fallback.responseBodies,
+		responseExample: primary.responseExample ?? fallback.responseExample,
+		responseExampleRaw: primary.responseExampleRaw ?? fallback.responseExampleRaw
+	};
+};
+const extractReadmeOperationFromSsrProps = (document) => {
+	const rawSsrProps = document.querySelector("script#ssr-props")?.textContent?.trim();
+	if (!rawSsrProps) return null;
+	let ssrProps;
+	try {
+		ssrProps = JSON.parse(rawSsrProps);
+	} catch {
+		return null;
+	}
+	const apiDocument = isRecord(ssrProps) && isRecord(ssrProps.document) ? ssrProps.document.api : null;
+	if (!isRecord(apiDocument)) return null;
+	const method = typeof apiDocument.method === "string" ? apiDocument.method.toUpperCase() : null;
+	const path = typeof apiDocument.path === "string" ? apiDocument.path : null;
+	const schema = isRecord(apiDocument.schema) ? apiDocument.schema : null;
+	const operation = resolveSsrOperation(schema, path, method?.toLowerCase() ?? null);
+	const serverUrl = Array.isArray(schema?.servers) && isRecord(schema.servers[0]) && typeof schema.servers[0].url === "string" ? schema.servers[0].url : null;
+	if (!operation && !method && !path) return null;
+	const responseBodies = extractResponseBodiesFromOpenApi(operation?.responses ?? {});
+	return {
+		method,
+		url: buildOperationUrl(serverUrl, path),
+		description: operation?.description ?? null,
+		sidebarLinks: [],
+		requestParams: [...extractOperationParametersFromOpenApi(operation?.parameters), ...extractRequestParamsFromOpenApi(operation?.requestBody)],
+		requestCodeSnippets: [],
+		requestExample: null,
+		requestExampleNormalized: null,
+		responseSchemas: extractResponseSchemasFromOpenApi(operation?.responses ?? {}),
+		responseBodies,
+		responseExample: responseBodies[0]?.body ?? null,
+		responseExampleRaw: responseBodies[0]?.rawBody ?? null
+	};
+};
+const extractOperationParametersFromOpenApi = (parameters) => {
+	if (!parameters) return [];
+	return parameters.map((parameter) => ({
+		name: parameter.name,
+		in: parameter.in,
+		path: [parameter.name],
+		type: parameter.schema?.type ?? null,
+		required: parameter.required ?? false,
+		defaultValue: parameter.schema?.default == null ? parameter.example == null ? null : String(parameter.example) : String(parameter.schema.default),
+		description: parameter.description ?? parameter.schema?.description ?? null
+	}));
+};
+const resolveSsrOperation = (schema, path, method) => {
+	if (!schema || !path || !method || !isRecord(schema.paths)) return null;
+	const pathItem = schema.paths[path];
+	if (!isRecord(pathItem) || !isRecord(pathItem[method])) return null;
+	return pathItem[method];
+};
+const buildOperationUrl = (serverUrl, path) => {
+	if (!serverUrl || !path) return null;
+	return `${serverUrl.replace(/\/$/, "")}${path.startsWith("/") ? path : `/${path}`}`;
+};
+const extractRequestParamsFromOpenApi = (requestBody) => {
+	const schema = requestBody?.content?.["application/json"]?.schema;
+	if (!schema) return [];
+	return flattenOpenApiSchemaProperties(schema);
+};
+const flattenOpenApiSchemaProperties = (schema, path = []) => {
+	if (!schema.properties) return [];
+	const params = [];
+	for (const [name, property] of Object.entries(schema.properties)) {
+		const propertyPath = [...path, name];
+		const required = schema.required?.includes(name) ?? false;
+		if (property.type === "object" && property.properties) {
+			params.push(...flattenOpenApiSchemaProperties(property, propertyPath).map((param) => ({
+				...param,
+				required: param.path.length === propertyPath.length + 1 ? required && param.required : param.required
+			})));
+			continue;
+		}
+		params.push({
+			name,
+			in: "body",
+			path: propertyPath,
+			type: property.type ?? null,
+			required,
+			defaultValue: property.default == null ? null : String(property.default),
+			description: property.description ?? null
+		});
+	}
+	return params;
+};
+const extractResponseSchemasFromOpenApi = (responses) => {
+	return Object.entries(responses).map(([statusCode, response]) => ({
+		statusCode,
+		description: response.description ?? statusCode
+	}));
+};
+const extractResponseBodiesFromOpenApi = (responses) => {
+	const bodies = [];
+	for (const [statusCode, response] of Object.entries(responses)) for (const [contentType, mediaType] of Object.entries(response.content ?? {})) {
+		const example = resolveOpenApiMediaExample(mediaType);
+		if (example == null) continue;
+		const rawBody = typeof example === "string" ? example : JSON.stringify(example, null, 2);
+		const normalized = normalizeResponseBody(rawBody, contentType);
+		bodies.push({
+			format: normalized.format,
+			contentType,
+			statusCode,
+			label: response.description ?? statusCode,
+			body: normalized.body,
+			rawBody
+		});
+	}
+	return bodies;
+};
+const resolveOpenApiMediaExample = (mediaType) => {
+	if (mediaType.example !== void 0) return mediaType.example;
+	const examples = mediaType.examples;
+	if (examples && isRecord(examples)) {
+		for (const example of Object.values(examples)) if (isRecord(example) && "value" in example) return example.value ?? null;
+	}
+	if (mediaType.schema?.example !== void 0) return mediaType.schema.example;
+	return null;
+};
+const extractOperationDescription = (root) => {
+	const header = root.querySelector("header");
+	if (!header) return null;
+	const markdownBlocks = Array.from(header.querySelectorAll("[data-testid=\"RDMD\"]"));
+	return readText(markdownBlocks[markdownBlocks.length - 1] ?? null);
+};
+const extractRequestCodeSnippets = (root) => {
+	if (!root) return [];
+	const label = extractRequestSnippetLabel(root);
+	return extractCodeSnippets(root).map((body) => ({
+		label,
+		body
+	}));
+};
+const extractResponseBodies = (root) => {
+	if (!root) return [];
+	const bodies = extractCodeSnippets(root);
+	const contentTypes = extractResponseContentTypes(root);
+	const labels = extractResponseLabels(root);
+	return bodies.map((body, index) => {
+		const label = labels[index] ?? labels[0] ?? null;
+		const contentType = contentTypes[index] ?? contentTypes[0] ?? null;
+		const normalized = normalizeResponseBody(body, contentType);
+		return {
+			format: normalized.format,
+			contentType,
+			statusCode: label?.match(/\b\d{3}\b/)?.[0] ?? null,
+			label,
+			body: normalized.body,
+			rawBody: body
+		};
+	});
+};
+const extractSidebarLinks = (root) => {
+	if (!root) return [];
+	return Array.from(root.querySelectorAll(".rm-Sidebar-link")).map((link) => {
+		const section = link.closest(".rm-Sidebar-section");
+		const method = readText(link.querySelector("[data-testid=\"http-method\"]"))?.toUpperCase() ?? null;
+		return {
+			section: readText(section?.querySelector(".rm-Sidebar-heading") ?? null),
+			label: extractSidebarLinkLabel(link, method),
+			href: link.getAttribute("href"),
+			method,
+			active: link.classList.contains("active") || link.getAttribute("aria-current") === "page",
+			subpage: link.classList.contains("subpage")
+		};
+	}).filter((link) => link.label.length > 0);
+};
+const extractRequestParams = (root) => {
+	if (!root) return [];
+	return Array.from(root.querySelectorAll("label")).map((label) => {
+		const name = readText(label);
+		const param = findParameterRoot(label, root);
+		const input = resolveParameterInput(param, label);
+		return {
+			name: name ?? "",
+			in: inferParameterLocation(param, label, root),
+			path: inferParameterPath(label, name),
+			type: inferParameterType(param, input),
+			required: isRequiredParameter(param, input),
+			defaultValue: readInputValue(input),
+			description: extractParameterDescription(param)
+		};
+	}).filter((param) => param.name.length > 0);
+};
+const extractResponseSchemas = (root) => {
+	const picker = root.querySelector("#response-schemas")?.nextElementSibling;
+	if (!picker || !picker.classList.contains("rm-APIResponseSchemaPicker")) return [];
+	return Array.from(picker.querySelectorAll("button")).map((option) => {
+		const optionText = readText(option);
+		const statusCodeMatch = optionText?.match(/\b\d{3}\b/);
+		const markdownBlocks = Array.from(option.querySelectorAll("[data-testid=\"RDMD\"]"));
+		return {
+			statusCode: statusCodeMatch?.[0] ?? null,
+			description: readText(markdownBlocks[0] ?? null) ?? optionText
+		};
+	}).filter((schema) => schema.statusCode !== null);
+};
+const extractCodeSnippets = (root) => {
+	return Array.from(root.querySelectorAll(".CodeSnippet")).map((snippet) => extractCodeMirrorText(snippet)).filter((snippet) => Boolean(snippet));
+};
+const extractCodeMirrorText = (root) => {
+	if (!root) return null;
+	const codeMirrorLines = Array.from(root.querySelectorAll(".CodeMirror-code pre.CodeMirror-line"));
+	if (codeMirrorLines.length === 0) return null;
+	return codeMirrorLines.map((line) => line.textContent?.replace(/\u00a0/g, " ") ?? "").join("\n").trimEnd() || null;
+};
+const extractRequestSnippetLabel = (root) => {
+	const header = root.querySelector("header");
+	if (!header) return null;
+	const buttonTexts = Array.from(header.querySelectorAll("button")).map((button) => extractButtonText(button)).filter((text) => Boolean(text));
+	return buttonTexts.find((text) => text.toLowerCase() !== "examples") ?? buttonTexts[0] ?? null;
+};
+const readInputValue = (element) => {
+	if (!element) return null;
+	return element.getAttribute("value")?.trim() || null;
+};
+const extractSidebarLinkLabel = (link, method) => {
+	return readTexts(link.querySelectorAll("span")).filter((text) => !method || text.toUpperCase() !== method).sort((left, right) => right.length - left.length)[0] ?? readText(link) ?? "";
+};
+const extractResponseContentTypes = (root) => {
+	return readTexts(root.querySelectorAll("div")).filter((text) => /^[\w.+-]+\/[\w.+-]+$/i.test(text));
+};
+const extractResponseLabels = (root) => {
+	return Array.from(root.querySelectorAll("button, [role=\"button\"]")).map((element) => extractButtonText(element)).filter((text) => Boolean(text)).filter((text) => /\b\d{3}\b/.test(text));
+};
+const findParameterRoot = (label, root) => {
+	const fieldId = label.getAttribute("for");
+	let current = label;
+	while (current) {
+		const fieldInput = fieldId ? current.querySelector(`#${escapeSelector(fieldId)}`) : null;
+		const fallbackInput = current.querySelector("input, textarea, select");
+		if ((fieldInput || fallbackInput) && current !== root) return current;
+		current = current.parentElement;
+	}
+	return label;
+};
+const resolveParameterInput = (param, label) => {
+	const fieldId = label.getAttribute("for");
+	const byId = fieldId ? param.querySelector(`#${escapeSelector(fieldId)}`) : null;
+	const fallback = param.querySelector("input, textarea, select");
+	return byId ?? fallback;
+};
+const inferParameterLocation = (param, label, root) => {
+	const locationFromId = inferParameterLocationFromText(`${label.getAttribute("for")?.toLowerCase() ?? ""} ${param.closest("[id]")?.getAttribute("id")?.toLowerCase() ?? ""}`);
+	if (locationFromId) return locationFromId;
+	let current = param;
+	while (current && current !== root) {
+		let sibling = current.previousElementSibling;
+		while (sibling) {
+			if (sibling.tagName === "HEADER") {
+				const locationFromHeader = inferParameterLocationFromText(readText(sibling) ?? "");
+				if (locationFromHeader) return locationFromHeader;
+			}
+			sibling = sibling.previousElementSibling;
+		}
+		current = current.parentElement;
+	}
+	return null;
+};
+const inferParameterLocationFromText = (value) => {
+	const normalized = value.trim().toLowerCase();
+	if (normalized.includes("query params") || normalized.includes("query-")) return "query";
+	if (normalized.includes("headers") || normalized.includes("header-")) return "header";
+	if (normalized.includes("body params") || normalized.includes("request body") || normalized.includes("body-")) return "body";
+	if (normalized.includes("path params") || normalized.includes("path-")) return "path";
+	if (normalized.includes("cookie") || normalized.includes("cookie-")) return "cookie";
+	return null;
+};
+const inferParameterPath = (label, name) => {
+	const fieldId = label.getAttribute("for") ?? "";
+	const suffix = fieldId.includes("_") ? fieldId.slice(fieldId.indexOf("_") + 1) : "";
+	if (suffix.includes(".")) return suffix.split(".").map((segment) => segment.trim()).filter((segment) => segment.length > 0);
+	return name ? [name] : [];
+};
+const inferParameterType = (param, input) => {
+	const inputType = input?.getAttribute("type")?.toLowerCase();
+	if (inputType === "text") return "string";
+	if (inputType) return inputType;
+	const fieldClass = Array.from(param.querySelectorAll("[class]")).find((element) => {
+		return (element.getAttribute("class") ?? "").split(/\s+/).some((token) => token.startsWith("field-"));
+	})?.getAttribute("class")?.split(/\s+/).find((token) => token.startsWith("field-"));
+	if (fieldClass) return fieldClass.replace(/^field-/, "");
+	return null;
+};
+const isRequiredParameter = (param, input) => {
+	if (input?.hasAttribute("required")) return true;
+	return readTexts(param.querySelectorAll("*")).some((text) => text.toLowerCase() === "required");
+};
+const extractParameterDescription = (param) => {
+	const description = param.querySelector("[id$=\"__description\"]");
+	if (description) return readText(description);
+	return readText(Array.from(param.querySelectorAll("[data-testid=\"RDMD\"]"))[0] ?? null);
+};
+const normalizeResponseBody = (body, contentType) => {
+	const trimmed = body.trim();
+	if (contentType?.toLowerCase().includes("json") || /^(?:\{|\[)/.test(trimmed)) {
+		const parsedBody = parsePossiblyTruncatedJson(trimmed);
+		if (parsedBody !== null) return {
+			format: "json",
+			body: parsedBody
+		};
+		return {
+			format: "text",
+			body
+		};
+	}
+	return {
+		format: "text",
+		body
+	};
+};
+const normalizeRequestCodeSnippet = (snippet) => {
+	if (!snippet) return null;
+	return normalizeCurlSnippet(snippet) ?? normalizeFetchSnippet(snippet) ?? {
+		sourceLabel: snippet.label,
+		method: null,
+		url: null,
+		headers: {},
+		bodyFormat: null,
+		body: null,
+		rawBody: null
+	};
+};
+const normalizeCurlSnippet = (snippet) => {
+	if (!snippet.body.startsWith("curl ")) return null;
+	const method = snippet.body.match(/--request\s+([A-Z]+)/)?.[1] ?? null;
+	const url = snippet.body.match(/--url\s+(\S+)/)?.[1] ?? null;
+	const headers = Object.fromEntries(Array.from(snippet.body.matchAll(/--header\s+'([^:]+):\s*([^']+)'/g)).map((match) => [match[1].trim(), match[2].trim()]));
+	const rawBody = snippet.body.match(/--data\s+'([\s\S]*)'$/)?.[1]?.trim() ?? null;
+	const normalizedBody = rawBody ? normalizeResponseBody(rawBody, headers["content-type"] ?? headers["Content-Type"] ?? null) : null;
+	return {
+		sourceLabel: snippet.label,
+		method,
+		url,
+		headers,
+		bodyFormat: normalizedBody?.format ?? null,
+		body: normalizedBody?.body ?? null,
+		rawBody
+	};
+};
+const normalizeFetchSnippet = (snippet) => {
+	const fetchMatch = snippet.body.match(/fetch\(\s*(["'])(.*?)\1\s*,\s*\{([\s\S]*)\}\s*\)/);
+	if (!fetchMatch) return null;
+	const [, , url, optionsBody] = fetchMatch;
+	const method = extractObjectPropertyValue(optionsBody, "method")?.toUpperCase() ?? null;
+	const headers = extractFetchHeaders(optionsBody);
+	const rawBody = extractFetchBody(optionsBody);
+	const contentType = headers["content-type"] ?? headers["Content-Type"] ?? null;
+	const normalizedBody = rawBody ? normalizeStructuredRequestBody(rawBody, contentType) : null;
+	return {
+		sourceLabel: snippet.label,
+		method,
+		url,
+		headers,
+		bodyFormat: normalizedBody?.format ?? null,
+		body: normalizedBody?.body ?? null,
+		rawBody
+	};
+};
+const extractFetchHeaders = (optionsBody) => {
+	const headersBlock = extractObjectPropertyValue(optionsBody, "headers");
+	if (!headersBlock) return {};
+	const parsedHeaders = parseLooseStructuredValue(headersBlock);
+	if (!isRecord(parsedHeaders)) return {};
+	return Object.fromEntries(Object.entries(parsedHeaders).map(([key, value]) => [key, String(value)]));
+};
+const extractFetchBody = (optionsBody) => {
+	return extractObjectPropertyValue(optionsBody, "body");
+};
+const normalizeStructuredRequestBody = (body, contentType) => {
+	const parsedBody = parseLooseStructuredValue(body);
+	if (parsedBody !== null && (contentType?.toLowerCase().includes("json") || /^[[{]/.test(body.trim()))) return {
+		format: "json",
+		body: parsedBody
+	};
+	return normalizeResponseBody(body, contentType);
+};
+const extractObjectPropertyValue = (source, propertyName) => {
+	const propertyMatch = source.match(new RegExp(`\\b${propertyName}\\s*:`, "m"));
+	if (!propertyMatch || propertyMatch.index === void 0) return null;
+	let cursor = propertyMatch.index + propertyMatch[0].length;
+	while (/\s/.test(source[cursor] ?? "")) cursor += 1;
+	if (source.startsWith("JSON.stringify", cursor)) {
+		const openParenIndex = source.indexOf("(", cursor);
+		if (openParenIndex === -1) return null;
+		return extractBalancedSegment(source, openParenIndex, "(", ")")?.slice(1, -1).trim() ?? null;
+	}
+	if (source[cursor] === "{" || source[cursor] === "[") {
+		const closingChar = source[cursor] === "{" ? "}" : "]";
+		return extractBalancedSegment(source, cursor, source[cursor], closingChar)?.trim() ?? null;
+	}
+	if (source[cursor] === "\"" || source[cursor] === "'") return extractStringLiteralValue(source, cursor);
+	return (source.slice(cursor).match(/^([^,\n]+)/)?.[1])?.trim() ?? null;
+};
+const extractBalancedSegment = (source, startIndex, openChar, closeChar) => {
+	let depth = 0;
+	let quoteChar = null;
+	let isEscaped = false;
+	for (let index = startIndex; index < source.length; index += 1) {
+		const character = source[index];
+		if (quoteChar) {
+			if (isEscaped) {
+				isEscaped = false;
+				continue;
+			}
+			if (character === "\\") {
+				isEscaped = true;
+				continue;
+			}
+			if (character === quoteChar) quoteChar = null;
+			continue;
+		}
+		if (character === "\"" || character === "'") {
+			quoteChar = character;
+			continue;
+		}
+		if (character === openChar) {
+			depth += 1;
+			continue;
+		}
+		if (character === closeChar) {
+			depth -= 1;
+			if (depth === 0) return source.slice(startIndex, index + 1);
+		}
+	}
+	return null;
+};
+const extractStringLiteralValue = (source, startIndex) => {
+	const quoteChar = source[startIndex];
+	let value = "";
+	let isEscaped = false;
+	for (let index = startIndex + 1; index < source.length; index += 1) {
+		const character = source[index];
+		if (isEscaped) {
+			value += character;
+			isEscaped = false;
+			continue;
+		}
+		if (character === "\\") {
+			isEscaped = true;
+			continue;
+		}
+		if (character === quoteChar) return value;
+		value += character;
+	}
+	return null;
+};
+const parseLooseStructuredValue = (value) => {
+	const trimmed = value.trim();
+	if (!/^[[{]/.test(trimmed)) return null;
+	const normalized = trimmed.replace(/([{,]\s*)([A-Za-z_$][\w$-]*)(\s*:)/g, "$1\"$2\"$3").replace(/'([^'\\]*(?:\\.[^'\\]*)*)'/g, (_match, inner) => JSON.stringify(inner.replace(/\\'/g, "'"))).replace(/,\s*([}\]])/g, "$1");
+	try {
+		return JSON.parse(normalized);
+	} catch {
+		return null;
+	}
+};
+const escapeSelector = (value) => {
+	return value.replace(/([#.:[\],=])/g, "\\$1");
+};
+const readText = (element) => {
+	const value = element?.textContent?.replace(/\s+/g, " ").trim();
+	return value ? value : null;
+};
+const readTexts = (elements) => {
+	return Array.from(elements).map((element) => readText(element)).filter((value) => Boolean(value));
+};
+const extractButtonText = (element) => {
+	return readTexts(element.querySelectorAll("span, div, code")).filter((text) => text.trim().length > 0).sort((left, right) => right.length - left.length)[0] ?? readText(element);
+};
+
+//#endregion
+//#region src/ReadmeCrawler.ts
+const resolveReadmeSidebarUrls = (operation, baseUrl) => {
+	const normalizedBaseUrl = new URL(baseUrl);
+	const urls = operation.sidebarLinks.map((link) => link.href).filter((href) => Boolean(href)).map((href) => new URL(href, normalizedBaseUrl).toString()).filter((href) => /^https?:\/\//i.test(href));
+	return Array.from(new Set(urls));
+};
+
+//#endregion
+//#region src/Application.ts
+var Application = class {
+	config;
+	constructor(config = {}) {
+		this.config = defineConfig(config);
+	}
+	getConfig(config = {}) {
+		return {
+			...this.config,
+			...config
+		};
+	}
+	configure(config) {
+		this.config = defineConfig({
+			...this.config,
+			...config
+		});
+		return this.config;
+	}
+	async crawlReadmeOperations(source, rootOperation, baseUrl) {
+		const crawlBaseUrl = this.resolveCrawlBaseUrl(source, baseUrl);
+		if (!crawlBaseUrl) throw new Error("Crawl mode requires a remote source URL or --base-url when using a local file");
+		const sessionWasActive = Boolean(getBrowserSession());
+		if (!sessionWasActive) await startBrowserSession(this.config);
+		try {
+			const discoveredUrls = resolveReadmeSidebarUrls(rootOperation, crawlBaseUrl);
+			const rootSourceUrl = new URL(crawlBaseUrl).toString();
+			const rootEntry = this.attachSourceUrl(rootSourceUrl, rootOperation);
+			const urlsToFetch = discoveredUrls.filter((url) => url !== rootSourceUrl);
+			return {
+				rootSource: rootSourceUrl,
+				discoveredUrls,
+				operations: [rootEntry, ...(await Promise.all(urlsToFetch.map(async (url) => {
+					const start = Date.now();
+					const operation = extractReadmeOperationFromHtml(await this.loadHtmlSource(url));
+					const end = Date.now() - start;
+					if (!operation.method) return null;
+					_h3ravel_shared.Logger.twoColumnDetail(_h3ravel_shared.Logger.log([["Crawled", "green"], [`${end / 1e3}s`, "gray"]], " ", false), url.replace(crawlBaseUrl, ""));
+					return this.attachSourceUrl(url, operation);
+				}))).filter((operation) => operation !== null)]
+			};
+		} finally {
+			if (!sessionWasActive) await endBrowserSession();
+		}
+	}
+	attachSourceUrl(sourceUrl, operation) {
+		return {
+			sourceUrl,
+			...operation
+		};
+	}
+	resolveCrawlBaseUrl(source, baseUrl) {
+		if (baseUrl) return new URL(baseUrl).toString();
+		if (/^https?:\/\//i.test(source)) return source;
+		return null;
+	}
+	async loadHtmlSource(source, initial) {
+		if (!source) throw new Error("A source path or URL is required");
+		if (/^https?:\/\//i.test(source)) return browser(source, this.config, initial);
+		return (0, node_fs_promises.readFile)(node_path.default.resolve(process.cwd(), source), "utf8");
+	}
+};
+
+//#endregion
+//#region src/Commands/InitCommand.ts
+const __filename$1 = (0, url.fileURLToPath)(require("url").pathToFileURL(__filename).href);
+var InitCommand = class extends _h3ravel_musket.Command {
+	signature = `init 
+        {--f|force : Overwrite existing config}
+    `;
+	description = "Generate a default openapie.config.ts in the current directory";
+	async handle() {
+		const cwd = process.cwd();
+		const configPath = node_path.default.join(cwd, "openapie.config.js");
+		const force = Boolean(this.option("force", false));
+		const configTemplate = this.buildConfigTemplate();
+		try {
+			await node_fs_promises.default.access(configPath);
+			if (!force) {
+				this.error(`Config file already exists at ${configPath}. Use --force to overwrite.`);
+				process.exit(1);
+			}
+		} catch {}
+		await node_fs_promises.default.writeFile(configPath, configTemplate, "utf8");
+		this.line(`Created ${configPath} `);
+	}
+	buildConfigTemplate() {
+		const def = defaultConfig;
+		return [
+			`import { defineConfig } from '${__filename$1.includes("node_modules") ? "openapie" : "./src/Manager"}'`,
+			"",
+			"/**",
+			" * See https://oapi-extractor.toneflix.net/configuration for docs",
+			" */",
+			"export default defineConfig({",
+			`  outputFormat: '${def.outputFormat}',`,
+			`  outputShape: '${def.outputShape}',`,
+			`  browser: '${def.browser}',`,
+			`  requestTimeout: ${def.requestTimeout},`,
+			`  maxRedirects: ${def.maxRedirects},`,
+			`  userAgent: '${def.userAgent}',`,
+			`  retryCount: ${def.retryCount},`,
+			`  retryDelay: ${def.retryDelay},`,
+			"})"
+		].join("\n");
+	}
+};
+
+//#endregion
+//#region src/OpenApiTransform.ts
+const createOpenApiDocumentFromReadmeOperations = (operations, title = "Extracted API", version = "0.0.0") => {
+	const paths = {};
+	for (const operation of operations) {
+		const normalized = transformReadmeOperationToOpenApi(operation);
+		if (!normalized || shouldSkipNormalizedOperation(normalized)) continue;
+		paths[normalized.path] ??= {};
+		paths[normalized.path][normalized.method] = normalized.operation;
+	}
+	return {
+		openapi: "3.1.0",
+		info: {
+			title,
+			version
+		},
+		paths
+	};
+};
+const shouldSkipNormalizedOperation = (normalized) => {
+	return normalized.path === "/" && normalized.method === "get" && normalized.operation.operationId === "get" && Object.keys(normalized.operation.responses).length === 0;
+};
+const transformReadmeOperationToOpenApi = (operation) => {
+	if (!operation.method || !operation.url) return null;
+	const url = new URL(operation.url);
+	if (shouldSkipPlaceholderOperation(url, operation)) return null;
+	const method = operation.method.toLowerCase();
+	const path = decodeOpenApiPathname(url.pathname);
+	return {
+		path,
+		method,
+		operation: {
+			summary: operation.sidebarLinks.find((link) => link.active)?.label,
+			description: operation.description ?? void 0,
+			operationId: buildOperationId(method, path),
+			parameters: createParameters(operation.requestParams),
+			requestBody: createRequestBody(operation.requestParams, operation.requestExampleNormalized?.body, hasExtractedBodyParams(operation.requestParams) ? null : resolveFallbackRequestBodyExample(operation)),
+			responses: createResponses(operation.responseSchemas, operation.responseBodies)
+		}
+	};
+};
+const shouldSkipPlaceholderOperation = (url, operation) => {
+	if (url.hostname !== "example.com" || url.pathname !== "/") return false;
+	return operation.requestParams.length === 0 && operation.responseSchemas.length === 0 && operation.responseBodies.length === 0 && operation.requestExampleNormalized?.url === "https://example.com/";
+};
+const decodeOpenApiPathname = (pathname) => {
+	return pathname.split("/").map((segment) => {
+		if (!segment) return segment;
+		try {
+			return decodeURIComponent(segment);
+		} catch {
+			return segment;
+		}
+	}).join("/");
+};
+const hasExtractedBodyParams = (params) => {
+	return params.some((param) => param.in === "body" || param.in === null);
+};
+const createParameters = (params) => {
+	const parameters = params.filter((param) => isOpenApiParameterLocation(param.in)).map((param) => createParameter(param));
+	return parameters.length > 0 ? parameters : void 0;
+};
+const createRequestBody = (params, example, fallbackExample) => {
+	const bodyParams = params.filter((param) => param.in === "body" || param.in === null);
+	if (bodyParams.length === 0 && example == null) return;
+	const schema = buildRequestBodySchema(bodyParams, example, fallbackExample);
+	return {
+		required: bodyParams.length > 0 ? bodyParams.some((param) => param.required) : false,
+		content: { "application/json": {
+			schema,
+			...example != null ? { example } : {}
+		} }
+	};
+};
+const buildRequestBodySchema = (params, example, fallbackExample) => {
+	const schema = mergeOpenApiSchemas(createExampleSchema(example), createExampleSchema(fallbackExample)) ?? { type: "object" };
+	if (example != null) schema.example = example;
+	else if (fallbackExample != null) schema.example = fallbackExample;
+	for (const param of params) insertRequestBodyParam(schema, param);
+	return schema;
+};
+const inferSchemaFromExample = (value) => {
+	if (Array.isArray(value)) return {
+		type: "array",
+		items: inferSchemaFromExample(value[0]) ?? {},
+		example: value
+	};
+	if (isRecord(value)) return {
+		type: "object",
+		properties: Object.fromEntries(Object.entries(value).map(([key, entryValue]) => [key, inferSchemaFromExample(entryValue) ?? {}])),
+		example: value
+	};
+	if (typeof value === "string") return {
+		type: "string",
+		example: value
+	};
+	if (typeof value === "number") return {
+		type: Number.isInteger(value) ? "integer" : "number",
+		example: value
+	};
+	if (typeof value === "boolean") return {
+		type: "boolean",
+		example: value
+	};
+	if (value === null) return {};
+};
+const insertRequestBodyParam = (rootSchema, param) => {
+	const path = param.path.length > 0 ? param.path : [param.name];
+	let currentSchema = rootSchema;
+	for (const [index, segment] of path.slice(0, -1).entries()) {
+		currentSchema.properties ??= {};
+		currentSchema.properties[segment] ??= { type: "object" };
+		if (param.required) currentSchema.required = Array.from(new Set([...currentSchema.required ?? [], segment]));
+		currentSchema = currentSchema.properties[segment];
+		currentSchema.type ??= "object";
+		if (index === path.length - 2 && param.required) currentSchema.required ??= [];
+	}
+	const leafKey = path[path.length - 1] ?? param.name;
+	currentSchema.properties ??= {};
+	currentSchema.properties[leafKey] = createParameterSchema(param);
+	if (param.required) currentSchema.required = Array.from(new Set([...currentSchema.required ?? [], leafKey]));
+};
+const createParameter = (param) => {
+	return {
+		name: param.name,
+		in: param.in,
+		required: param.in === "path" ? true : param.required,
+		description: param.description ?? void 0,
+		schema: createParameterSchema(param),
+		example: param.defaultValue ?? void 0
+	};
+};
+const createParameterSchema = (param) => {
+	return {
+		type: param.type ?? void 0,
+		description: param.description ?? void 0,
+		default: param.defaultValue ?? void 0
+	};
+};
+const createResponses = (schemas, responseBodies) => {
+	const responses = {};
+	for (const schema of schemas) {
+		if (!schema.statusCode) continue;
+		const content = createResponseContent(responseBodies.filter((body) => body.statusCode === schema.statusCode));
+		responses[schema.statusCode] = {
+			description: schema.description ?? schema.statusCode,
+			...content ? { content } : {}
+		};
+	}
+	for (const body of responseBodies) {
+		if (!body.statusCode || responses[body.statusCode]) continue;
+		const content = createResponseContent([body]);
+		responses[body.statusCode] = {
+			description: body.label ?? body.statusCode,
+			...content ? { content } : {}
+		};
+	}
+	return responses;
+};
+const createResponseContent = (bodies) => {
+	if (bodies.length === 0) return;
+	const content = {};
+	for (const body of bodies) {
+		const contentType = body.contentType ?? (body.format === "json" ? "application/json" : "text/plain");
+		content[contentType] = {
+			schema: inferSchemaFromBody(body.body, body.format),
+			example: body.body
+		};
+	}
+	return content;
+};
+const inferSchemaFromBody = (body, format) => {
+	if (format === "json") return inferSchemaFromExample(body);
+	if (format === "text") return {
+		type: "string",
+		example: body
+	};
+};
+const resolveFallbackRequestBodyExample = (operation) => {
+	const jsonResponseBody = operation.responseBodies.find((body) => body.format === "json")?.body;
+	if (jsonResponseBody != null) return jsonResponseBody;
+	if (typeof operation.responseExample === "object" && operation.responseExample !== null) return operation.responseExample;
+	if (typeof operation.responseExampleRaw === "string") return parsePossiblyTruncatedJson(operation.responseExampleRaw);
+	if (typeof operation.responseExample === "string") return parsePossiblyTruncatedJson(operation.responseExample);
+	return null;
+};
+const createExampleSchema = (value) => {
+	if (value == null) return null;
+	return inferSchemaFromExample(value) ?? null;
+};
+const mergeOpenApiSchemas = (left, right) => {
+	if (!left) return right;
+	if (!right) return left;
+	const merged = {
+		...right,
+		...left,
+		...left.type || right.type ? { type: left.type ?? right.type } : {},
+		...left.description || right.description ? { description: left.description ?? right.description } : {},
+		...left.default !== void 0 || right.default !== void 0 ? { default: left.default ?? right.default } : {},
+		...left.example !== void 0 || right.example !== void 0 ? { example: left.example ?? right.example } : {}
+	};
+	if (left.properties || right.properties) {
+		const propertyKeys = new Set([...Object.keys(left.properties ?? {}), ...Object.keys(right.properties ?? {})]);
+		merged.properties = Object.fromEntries(Array.from(propertyKeys).map((key) => [key, mergeOpenApiSchemas(left.properties?.[key] ?? null, right.properties?.[key] ?? null) ?? {}]));
+	}
+	if (left.items || right.items) merged.items = mergeOpenApiSchemas(left.items ?? null, right.items ?? null) ?? {};
+	if (left.required || right.required) merged.required = Array.from(new Set([...right.required ?? [], ...left.required ?? []]));
+	return merged;
+};
+const buildOperationId = (method, path) => {
+	return `${method}${path.replace(/\{([^}]+)\}/g, "$1").split("/").filter(Boolean).map((segment) => segment.replace(/[^a-zA-Z0-9]+/g, " ")).map((segment) => segment.trim()).filter(Boolean).map((segment) => segment.charAt(0).toUpperCase() + segment.slice(1).replace(/\s+(.)/g, (_match, char) => char.toUpperCase())).join("")}`;
+};
+const isOpenApiParameterLocation = (value) => {
+	return value === "query" || value === "header" || value === "path" || value === "cookie";
+};
+
+//#endregion
+//#region src/Commands/ParseCommand.ts
+var ParseCommand = class extends _h3ravel_musket.Command {
+	signature = `parse
+        {source : Local HTML file path or remote URL}
+        {--O|output=pretty : Output format [pretty,json,js]}
+        {--S|shape=raw : Result shape [raw,openapi]}
+        {--B|browser? : Remote loader [axios,happy-dom,jsdom,puppeteer]}
+        {--c|crawl : Crawl sidebar links and parse every discovered operation}
+        {--b|base-url? : Base URL used to resolve sidebar links when crawling from a local file}
+    `;
+	description = "Parse a saved ReadMe page or remote documentation URL and print normalized output";
+	async handle() {
+		const conf = this.app.getConfig();
+		const source = String(this.argument("source", "")).trim();
+		const output = String(this.option("output", conf.outputFormat)).trim().toLowerCase();
+		const shape = String(this.option("shape", conf.outputShape)).trim().toLowerCase();
+		const browser = String(this.option("browser", conf.browser)).trim().toLowerCase();
+		const crawl = this.option("crawl");
+		const baseUrl = String(this.option("baseUrl", "")).trim() || null;
+		const spinner = this.spinner(`${crawl ? "Crawling and p" : "P"}arsing source...`).start();
+		let startedBrowserSession = false;
+		try {
+			const start = Date.now();
+			if (!isSupportedBrowser(browser)) throw new Error(`Unsupported browser: ${browser}`);
+			this.app.configure({ browser });
+			if (crawl) {
+				await startBrowserSession(this.app.getConfig());
+				startedBrowserSession = true;
+			}
+			const operation = extractReadmeOperationFromHtml(await this.app.loadHtmlSource(source, true));
+			const payload = crawl ? await this.app.crawlReadmeOperations(source, operation, baseUrl) : operation;
+			const normalizedPayload = shape === "openapi" ? this.buildOpenApiPayload(payload) : payload;
+			const serialized = output === "js" ? `export default ${JSON.stringify(normalizedPayload, null, 2)}` : JSON.stringify(normalizedPayload, null, output === "json" ? 0 : 2);
+			const filePath = await this.saveOutputToFile(serialized, source, shape, output);
+			const duration = Date.now() - start;
+			_h3ravel_shared.Logger.twoColumnDetail(_h3ravel_shared.Logger.log([["Output", "green"], [`${duration / 1e3}s`, "gray"]], " ", false), filePath.replace(process.cwd(), "."));
+			spinner.succeed("Parsing completed");
+		} catch (error) {
+			const message = error instanceof Error ? error.message : "Unknown error";
+			spinner.fail(`Failed to parse source: ${message}`);
+			process.exitCode = 1;
+		} finally {
+			if (startedBrowserSession) await endBrowserSession();
+		}
+	}
+	buildOpenApiPayload = (payload) => {
+		if ("operations" in payload) return createOpenApiDocumentFromReadmeOperations(payload.operations, "Extracted API", "0.0.0");
+		return createOpenApiDocumentFromReadmeOperations([payload], "Extracted API", "0.0.0");
+	};
+	saveOutputToFile = async (content, source, shape, outputFormat) => {
+		const ext = {
+			pretty: "txt",
+			json: "json",
+			js: "js"
+		}[outputFormat];
+		const outputDir = node_path.default.resolve(process.cwd(), "output");
+		await node_fs_promises.default.mkdir(outputDir, { recursive: true });
+		const filename = `${source.replace(/[^a-zA-Z0-9_-]+/g, "_").replace(/^_+|_+$/g, "") || "output"}${shape === "openapi" ? ".openapi" : ""}.${ext}`;
+		const filePath = node_path.default.join(outputDir, filename);
+		if (outputFormat === "js") content = await prettier.default.format(content, {
+			parser: "babel",
+			semi: false,
+			singleQuote: true
+		});
+		await node_fs_promises.default.writeFile(filePath, content, "utf8");
+		return filePath;
+	};
+};
+
+//#endregion
+//#region src/ConfigLoader.ts
+const CONFIG_BASENAMES = [
+	"openapie.config.ts",
+	"openapie.config.js",
+	"openapie.config.cjs"
+];
+async function loadUserConfig(rootDir = process.cwd()) {
+	for (const basename of CONFIG_BASENAMES) {
+		const configPath = node_path.default.join(rootDir, basename);
+		try {
+			await node_fs_promises.default.access(configPath);
+			const configModule = await import((0, node_url.pathToFileURL)(configPath).href);
+			const config = configModule.default || configModule.config || configModule;
+			if (typeof config === "object" && config !== null) return config;
+		} catch {
+			continue;
+		}
+	}
+	return null;
+}
+async function resolveConfig(cliOverrides = {}) {
+	const userConfig = await loadUserConfig();
+	return {
+		...defaultConfig,
+		...userConfig,
+		...cliOverrides,
+		happyDom: {
+			...defaultConfig.happyDom,
+			...userConfig?.happyDom || {},
+			...cliOverrides.happyDom || {}
+		}
+	};
+}
+
+//#endregion
+exports.Application = Application;
+exports.InitCommand = InitCommand;
+exports.ParseCommand = ParseCommand;
+exports.browser = browser;
+exports.buildOperationId = buildOperationId;
+exports.buildOperationUrl = buildOperationUrl;
+exports.buildRequestBodySchema = buildRequestBodySchema;
+exports.createExampleSchema = createExampleSchema;
+exports.createOpenApiDocumentFromReadmeOperations = createOpenApiDocumentFromReadmeOperations;
+exports.createParameter = createParameter;
+exports.createParameterSchema = createParameterSchema;
+exports.createParameters = createParameters;
+exports.createRequestBody = createRequestBody;
+exports.createResponseContent = createResponseContent;
+exports.createResponses = createResponses;
+exports.decodeOpenApiPathname = decodeOpenApiPathname;
+exports.defaultConfig = defaultConfig;
+exports.defineConfig = defineConfig;
+exports.endBrowserSession = endBrowserSession;
+exports.escapeSelector = escapeSelector;
+exports.extractBalancedSegment = extractBalancedSegment;
+exports.extractButtonText = extractButtonText;
+exports.extractCodeMirrorText = extractCodeMirrorText;
+exports.extractCodeSnippets = extractCodeSnippets;
+exports.extractFetchBody = extractFetchBody;
+exports.extractFetchHeaders = extractFetchHeaders;
+exports.extractObjectPropertyValue = extractObjectPropertyValue;
+exports.extractOperationDescription = extractOperationDescription;
+exports.extractOperationParametersFromOpenApi = extractOperationParametersFromOpenApi;
+exports.extractParameterDescription = extractParameterDescription;
+exports.extractReadmeOperationFromHtml = extractReadmeOperationFromHtml;
+exports.extractReadmeOperationFromSsrProps = extractReadmeOperationFromSsrProps;
+exports.extractRequestCodeSnippets = extractRequestCodeSnippets;
+exports.extractRequestParams = extractRequestParams;
+exports.extractRequestParamsFromOpenApi = extractRequestParamsFromOpenApi;
+exports.extractRequestSnippetLabel = extractRequestSnippetLabel;
+exports.extractResponseBodies = extractResponseBodies;
+exports.extractResponseBodiesFromOpenApi = extractResponseBodiesFromOpenApi;
+exports.extractResponseContentTypes = extractResponseContentTypes;
+exports.extractResponseLabels = extractResponseLabels;
+exports.extractResponseSchemas = extractResponseSchemas;
+exports.extractResponseSchemasFromOpenApi = extractResponseSchemasFromOpenApi;
+exports.extractSidebarLinkLabel = extractSidebarLinkLabel;
+exports.extractSidebarLinks = extractSidebarLinks;
+exports.extractStringLiteralValue = extractStringLiteralValue;
+exports.findParameterRoot = findParameterRoot;
+exports.flattenOpenApiSchemaProperties = flattenOpenApiSchemaProperties;
+exports.getBrowserSession = getBrowserSession;
+Object.defineProperty(exports, 'globalConfig', {
+  enumerable: true,
+  get: function () {
+    return globalConfig;
+  }
+});
+exports.hasExtractedBodyParams = hasExtractedBodyParams;
+exports.inferParameterLocation = inferParameterLocation;
+exports.inferParameterLocationFromText = inferParameterLocationFromText;
+exports.inferParameterPath = inferParameterPath;
+exports.inferParameterType = inferParameterType;
+exports.inferSchemaFromBody = inferSchemaFromBody;
+exports.inferSchemaFromExample = inferSchemaFromExample;
+exports.insertRequestBodyParam = insertRequestBodyParam;
+exports.isOpenApiParameterLocation = isOpenApiParameterLocation;
+exports.isRecord = isRecord;
+exports.isRequiredParameter = isRequiredParameter;
+exports.isSupportedBrowser = isSupportedBrowser;
+exports.loadUserConfig = loadUserConfig;
+exports.mergeOpenApiSchemas = mergeOpenApiSchemas;
+exports.mergeReadmeOperations = mergeReadmeOperations;
+exports.mergeSsrPropsIntoRenderedHtml = mergeSsrPropsIntoRenderedHtml;
+exports.normalizeCurlSnippet = normalizeCurlSnippet;
+exports.normalizeFetchSnippet = normalizeFetchSnippet;
+exports.normalizeRequestCodeSnippet = normalizeRequestCodeSnippet;
+exports.normalizeResponseBody = normalizeResponseBody;
+exports.normalizeStructuredRequestBody = normalizeStructuredRequestBody;
+exports.parseLooseStructuredValue = parseLooseStructuredValue;
+exports.parsePossiblyTruncatedJson = parsePossiblyTruncatedJson;
+exports.readInputValue = readInputValue;
+exports.readText = readText;
+exports.readTexts = readTexts;
+exports.resolveConfig = resolveConfig;
+exports.resolveFallbackRequestBodyExample = resolveFallbackRequestBodyExample;
+exports.resolveOpenApiMediaExample = resolveOpenApiMediaExample;
+exports.resolveParameterInput = resolveParameterInput;
+exports.resolveReadmeSidebarUrls = resolveReadmeSidebarUrls;
+exports.resolveSsrOperation = resolveSsrOperation;
+exports.shouldSkipNormalizedOperation = shouldSkipNormalizedOperation;
+exports.shouldSkipPlaceholderOperation = shouldSkipPlaceholderOperation;
+exports.startBrowserSession = startBrowserSession;
+exports.supportedBrowsers = supportedBrowsers;
+exports.transformReadmeOperationToOpenApi = transformReadmeOperationToOpenApi;