@redocly/cli 0.0.0-snapshot.1784620262 → 0.0.0-snapshot.1784895845

package/THIRD_PARTY_NOTICES

@@ -4,7 +4,7 @@ Third-party software bundled in @redocly/cli
 (MPL-2.0 OR Apache-2.0)
 
 Packages:
-  dompurify@3.4.11 — copyright owner or entity authorized by
+  dompurify@3.4.12 — copyright owner or entity authorized by
 
 License text:
 
@@ -574,7 +574,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 BSD-3-Clause
 
 Packages:
-  fast-uri@3.1.2 — Copyright (c) 2011-2021, Gary Court until https://github.com/garycourt/uri-js/commit/a1acf730b4bba3f1097c9f52e7d9d3aba8cdcaae
+  fast-uri@3.1.4 — Copyright (c) 2011-2021, Gary Court until https://github.com/garycourt/uri-js/commit/a1acf730b4bba3f1097c9f52e7d9d3aba8cdcaae
   source-map@0.6.1 — Copyright (c) 2009-2011, Mozilla Foundation and contributors
 
 License text:
@@ -649,14 +649,14 @@ Packages:
   @redocly/ajv@8.18.3 — Copyright (c) 2015-2021 Evgeny Poberezkin
   @redocly/cli-otel@0.3.4 — Copyright 2025 Redocly Inc, all rights reserved.
   @redocly/config@0.22.0 — Copyright 2024 Redocly Inc.
-  @redocly/config@0.51.0 — Copyright 2024 Redocly Inc.
-  @redocly/openapi-core@1.34.16
+  @redocly/config@0.52.0 — Copyright 2024 Redocly Inc.
+  @redocly/openapi-core@1.34.17
   agent-base@7.1.4 — Copyright (c) 2013 Nathan Rajlich <nathan@tootallnate.net>
   ajv-formats@3.0.1 — Copyright (c) 2020 Evgeny Poberezkin
   ajv@8.20.0 — Copyright (c) 2015-2021 Evgeny Poberezkin
   ansi-styles@4.3.0
   balanced-match@1.0.2 — Copyright (c) 2013 Julian Gruber &lt;julian@juliangruber.com&gt;
-  brace-expansion@2.1.1 — Copyright (c) 2013 Julian Gruber <julian@juliangruber.com>
+  brace-expansion@2.1.2 — Copyright (c) 2013 Julian Gruber <julian@juliangruber.com>
   call-me-maybe@1.0.2 — Copyright (c) 2015 Eric McCarthy
   chalk@4.1.2
   classnames@2.5.1 — Copyright (c) 2018 Jed Watson
@@ -679,6 +679,7 @@ Packages:
   js-levenshtein@1.1.6 — Copyright (c) 2017 Gustaf Andersson
   js-tokens@4.0.0 — Copyright (c) 2014, 2015, 2016, 2017, 2018 Simon Lydell
   js-yaml@4.2.0 — Copyright (C) 2011-2015 by Vitaly Puzrin
+  js-yaml@5.2.1 — Copyright (C) 2011-2015 by Vitaly Puzrin
   json-pointer@0.6.2 — Copyright (c) 2016 Manuel Stofer
   json-schema-traverse@1.0.0 — Copyright (c) 2017 Evgeny Poberezkin
   jsonpointer@5.0.1 — Copyright (c) 2011-2015 Jan Lehnardt <jan@apache.org> & Marc Bachmann <https://github.com/marcbachmann>

package/lib/chunks/2RSMENOK.js

@@ -0,0 +1,496 @@
+import { createRequire as __createRequire } from 'node:module';
+import { fileURLToPath as __fileURLToPath } from 'node:url';
+import { dirname as __pathDirname } from 'node:path';
+const require = __createRequire(import.meta.url);
+var __filename = __fileURLToPath(import.meta.url);
+var __dirname = __pathDirname(__filename);
+import {
+  isPlainObject
+} from "./KO5RGRSI.js";
+
+// src/commands/drift/utils/files.ts
+import { open, readdir, stat } from "node:fs/promises";
+import path from "node:path";
+var SPEC_FILE_EXTENSIONS = /* @__PURE__ */ new Set([".yaml", ".yml", ".json"]);
+async function listOpenApiFiles(rootDir) {
+  const output = [];
+  async function walk(currentDir) {
+    const entries = await readdir(currentDir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (entry.name.startsWith(".")) {
+        continue;
+      }
+      const absolutePath = path.join(currentDir, entry.name);
+      if (entry.isDirectory()) {
+        await walk(absolutePath);
+        continue;
+      }
+      if (entry.isFile() && SPEC_FILE_EXTENSIONS.has(path.extname(entry.name).toLowerCase())) {
+        output.push(absolutePath);
+      }
+    }
+  }
+  await walk(rootDir);
+  output.sort();
+  return output;
+}
+async function readProbe(filePath, maxBytes = 4096) {
+  const fileHandle = await open(filePath, "r");
+  try {
+    const buffer = Buffer.allocUnsafe(maxBytes);
+    const { bytesRead } = await fileHandle.read(buffer, 0, maxBytes, 0);
+    return buffer.toString("utf8", 0, bytesRead);
+  } finally {
+    await fileHandle.close();
+  }
+}
+function normalizeFsPath(value) {
+  return path.resolve(process.cwd(), value);
+}
+async function listFilesRecursively(rootPath) {
+  const stats = await stat(rootPath);
+  if (stats.isFile()) {
+    return [rootPath];
+  }
+  if (!stats.isDirectory()) {
+    return [];
+  }
+  const output = [];
+  async function walk(currentDir) {
+    const entries = await readdir(currentDir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (entry.name.startsWith(".")) {
+        continue;
+      }
+      const absolutePath = path.join(currentDir, entry.name);
+      if (entry.isDirectory()) {
+        await walk(absolutePath);
+        continue;
+      }
+      if (entry.isFile()) {
+        output.push(absolutePath);
+      }
+    }
+  }
+  await walk(rootPath);
+  output.sort();
+  return output;
+}
+
+// src/commands/drift/utils/http.ts
+var DUMMY_HOST = "drift.local";
+var DUMMY_BASE_URL = `http://${DUMMY_HOST}`;
+function isSyntheticHost(host) {
+  return host === DUMMY_HOST;
+}
+var IGNORED_UNDOCUMENTED_HEADERS = /* @__PURE__ */ new Set([
+  "accept",
+  "accept-charset",
+  "accept-encoding",
+  "accept-language",
+  "authorization",
+  "baggage",
+  "cache-control",
+  "cdn-loop",
+  "cookie",
+  "connection",
+  "content-length",
+  "content-type",
+  "dpr",
+  "dnt",
+  "downlink",
+  "ect",
+  "forwarded",
+  "host",
+  "if-match",
+  "if-modified-since",
+  "if-none-match",
+  "if-range",
+  "if-unmodified-since",
+  "origin",
+  "pragma",
+  "priority",
+  "range",
+  "referer",
+  "sec-fetch-dest",
+  "sec-fetch-mode",
+  "sec-fetch-site",
+  "sec-fetch-user",
+  "sec-gpc",
+  "sentry-trace",
+  "te",
+  "traceparent",
+  "tracestate",
+  "upgrade",
+  "upgrade-insecure-requests",
+  "user-agent",
+  "via",
+  "x-amzn-trace-id",
+  "x-client-trace-id",
+  "x-cloud-trace-context",
+  "x-correlation-id",
+  "x-http-method-override",
+  "x-method-override",
+  "x-real-ip",
+  "x-request-id",
+  "x-forwarded-for",
+  "x-forwarded-host",
+  "x-forwarded-port",
+  "x-forwarded-proto"
+]);
+var IGNORED_UNDOCUMENTED_HEADER_PREFIXES = [
+  "cf-",
+  "sec-ch-",
+  "sec-fetch-",
+  "x-b3-",
+  "x-envoy-",
+  "x-forwarded-"
+];
+var SET_COOKIE_SEPARATOR = "\n";
+function splitSetCookieHeader(value) {
+  return value.split(SET_COOKIE_SEPARATOR);
+}
+function appendHeaderValue(result, name, value) {
+  const key = name.toLowerCase();
+  const existing = result[key];
+  if (existing === void 0) {
+    result[key] = value;
+    return;
+  }
+  result[key] = key === "set-cookie" ? `${existing}${SET_COOKIE_SEPARATOR}${value}` : `${existing},${value}`;
+}
+function normalizeHeaders(input) {
+  if (!isPlainObject(input) && !Array.isArray(input)) {
+    return {};
+  }
+  const result = {};
+  if (Array.isArray(input)) {
+    for (const item of input) {
+      if (!isPlainObject(item)) {
+        continue;
+      }
+      const { name, value } = item;
+      if (typeof name === "string" && value !== void 0) {
+        appendHeaderValue(result, name, String(value));
+      }
+    }
+    return result;
+  }
+  for (const [key, value] of Object.entries(input)) {
+    if (value === void 0 || value === null) {
+      continue;
+    }
+    if (Array.isArray(value)) {
+      for (const item of value) {
+        appendHeaderValue(result, key, String(item));
+      }
+      continue;
+    }
+    appendHeaderValue(result, key, String(value));
+  }
+  return result;
+}
+function parseUrl(input) {
+  try {
+    return new URL(input);
+  } catch {
+    return new URL(input, DUMMY_BASE_URL);
+  }
+}
+function getPathWithoutTrailingSlash(pathname) {
+  if (pathname.length > 1 && pathname.endsWith("/")) {
+    return pathname.slice(0, -1);
+  }
+  return pathname;
+}
+function escapeRegex(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function compileOpenApiPath(pathTemplate) {
+  const params = [];
+  let score = 0;
+  const absolutePath = pathTemplate.startsWith("/") ? pathTemplate : `/${pathTemplate}`;
+  const normalizedPath = getPathWithoutTrailingSlash(absolutePath);
+  const regexBody = normalizedPath.split("/").map((segment) => {
+    if (!segment) {
+      return "";
+    }
+    const paramMatch = segment.match(/^\{([^}]+)\}$/);
+    if (paramMatch) {
+      params.push(paramMatch[1]);
+      return "([^/]+)";
+    }
+    score += 2;
+    return escapeRegex(segment);
+  }).join("/");
+  return {
+    regex: new RegExp(`^${regexBody || "/"}$`),
+    params,
+    score
+  };
+}
+function parseJsonBodyIfPresent(contentType, bodyText) {
+  if (!bodyText) {
+    return void 0;
+  }
+  if (!isJsonMime(contentType)) {
+    return void 0;
+  }
+  try {
+    return JSON.parse(bodyText);
+  } catch {
+    return void 0;
+  }
+}
+function normalizeContentType(contentType) {
+  if (!contentType) {
+    return "";
+  }
+  return contentType.split(";")[0]?.trim().toLowerCase() ?? "";
+}
+function isJsonMime(contentType) {
+  const mime = normalizeContentType(contentType);
+  return mime === "application/json" || mime.endsWith("+json");
+}
+function pickSchemaByMime(contentMap, contentType) {
+  const requestedMime = normalizeContentType(contentType);
+  if (!requestedMime) {
+    return contentMap["application/json"] ?? contentMap["*/*"];
+  }
+  if (contentMap[requestedMime] !== void 0) {
+    return contentMap[requestedMime];
+  }
+  const [type, subtype] = requestedMime.split("/");
+  if (type && subtype) {
+    const wildcardSubtype = `${type}/*`;
+    if (contentMap[wildcardSubtype] !== void 0) {
+      return contentMap[wildcardSubtype];
+    }
+  }
+  return contentMap["*/*"];
+}
+function parseHeaderIgnoreList(patterns) {
+  const names = /* @__PURE__ */ new Set();
+  const prefixes = [];
+  for (const pattern of patterns) {
+    const normalized = pattern.trim().toLowerCase();
+    if (normalized.length === 0) {
+      continue;
+    }
+    if (normalized.endsWith("*")) {
+      prefixes.push(normalized.slice(0, -1));
+    } else {
+      names.add(normalized);
+    }
+  }
+  return { names, prefixes };
+}
+function shouldIgnoreHeaderAsUndocumented(headerName, extraIgnored) {
+  const normalizedHeaderName = headerName.toLowerCase();
+  if (normalizedHeaderName.startsWith(":")) {
+    return true;
+  }
+  if (IGNORED_UNDOCUMENTED_HEADERS.has(normalizedHeaderName) || IGNORED_UNDOCUMENTED_HEADER_PREFIXES.some((prefix) => normalizedHeaderName.startsWith(prefix))) {
+    return true;
+  }
+  if (extraIgnored) {
+    return extraIgnored.names.has(normalizedHeaderName) || extraIgnored.prefixes.some((prefix) => normalizedHeaderName.startsWith(prefix));
+  }
+  return false;
+}
+
+// src/commands/drift/log-formats/helpers.ts
+import { createReadStream } from "node:fs";
+import { readFile } from "node:fs/promises";
+import { createInterface } from "node:readline";
+function coerceString(value) {
+  if (value === void 0 || value === null) {
+    return void 0;
+  }
+  if (typeof value === "string") {
+    return value;
+  }
+  if (Buffer.isBuffer(value)) {
+    return value.toString("utf8");
+  }
+  if (isPlainObject(value) || Array.isArray(value)) {
+    try {
+      return JSON.stringify(value);
+    } catch {
+      return String(value);
+    }
+  }
+  return String(value);
+}
+function coerceNumber(value) {
+  if (typeof value === "number" && Number.isFinite(value)) {
+    return value;
+  }
+  if (typeof value === "string" && value.trim() !== "") {
+    const parsed = Number(value);
+    if (Number.isFinite(parsed)) {
+      return parsed;
+    }
+  }
+  return void 0;
+}
+function decodeBody(value, encoding) {
+  if (value === void 0 || value === null) {
+    return void 0;
+  }
+  if (encoding === "base64" && typeof value === "string") {
+    try {
+      return Buffer.from(value, "base64").toString("utf8");
+    } catch {
+      return value;
+    }
+  }
+  return coerceString(value);
+}
+function createNormalizedExchange(seed, index, source) {
+  const method = seed.method?.toUpperCase();
+  const url = seed.url;
+  if (!method || !url) {
+    return null;
+  }
+  const requestHeaders = normalizeHeaders(seed.requestHeaders);
+  let parsedUrl = parseUrl(url);
+  if (isSyntheticHost(parsedUrl.host) && requestHeaders.host) {
+    try {
+      parsedUrl = new URL(
+        `${parsedUrl.protocol}//${requestHeaders.host}${parsedUrl.pathname}${parsedUrl.search}`
+      );
+    } catch {
+      parsedUrl = parseUrl(url);
+    }
+  }
+  const requestContentType = seed.requestContentType ?? requestHeaders["content-type"];
+  const requestBodyText = decodeBody(seed.requestBody);
+  const request = {
+    method,
+    url: parsedUrl.toString(),
+    path: parsedUrl.pathname,
+    query: parsedUrl.searchParams,
+    protocol: parsedUrl.protocol,
+    protocolKnown: seed.schemeKnown ?? /^https?:\/\//i.test(url),
+    host: isSyntheticHost(parsedUrl.host) ? void 0 : parsedUrl.host || void 0,
+    headers: requestHeaders,
+    contentType: requestContentType,
+    bodyText: requestBodyText,
+    bodyJson: parseJsonBodyIfPresent(requestContentType, requestBodyText)
+  };
+  let response;
+  const responseStatus = seed.responseStatus;
+  if (responseStatus !== void 0) {
+    const responseHeaders = normalizeHeaders(seed.responseHeaders);
+    const responseContentType = seed.responseContentType ?? responseHeaders["content-type"];
+    const responseBodyText = decodeBody(seed.responseBody);
+    response = {
+      status: responseStatus,
+      statusText: seed.responseStatusText,
+      headers: responseHeaders,
+      contentType: responseContentType,
+      bodyText: responseBodyText,
+      bodyJson: parseJsonBodyIfPresent(responseContentType, responseBodyText)
+    };
+  }
+  return {
+    index,
+    source,
+    startedAt: seed.startedAt,
+    request,
+    response,
+    raw: seed.raw
+  };
+}
+async function* streamNdjsonObjects(filePath) {
+  const readStream = createReadStream(filePath, { encoding: "utf8" });
+  const reader = createInterface({ input: readStream, crlfDelay: Infinity });
+  for await (const line of reader) {
+    const trimmed = line.trim();
+    if (!trimmed) {
+      continue;
+    }
+    try {
+      const parsed = JSON.parse(trimmed);
+      if (isPlainObject(parsed)) {
+        yield parsed;
+      }
+    } catch {
+    }
+  }
+}
+async function* iterateJsonArray(filePath, arrayPath) {
+  const content = await readFile(filePath, "utf8");
+  let value = JSON.parse(content);
+  if (arrayPath) {
+    for (const key of arrayPath.split(".")) {
+      value = isPlainObject(value) ? value[key] : void 0;
+    }
+  }
+  if (Array.isArray(value)) {
+    for (const item of value) {
+      if (isPlainObject(item)) {
+        yield item;
+      }
+    }
+  }
+}
+function pickHeaderContentType(headers) {
+  const normalized = normalizeHeaders(headers);
+  return normalized["content-type"];
+}
+
+// src/commands/drift/utils/server.ts
+function normalizeServerPrefix(server) {
+  const trimmed = server?.replace(/\/+$/, "");
+  return trimmed || void 0;
+}
+function stripPrefixFromPath(pathname, prefixPath) {
+  if (!prefixPath || prefixPath === "/") {
+    return pathname || "/";
+  }
+  if (pathname === prefixPath) {
+    return "/";
+  }
+  if (!pathname.startsWith(`${prefixPath}/`)) {
+    return void 0;
+  }
+  return pathname.slice(prefixPath.length) || "/";
+}
+function resolvePathForServer(request, server) {
+  if (server.startsWith("/")) {
+    return stripPrefixFromPath(request.path, server);
+  }
+  const serverUrl = parseUrl(server.includes("://") ? server : `http://${server}`);
+  if (isSyntheticHost(serverUrl.host) || request.host !== void 0 && request.host.toLowerCase() !== serverUrl.host) {
+    return void 0;
+  }
+  return stripPrefixFromPath(request.path, getPathWithoutTrailingSlash(serverUrl.pathname));
+}
+
+export {
+  listOpenApiFiles,
+  readProbe,
+  normalizeFsPath,
+  listFilesRecursively,
+  isSyntheticHost,
+  splitSetCookieHeader,
+  parseUrl,
+  getPathWithoutTrailingSlash,
+  compileOpenApiPath,
+  normalizeContentType,
+  isJsonMime,
+  pickSchemaByMime,
+  parseHeaderIgnoreList,
+  shouldIgnoreHeaderAsUndocumented,
+  coerceString,
+  coerceNumber,
+  decodeBody,
+  createNormalizedExchange,
+  streamNdjsonObjects,
+  iterateJsonArray,
+  pickHeaderContentType,
+  normalizeServerPrefix,
+  resolvePathForServer
+};

package/lib/chunks/{IRDDR6ZX.js → 3WU5KDKV.js}

@@ -12,7 +12,7 @@ import {
 } from "./JPNXFCZJ.js";
 import {
   version
-} from "./U5H3NDWA.js";
+} from "./NWE2GATL.js";
 import {
   require_undici
 } from "./QRC5ADSZ.js";
@@ -20,7 +20,7 @@ import {
   blue,
   green,
   logger
-} from "./HD24VMMU.js";
+} from "./KO5RGRSI.js";
 import {
   __toESM
 } from "./YDPUXTSG.js";

package/lib/chunks/{UWZRCAHF.js → 67FKMJUU.js}

@@ -6,7 +6,7 @@ var __filename = __fileURLToPath(import.meta.url);
 var __dirname = __pathDirname(__filename);
 import {
   HandledError
-} from "./HD24VMMU.js";
+} from "./KO5RGRSI.js";
 
 // src/utils/error.ts
 var AbortFlowError = class extends Error {