@scalar/workspace-store 0.25.3 → 0.26.1

package/dist/helpers/apply-selective-updates.js

@@ -1,11 +1,21 @@
 import { apply, diff } from "@scalar/json-magic/diff";
 import { split } from "../helpers/general.js";
-const excludeKeys = /* @__PURE__ */ new Set(["x-scalar-navigation", "x-ext", "x-ext-urls", "$status"]);
+const isSecretKey = (key) => key.startsWith("x-scalar-secret-");
+const excludeKeys = /* @__PURE__ */ new Set(["x-scalar-navigation", "x-ext", "x-ext-urls", "$status", "x-scalar-is-dirty"]);
+const filterDiff = (diff2) => {
+  if (diff2.path.some((p) => excludeKeys.has(p))) {
+    return false;
+  }
+  if (isSecretKey(diff2.path.at(-1) ?? "")) {
+    return false;
+  }
+  return true;
+};
 const applySelectiveUpdates = (originalDocument, updatedDocument) => {
   const diffs = diff(originalDocument, updatedDocument);
-  const [writableDiffs, excludedDiffs] = split(diffs, (d) => !d.path.some((p) => excludeKeys.has(p)));
+  const [writableDiffs, excludedDiffs] = split(diffs, filterDiff);
   apply(originalDocument, writableDiffs);
-  return [originalDocument, excludedDiffs];
+  return excludedDiffs;
 };
 export {
   applySelectiveUpdates

package/dist/helpers/apply-selective-updates.js.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../src/helpers/apply-selective-updates.ts"],
-  "sourcesContent": ["import { type Difference, apply, diff } from '@scalar/json-magic/diff'\n\nimport { type UnknownObject, split } from '@/helpers/general'\n\n// Keys to exclude from the diff - these are metadata fields that should not be persisted\n// when applying updates to the original document\nconst excludeKeys = new Set(['x-scalar-navigation', 'x-ext', 'x-ext-urls', '$status'])\n\n/**\n * Applies updates from an updated document to an original document, while excluding changes to certain metadata keys.\n *\n * This function computes the differences between the original and updated documents,\n * filters out any diffs that affect excluded keys (such as navigation, external references, or status fields),\n * and applies only the allowed changes to the original document in place.\n *\n * Note: The originalDocument is mutated directly.\n *\n * @param originalDocument - The document to be updated (mutated in place)\n * @param updatedDocument - The document containing the desired changes\n * @returns A tuple: [the updated original document, array of excluded diffs that were not applied]\n */\nexport const applySelectiveUpdates = (originalDocument: UnknownObject, updatedDocument: UnknownObject) => {\n  const diffs: Difference<unknown>[] = diff(originalDocument, updatedDocument)\n\n  const [writableDiffs, excludedDiffs] = split(diffs, (d) => !d.path.some((p) => excludeKeys.has(p)))\n\n  apply(originalDocument, writableDiffs)\n\n  return [originalDocument, excludedDiffs]\n}\n"],
-  "mappings": "AAAA,SAA0B,OAAO,YAAY;AAE7C,SAA6B,aAAa;AAI1C,MAAM,cAAc,oBAAI,IAAI,CAAC,uBAAuB,SAAS,cAAc,SAAS,CAAC;AAe9E,MAAM,wBAAwB,CAAC,kBAAiC,oBAAmC;AACxG,QAAM,QAA+B,KAAK,kBAAkB,eAAe;AAE3E,QAAM,CAAC,eAAe,aAAa,IAAI,MAAM,OAAO,CAAC,MAAM,CAAC,EAAE,KAAK,KAAK,CAAC,MAAM,YAAY,IAAI,CAAC,CAAC,CAAC;AAElG,QAAM,kBAAkB,aAAa;AAErC,SAAO,CAAC,kBAAkB,aAAa;AACzC;",
-  "names": []
+  "sourcesContent": ["import { type Difference, apply, diff } from '@scalar/json-magic/diff'\n\nimport { type UnknownObject, split } from '@/helpers/general'\n\n/**\n * Checks if a key is a Scalar secret key.\n * Secret keys start with 'x-scalar-secret-' prefix.\n */\nconst isSecretKey = (key: string) => key.startsWith('x-scalar-secret-')\n\n/**\n * Keys to exclude from diffs.\n * These are metadata fields that should be omitted when syncing updates to the original document.\n * Changes to these fields are not persisted.\n */\nconst excludeKeys = new Set(['x-scalar-navigation', 'x-ext', 'x-ext-urls', '$status', 'x-scalar-is-dirty'])\n\n/**\n * Determines whether a diff should be included when applying updates.\n *\n * Returns `true` if the diff does not involve excluded metadata fields\n * (such as navigation or external references) or secret keys.\n * Excluded keys and secret keys are not persisted to the original document.\n */\nconst filterDiff = (diff: Difference<unknown>) => {\n  // Omit diff if its path contains a key we want to exclude from updates\n  if (diff.path.some((p) => excludeKeys.has(p))) {\n    return false\n  }\n\n  // Omit diff if its last path element is a secret key\n  if (isSecretKey(diff.path.at(-1) ?? '')) {\n    return false\n  }\n\n  return true\n}\n\n/**\n * Applies updates from an updated document to an original document, while excluding changes to certain metadata keys.\n *\n * This function computes the differences between the original and updated documents,\n * filters out any diffs that affect excluded keys (such as navigation, external references, or status fields),\n * and applies only the allowed changes to the original document in place.\n *\n * Note: The originalDocument is mutated directly.\n *\n * @param originalDocument - The document to be updated (mutated in place)\n * @param updatedDocument - The document containing the desired changes\n * @returns A tuple: [the updated original document, array of excluded diffs that were not applied]\n */\nexport const applySelectiveUpdates = (originalDocument: UnknownObject, updatedDocument: UnknownObject) => {\n  const diffs: Difference<unknown>[] = diff(originalDocument, updatedDocument)\n\n  const [writableDiffs, excludedDiffs] = split(diffs, filterDiff)\n\n  apply(originalDocument, writableDiffs)\n\n  return excludedDiffs\n}\n"],
+  "mappings": "AAAA,SAA0B,OAAO,YAAY;AAE7C,SAA6B,aAAa;AAM1C,MAAM,cAAc,CAAC,QAAgB,IAAI,WAAW,kBAAkB;AAOtE,MAAM,cAAc,oBAAI,IAAI,CAAC,uBAAuB,SAAS,cAAc,WAAW,mBAAmB,CAAC;AAS1G,MAAM,aAAa,CAACA,UAA8B;AAEhD,MAAIA,MAAK,KAAK,KAAK,CAAC,MAAM,YAAY,IAAI,CAAC,CAAC,GAAG;AAC7C,WAAO;AAAA,EACT;AAGA,MAAI,YAAYA,MAAK,KAAK,GAAG,EAAE,KAAK,EAAE,GAAG;AACvC,WAAO;AAAA,EACT;AAEA,SAAO;AACT;AAeO,MAAM,wBAAwB,CAAC,kBAAiC,oBAAmC;AACxG,QAAM,QAA+B,KAAK,kBAAkB,eAAe;AAE3E,QAAM,CAAC,eAAe,aAAa,IAAI,MAAM,OAAO,UAAU;AAE9D,QAAM,kBAAkB,aAAa;AAErC,SAAO;AACT;",
+  "names": ["diff"]
 }

package/dist/mutators/fetch-request-to-har.d.ts

@@ -0,0 +1,62 @@
+import type { HarRequest } from '@scalar/snippetz';
+type FetchRequestToHarProps = {
+    /** The Fetch API Request object to convert */
+    request: Request;
+    /**
+     * Whether to include the request body in the HAR postData.
+     * Note: Reading the body consumes it, so the request will be cloned automatically.
+     * @default true
+     */
+    includeBody?: boolean;
+    /**
+     * HTTP version string to use (since Fetch API does not expose this)
+     * @default 'HTTP/1.1'
+     */
+    httpVersion?: string;
+    /**
+     * The maximum size of the request body to include in the HAR postData.
+     * @default 1MB
+     */
+    bodySizeLimit?: number;
+};
+/**
+ * Converts a Fetch API Request object to HAR (HTTP Archive) Request format.
+ *
+ * This function transforms a standard JavaScript Fetch API Request into the
+ * HAR format, which is useful for:
+ * - Recording HTTP requests for replay or analysis
+ * - Creating request fixtures from real API calls
+ * - Debugging and monitoring HTTP traffic
+ * - Storing request history in a standard format
+ * - Generating API documentation from real requests
+ *
+ * The conversion handles:
+ * - Request method and URL
+ * - Headers extraction (excluding sensitive headers if needed)
+ * - Query parameters extraction from URL
+ * - Cookie extraction from headers
+ * - Request body reading (with automatic cloning to preserve the original)
+ * - Content-Type detection and MIME type extraction
+ * - Size calculations for headers and body
+ * - Form data bodies are converted to params array
+ * - Other body types are read as text
+ *
+ * Note: The Fetch API does not expose the HTTP version, so it defaults to HTTP/1.1
+ * unless specified otherwise.
+ *
+ * @see https://w3c.github.io/web-performance/specs/HAR/Overview.html
+ * @see https://developer.mozilla.org/en-US/docs/Web/API/Request
+ *
+ * @example
+ * const request = new Request('https://api.example.com/users', {
+ *   method: 'POST',
+ *   headers: { 'Content-Type': 'application/json' },
+ *   body: JSON.stringify({ name: 'John' })
+ * })
+ * const harRequest = await fetchRequestToHar({ request })
+ * console.log(harRequest.method) // 'POST'
+ * console.log(harRequest.postData?.text) // '{"name":"John"}'
+ */
+export declare const fetchRequestToHar: ({ request, includeBody, httpVersion, bodySizeLimit, }: FetchRequestToHarProps) => Promise<HarRequest>;
+export {};
+//# sourceMappingURL=fetch-request-to-har.d.ts.map

package/dist/mutators/fetch-request-to-har.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fetch-request-to-har.d.ts","sourceRoot":"","sources":["../../src/mutators/fetch-request-to-har.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAA;AAElD,KAAK,sBAAsB,GAAG;IAC5B,8CAA8C;IAC9C,OAAO,EAAE,OAAO,CAAA;IAChB;;;;OAIG;IACH,WAAW,CAAC,EAAE,OAAO,CAAA;IACrB;;;OAGG;IACH,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB;;;OAGG;IACH,aAAa,CAAC,EAAE,MAAM,CAAA;CACvB,CAAA;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AACH,eAAO,MAAM,iBAAiB,GAAU,uDAMrC,sBAAsB,KAAG,OAAO,CAAC,UAAU,CA+C7C,CAAA"}

package/dist/mutators/fetch-request-to-har.js

@@ -0,0 +1,117 @@
+const fetchRequestToHar = async ({
+  request,
+  includeBody = true,
+  httpVersion = "HTTP/1.1",
+  // Default to 1MB
+  bodySizeLimit = 1048576
+}) => {
+  const url = new URL(request.url);
+  const queryString = Array.from(url.searchParams.entries()).map(([name, value]) => ({ name, value }));
+  const { headers, headersSize, cookies } = processRequestHeaders(request);
+  const mimeType = request.headers.get("content-type")?.split(";")[0]?.trim() ?? "text/plain";
+  const bodyDetails = await (async () => {
+    if (includeBody && request.body) {
+      const details = await processRequestBody(request.clone());
+      if (details.size <= bodySizeLimit) {
+        return details;
+      }
+    }
+    return { text: "", size: -1 };
+  })();
+  const harRequest = {
+    method: request.method,
+    url: request.url,
+    httpVersion,
+    headers,
+    cookies,
+    queryString,
+    headersSize,
+    bodySize: bodyDetails.size,
+    postData: "params" in bodyDetails ? {
+      mimeType,
+      params: bodyDetails.params
+    } : {
+      mimeType,
+      text: bodyDetails.text
+    }
+  };
+  return harRequest;
+};
+const processRequestBody = async (request) => {
+  const formData = await tryGetRequestFormData(request.clone());
+  if (formData) {
+    return Array.from(formData.entries()).reduce(
+      (acc, [name, value]) => {
+        if (value instanceof File) {
+          const fileName = `@${value.name}`;
+          acc.params.push({ name, value: fileName });
+          acc.size += fileName.length;
+          return acc;
+        }
+        acc.params.push({ name, value });
+        acc.size += value.length;
+        return acc;
+      },
+      { params: [], size: 0 }
+    );
+  }
+  if (request.headers.get("content-type")?.includes("application/octet-stream")) {
+    return { text: "", size: -1 };
+  }
+  const arrayBuffer = await request.arrayBuffer();
+  const size = arrayBuffer.byteLength;
+  return { size, text: new TextDecoder().decode(arrayBuffer) };
+};
+async function tryGetRequestFormData(request) {
+  if (typeof request.formData !== "function") {
+    return null;
+  }
+  if (request.bodyUsed) {
+    return null;
+  }
+  const contentType = request.headers.get("content-type") ?? "";
+  if (!contentType.includes("multipart/form-data") && !contentType.includes("application/x-www-form-urlencoded")) {
+    return null;
+  }
+  try {
+    return await request.formData();
+  } catch {
+    return null;
+  }
+}
+const processRequestHeaders = (request) => {
+  return Array.from(request.headers.entries()).reduce(
+    (acc, [name, value]) => {
+      if (name.toLowerCase() === "cookie") {
+        const parsedCookies = parseCookieHeader(value);
+        acc.cookies.push(...parsedCookies.cookies);
+      } else {
+        acc.headers.push({ name, value });
+        acc.headersSize += name.length + 2 + value.length + 2;
+      }
+      return acc;
+    },
+    { headers: [], headersSize: 0, cookies: [] }
+  );
+};
+const parseCookieHeader = (cookieValue) => {
+  return cookieValue.split(";").reduce(
+    (acc, part) => {
+      const trimmedPart = part.trim();
+      const equalIndex = trimmedPart.indexOf("=");
+      if (equalIndex === -1) {
+        return acc;
+      }
+      const name = trimmedPart.substring(0, equalIndex).trim();
+      const value = trimmedPart.substring(equalIndex + 1).trim();
+      acc.cookies.push({ name, value });
+      acc.size += name.length + 2 + value.length + 2;
+      return acc;
+    },
+    { cookies: [], size: 0 }
+  );
+};
+export {
+  fetchRequestToHar
+};
+//# sourceMappingURL=fetch-request-to-har.js.map

package/dist/mutators/fetch-request-to-har.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/mutators/fetch-request-to-har.ts"],
+  "sourcesContent": ["import type { HarRequest } from '@scalar/snippetz'\n\ntype FetchRequestToHarProps = {\n  /** The Fetch API Request object to convert */\n  request: Request\n  /**\n   * Whether to include the request body in the HAR postData.\n   * Note: Reading the body consumes it, so the request will be cloned automatically.\n   * @default true\n   */\n  includeBody?: boolean\n  /**\n   * HTTP version string to use (since Fetch API does not expose this)\n   * @default 'HTTP/1.1'\n   */\n  httpVersion?: string\n  /**\n   * The maximum size of the request body to include in the HAR postData.\n   * @default 1MB\n   */\n  bodySizeLimit?: number\n}\n\n/**\n * Converts a Fetch API Request object to HAR (HTTP Archive) Request format.\n *\n * This function transforms a standard JavaScript Fetch API Request into the\n * HAR format, which is useful for:\n * - Recording HTTP requests for replay or analysis\n * - Creating request fixtures from real API calls\n * - Debugging and monitoring HTTP traffic\n * - Storing request history in a standard format\n * - Generating API documentation from real requests\n *\n * The conversion handles:\n * - Request method and URL\n * - Headers extraction (excluding sensitive headers if needed)\n * - Query parameters extraction from URL\n * - Cookie extraction from headers\n * - Request body reading (with automatic cloning to preserve the original)\n * - Content-Type detection and MIME type extraction\n * - Size calculations for headers and body\n * - Form data bodies are converted to params array\n * - Other body types are read as text\n *\n * Note: The Fetch API does not expose the HTTP version, so it defaults to HTTP/1.1\n * unless specified otherwise.\n *\n * @see https://w3c.github.io/web-performance/specs/HAR/Overview.html\n * @see https://developer.mozilla.org/en-US/docs/Web/API/Request\n *\n * @example\n * const request = new Request('https://api.example.com/users', {\n *   method: 'POST',\n *   headers: { 'Content-Type': 'application/json' },\n *   body: JSON.stringify({ name: 'John' })\n * })\n * const harRequest = await fetchRequestToHar({ request })\n * console.log(harRequest.method) // 'POST'\n * console.log(harRequest.postData?.text) // '{\"name\":\"John\"}'\n */\nexport const fetchRequestToHar = async ({\n  request,\n  includeBody = true,\n  httpVersion = 'HTTP/1.1',\n  // Default to 1MB\n  bodySizeLimit = 1048576,\n}: FetchRequestToHarProps): Promise<HarRequest> => {\n  // Extract query string from URL\n  const url = new URL(request.url)\n\n  // Extract the query strings from the URL\n  const queryString = Array.from(url.searchParams.entries()).map(([name, value]) => ({ name, value }))\n\n  // Extract the headers from the request\n  const { headers, headersSize, cookies } = processRequestHeaders(request)\n\n  // Extract the MIME type from the request headers\n  const mimeType = request.headers.get('content-type')?.split(';')[0]?.trim() ?? 'text/plain'\n\n  // Read the request body if requested\n  const bodyDetails = await (async () => {\n    if (includeBody && request.body) {\n      const details = await processRequestBody(request.clone())\n      if (details.size <= bodySizeLimit) {\n        return details\n      }\n    }\n    return { text: '', size: -1 }\n  })()\n\n  // Create the HAR request object\n  const harRequest: HarRequest = {\n    method: request.method,\n    url: request.url,\n    httpVersion,\n    headers,\n    cookies,\n    queryString,\n    headersSize,\n    bodySize: bodyDetails.size,\n    postData:\n      'params' in bodyDetails\n        ? {\n            mimeType,\n            params: bodyDetails.params,\n          }\n        : {\n            mimeType,\n            text: bodyDetails.text,\n          },\n  }\n\n  return harRequest\n}\n\nconst processRequestBody = async (request: Request) => {\n  const formData = await tryGetRequestFormData(request.clone())\n  if (formData) {\n    return Array.from(formData.entries()).reduce<{ params: { name: string; value: string }[]; size: number }>(\n      (acc, [name, value]) => {\n        if (value instanceof File) {\n          const fileName = `@${value.name}`\n          acc.params.push({ name, value: fileName })\n          acc.size += fileName.length\n          return acc\n        }\n\n        acc.params.push({ name, value })\n        acc.size += value.length\n        return acc\n      },\n      { params: [], size: 0 },\n    )\n  }\n  // Skip binary bodies\n  if (request.headers.get('content-type')?.includes('application/octet-stream')) {\n    return { text: '', size: -1 }\n  }\n\n  // Read the request body as text\n  const arrayBuffer = await request.arrayBuffer()\n  const size = arrayBuffer.byteLength\n  return { size, text: new TextDecoder().decode(arrayBuffer) }\n}\n\nasync function tryGetRequestFormData(request: Request): Promise<FormData | null> {\n  if (typeof request.formData !== 'function') {\n    return null\n  }\n\n  if (request.bodyUsed) {\n    return null\n  }\n\n  const contentType = request.headers.get('content-type') ?? ''\n  if (!contentType.includes('multipart/form-data') && !contentType.includes('application/x-www-form-urlencoded')) {\n    return null\n  }\n\n  try {\n    return await request.formData()\n  } catch {\n    return null\n  }\n}\n\nconst processRequestHeaders = (request: Request) => {\n  return Array.from(request.headers.entries()).reduce<{\n    headers: { name: string; value: string }[]\n    headersSize: number\n    cookies: { name: string; value: string }[]\n  }>(\n    (acc, [name, value]) => {\n      if (name.toLowerCase() === 'cookie') {\n        const parsedCookies = parseCookieHeader(value)\n        acc.cookies.push(...parsedCookies.cookies)\n      } else {\n        acc.headers.push({ name, value })\n        acc.headersSize += name.length + 2 + value.length + 2\n      }\n      return acc\n    },\n    { headers: [], headersSize: 0, cookies: [] },\n  )\n}\n\n/**\n * Parses a Cookie header value into an array of cookie objects.\n * Cookie format: name1=value1; name2=value2\n */\nconst parseCookieHeader = (cookieValue: string) => {\n  return cookieValue.split(';').reduce<{ cookies: { name: string; value: string }[]; size: number }>(\n    (acc, part) => {\n      const trimmedPart = part.trim()\n      const equalIndex = trimmedPart.indexOf('=')\n\n      if (equalIndex === -1) {\n        return acc\n      }\n\n      const name = trimmedPart.substring(0, equalIndex).trim()\n      const value = trimmedPart.substring(equalIndex + 1).trim()\n\n      acc.cookies.push({ name, value })\n      acc.size += name.length + 2 + value.length + 2\n      return acc\n    },\n    { cookies: [], size: 0 },\n  )\n}\n"],
+  "mappings": "AA6DO,MAAM,oBAAoB,OAAO;AAAA,EACtC;AAAA,EACA,cAAc;AAAA,EACd,cAAc;AAAA;AAAA,EAEd,gBAAgB;AAClB,MAAmD;AAEjD,QAAM,MAAM,IAAI,IAAI,QAAQ,GAAG;AAG/B,QAAM,cAAc,MAAM,KAAK,IAAI,aAAa,QAAQ,CAAC,EAAE,IAAI,CAAC,CAAC,MAAM,KAAK,OAAO,EAAE,MAAM,MAAM,EAAE;AAGnG,QAAM,EAAE,SAAS,aAAa,QAAQ,IAAI,sBAAsB,OAAO;AAGvE,QAAM,WAAW,QAAQ,QAAQ,IAAI,cAAc,GAAG,MAAM,GAAG,EAAE,CAAC,GAAG,KAAK,KAAK;AAG/E,QAAM,cAAc,OAAO,YAAY;AACrC,QAAI,eAAe,QAAQ,MAAM;AAC/B,YAAM,UAAU,MAAM,mBAAmB,QAAQ,MAAM,CAAC;AACxD,UAAI,QAAQ,QAAQ,eAAe;AACjC,eAAO;AAAA,MACT;AAAA,IACF;AACA,WAAO,EAAE,MAAM,IAAI,MAAM,GAAG;AAAA,EAC9B,GAAG;AAGH,QAAM,aAAyB;AAAA,IAC7B,QAAQ,QAAQ;AAAA,IAChB,KAAK,QAAQ;AAAA,IACb;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA,UAAU,YAAY;AAAA,IACtB,UACE,YAAY,cACR;AAAA,MACE;AAAA,MACA,QAAQ,YAAY;AAAA,IACtB,IACA;AAAA,MACE;AAAA,MACA,MAAM,YAAY;AAAA,IACpB;AAAA,EACR;AAEA,SAAO;AACT;AAEA,MAAM,qBAAqB,OAAO,YAAqB;AACrD,QAAM,WAAW,MAAM,sBAAsB,QAAQ,MAAM,CAAC;AAC5D,MAAI,UAAU;AACZ,WAAO,MAAM,KAAK,SAAS,QAAQ,CAAC,EAAE;AAAA,MACpC,CAAC,KAAK,CAAC,MAAM,KAAK,MAAM;AACtB,YAAI,iBAAiB,MAAM;AACzB,gBAAM,WAAW,IAAI,MAAM,IAAI;AAC/B,cAAI,OAAO,KAAK,EAAE,MAAM,OAAO,SAAS,CAAC;AACzC,cAAI,QAAQ,SAAS;AACrB,iBAAO;AAAA,QACT;AAEA,YAAI,OAAO,KAAK,EAAE,MAAM,MAAM,CAAC;AAC/B,YAAI,QAAQ,MAAM;AAClB,eAAO;AAAA,MACT;AAAA,MACA,EAAE,QAAQ,CAAC,GAAG,MAAM,EAAE;AAAA,IACxB;AAAA,EACF;AAEA,MAAI,QAAQ,QAAQ,IAAI,cAAc,GAAG,SAAS,0BAA0B,GAAG;AAC7E,WAAO,EAAE,MAAM,IAAI,MAAM,GAAG;AAAA,EAC9B;AAGA,QAAM,cAAc,MAAM,QAAQ,YAAY;AAC9C,QAAM,OAAO,YAAY;AACzB,SAAO,EAAE,MAAM,MAAM,IAAI,YAAY,EAAE,OAAO,WAAW,EAAE;AAC7D;AAEA,eAAe,sBAAsB,SAA4C;AAC/E,MAAI,OAAO,QAAQ,aAAa,YAAY;AAC1C,WAAO;AAAA,EACT;AAEA,MAAI,QAAQ,UAAU;AACpB,WAAO;AAAA,EACT;AAEA,QAAM,cAAc,QAAQ,QAAQ,IAAI,cAAc,KAAK;AAC3D,MAAI,CAAC,YAAY,SAAS,qBAAqB,KAAK,CAAC,YAAY,SAAS,mCAAmC,GAAG;AAC9G,WAAO;AAAA,EACT;AAEA,MAAI;AACF,WAAO,MAAM,QAAQ,SAAS;AAAA,EAChC,QAAQ;AACN,WAAO;AAAA,EACT;AACF;AAEA,MAAM,wBAAwB,CAAC,YAAqB;AAClD,SAAO,MAAM,KAAK,QAAQ,QAAQ,QAAQ,CAAC,EAAE;AAAA,IAK3C,CAAC,KAAK,CAAC,MAAM,KAAK,MAAM;AACtB,UAAI,KAAK,YAAY,MAAM,UAAU;AACnC,cAAM,gBAAgB,kBAAkB,KAAK;AAC7C,YAAI,QAAQ,KAAK,GAAG,cAAc,OAAO;AAAA,MAC3C,OAAO;AACL,YAAI,QAAQ,KAAK,EAAE,MAAM,MAAM,CAAC;AAChC,YAAI,eAAe,KAAK,SAAS,IAAI,MAAM,SAAS;AAAA,MACtD;AACA,aAAO;AAAA,IACT;AAAA,IACA,EAAE,SAAS,CAAC,GAAG,aAAa,GAAG,SAAS,CAAC,EAAE;AAAA,EAC7C;AACF;AAMA,MAAM,oBAAoB,CAAC,gBAAwB;AACjD,SAAO,YAAY,MAAM,GAAG,EAAE;AAAA,IAC5B,CAAC,KAAK,SAAS;AACb,YAAM,cAAc,KAAK,KAAK;AAC9B,YAAM,aAAa,YAAY,QAAQ,GAAG;AAE1C,UAAI,eAAe,IAAI;AACrB,eAAO;AAAA,MACT;AAEA,YAAM,OAAO,YAAY,UAAU,GAAG,UAAU,EAAE,KAAK;AACvD,YAAM,QAAQ,YAAY,UAAU,aAAa,CAAC,EAAE,KAAK;AAEzD,UAAI,QAAQ,KAAK,EAAE,MAAM,MAAM,CAAC;AAChC,UAAI,QAAQ,KAAK,SAAS,IAAI,MAAM,SAAS;AAC7C,aAAO;AAAA,IACT;AAAA,IACA,EAAE,SAAS,CAAC,GAAG,MAAM,EAAE;AAAA,EACzB;AACF;",
+  "names": []
+}

package/dist/mutators/fetch-response-to-har.d.ts

@@ -0,0 +1,67 @@
+import type { HarResponse } from '@scalar/snippetz';
+type FetchResponseToHarProps = {
+    /** The Fetch API Response object to convert */
+    response: Response;
+    /**
+     * Whether to include the response body in the HAR content.
+     * Note: Reading the body consumes it, so the response will be cloned automatically.
+     * Bodies will only be included if they meet the following criteria:
+     * - Not a streaming response (text/event-stream)
+     * - Text-based content (not binary)
+     * - Under 1MB in size
+     * @default true
+     */
+    includeBody?: boolean;
+    /**
+     * HTTP version string to use (since Fetch API does not expose this)
+     * @default 'HTTP/1.1'
+     */
+    httpVersion?: string;
+    /**
+     * The maximum size of the response body to include in the HAR content.
+     * @default 1MB
+     */
+    bodySizeLimit?: number;
+};
+/**
+ * Converts a Fetch API Response object to HAR (HTTP Archive) Response format.
+ *
+ * This function transforms a standard JavaScript Fetch API Response into the
+ * HAR format, which is useful for:
+ * - Recording HTTP responses for replay or analysis
+ * - Creating test fixtures from real API responses
+ * - Debugging and monitoring HTTP traffic
+ * - Generating API documentation from real responses
+ *
+ * The conversion handles:
+ * - Response status and status text
+ * - Headers extraction (including Set-Cookie headers converted to cookies)
+ * - Response body reading (with automatic cloning to preserve the original)
+ * - Content-Type detection and MIME type extraction
+ * - Size calculations for headers and body
+ * - Redirect URL extraction from Location header
+ *
+ * Note: The Fetch API does not expose the HTTP version, so it defaults to HTTP/1.1
+ * unless specified otherwise.
+ *
+ * @see https://w3c.github.io/web-performance/specs/HAR/Overview.html
+ * @see https://developer.mozilla.org/en-US/docs/Web/API/Response
+ *
+ * @example
+ * const response = await fetch('https://api.example.com/users')
+ * const harResponse = await fetchResponseToHar({ response })
+ * console.log(harResponse.status) // 200
+ */
+export declare const fetchResponseToHar: ({ response, includeBody, httpVersion, bodySizeLimit, }: FetchResponseToHarProps) => Promise<HarResponse>;
+/**
+ * Checks if the content type is text-based and should be included in HAR.
+ * Text-based content types include:
+ * - text/* (text/plain, text/html, text/css, etc.)
+ * - application/json
+ * - application/xml and text/xml
+ * - application/javascript
+ * - application/*+json and application/*+xml variants
+ */
+export declare const isTextBasedContent: (contentType: string) => boolean;
+export {};
+//# sourceMappingURL=fetch-response-to-har.d.ts.map

package/dist/mutators/fetch-response-to-har.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fetch-response-to-har.d.ts","sourceRoot":"","sources":["../../src/mutators/fetch-response-to-har.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAA;AAEnD,KAAK,uBAAuB,GAAG;IAC7B,+CAA+C;IAC/C,QAAQ,EAAE,QAAQ,CAAA;IAClB;;;;;;;;OAQG;IACH,WAAW,CAAC,EAAE,OAAO,CAAA;IACrB;;;OAGG;IACH,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB;;;OAGG;IACH,aAAa,CAAC,EAAE,MAAM,CAAA;CACvB,CAAA;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,eAAO,MAAM,kBAAkB,GAAU,wDAKtC,uBAAuB,KAAG,OAAO,CAAC,WAAW,CAwC/C,CAAA;AA4CD;;;;;;;;GAQG;AACH,eAAO,MAAM,kBAAkB,GAAI,aAAa,MAAM,KAAG,OAoCxD,CAAA"}

package/dist/mutators/fetch-response-to-har.js

@@ -0,0 +1,104 @@
+const fetchResponseToHar = async ({
+  response,
+  includeBody = true,
+  httpVersion = "HTTP/1.1",
+  bodySizeLimit = 1048576
+}) => {
+  const { headers, headersSize, cookies } = processResponseHeaders(response);
+  const redirectURL = response.headers.get("location") || "";
+  const contentType = response.headers.get("content-type") ?? "text/plain";
+  const bodyDetails = await (async () => {
+    if (includeBody && response.body) {
+      const details = await processResponseBody(response.clone());
+      if (details.size <= bodySizeLimit) {
+        return details;
+      }
+    }
+    return { text: "", size: -1, encoding: void 0 };
+  })();
+  const harResponse = {
+    status: response.status,
+    statusText: response.statusText,
+    httpVersion,
+    headers,
+    cookies,
+    content: {
+      size: bodyDetails.size,
+      mimeType: contentType,
+      text: bodyDetails.text,
+      encoding: bodyDetails.encoding
+    },
+    redirectURL,
+    headersSize,
+    bodySize: bodyDetails.size
+  };
+  return harResponse;
+};
+const processResponseHeaders = (response) => {
+  return Array.from(response.headers.entries()).reduce(
+    (acc, [name, value]) => {
+      acc.headers.push({ name, value });
+      acc.headersSize += name.length + 2 + value.length + 2;
+      if (name.toLowerCase() === "set-cookie") {
+        const cookie = parseSetCookieHeader(value);
+        if (cookie) {
+          acc.cookies.push(cookie);
+        }
+      }
+      return acc;
+    },
+    { headers: [], headersSize: 0, cookies: [] }
+  );
+};
+const processResponseBody = async (response) => {
+  const contentType = response.headers.get("content-type");
+  if (!contentType || !isTextBasedContent(contentType)) {
+    return { text: "", size: -1, encoding: void 0 };
+  }
+  try {
+    const arrayBuffer = await response.arrayBuffer();
+    const bodySize = arrayBuffer.byteLength;
+    const text = new TextDecoder("utf-8").decode(arrayBuffer);
+    return { text, size: bodySize, encoding: void 0 };
+  } catch {
+    return { text: "", size: -1, encoding: void 0 };
+  }
+};
+const isTextBasedContent = (contentType) => {
+  const lowerContentType = contentType.toLowerCase();
+  if (lowerContentType.startsWith("text/")) {
+    return true;
+  }
+  if (lowerContentType.includes("application/json") || lowerContentType.includes("+json")) {
+    return true;
+  }
+  if (lowerContentType.includes("application/xml") || lowerContentType.includes("text/xml") || lowerContentType.includes("+xml")) {
+    return true;
+  }
+  if (lowerContentType.includes("application/javascript") || lowerContentType.includes("application/x-javascript")) {
+    return true;
+  }
+  if (lowerContentType.includes("application/x-www-form-urlencoded") || lowerContentType.includes("application/graphql")) {
+    return true;
+  }
+  return false;
+};
+const parseSetCookieHeader = (setCookieValue) => {
+  const parts = setCookieValue.split(";");
+  if (parts.length === 0 || !parts[0]) {
+    return null;
+  }
+  const cookiePart = parts[0].trim();
+  const equalIndex = cookiePart.indexOf("=");
+  if (equalIndex === -1) {
+    return null;
+  }
+  const name = cookiePart.substring(0, equalIndex).trim();
+  const value = cookiePart.substring(equalIndex + 1).trim();
+  return { name, value };
+};
+export {
+  fetchResponseToHar,
+  isTextBasedContent
+};
+//# sourceMappingURL=fetch-response-to-har.js.map

package/dist/mutators/fetch-response-to-har.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/mutators/fetch-response-to-har.ts"],
+  "sourcesContent": ["import type { HarResponse } from '@scalar/snippetz'\n\ntype FetchResponseToHarProps = {\n  /** The Fetch API Response object to convert */\n  response: Response\n  /**\n   * Whether to include the response body in the HAR content.\n   * Note: Reading the body consumes it, so the response will be cloned automatically.\n   * Bodies will only be included if they meet the following criteria:\n   * - Not a streaming response (text/event-stream)\n   * - Text-based content (not binary)\n   * - Under 1MB in size\n   * @default true\n   */\n  includeBody?: boolean\n  /**\n   * HTTP version string to use (since Fetch API does not expose this)\n   * @default 'HTTP/1.1'\n   */\n  httpVersion?: string\n  /**\n   * The maximum size of the response body to include in the HAR content.\n   * @default 1MB\n   */\n  bodySizeLimit?: number\n}\n\n/**\n * Converts a Fetch API Response object to HAR (HTTP Archive) Response format.\n *\n * This function transforms a standard JavaScript Fetch API Response into the\n * HAR format, which is useful for:\n * - Recording HTTP responses for replay or analysis\n * - Creating test fixtures from real API responses\n * - Debugging and monitoring HTTP traffic\n * - Generating API documentation from real responses\n *\n * The conversion handles:\n * - Response status and status text\n * - Headers extraction (including Set-Cookie headers converted to cookies)\n * - Response body reading (with automatic cloning to preserve the original)\n * - Content-Type detection and MIME type extraction\n * - Size calculations for headers and body\n * - Redirect URL extraction from Location header\n *\n * Note: The Fetch API does not expose the HTTP version, so it defaults to HTTP/1.1\n * unless specified otherwise.\n *\n * @see https://w3c.github.io/web-performance/specs/HAR/Overview.html\n * @see https://developer.mozilla.org/en-US/docs/Web/API/Response\n *\n * @example\n * const response = await fetch('https://api.example.com/users')\n * const harResponse = await fetchResponseToHar({ response })\n * console.log(harResponse.status) // 200\n */\nexport const fetchResponseToHar = async ({\n  response,\n  includeBody = true,\n  httpVersion = 'HTTP/1.1',\n  bodySizeLimit = 1048576,\n}: FetchResponseToHarProps): Promise<HarResponse> => {\n  // Extract the headers from the response\n  const { headers, headersSize, cookies } = processResponseHeaders(response)\n\n  // Extract redirect URL from Location header\n  const redirectURL = response.headers.get('location') || ''\n\n  // Get content type\n  const contentType = response.headers.get('content-type') ?? 'text/plain'\n\n  // Read the response body if requested\n  const bodyDetails = await (async () => {\n    if (includeBody && response.body) {\n      const details = await processResponseBody(response.clone())\n      if (details.size <= bodySizeLimit) {\n        return details\n      }\n    }\n    return { text: '', size: -1, encoding: undefined }\n  })()\n\n  // Create the HAR response object\n  const harResponse: HarResponse = {\n    status: response.status,\n    statusText: response.statusText,\n    httpVersion,\n    headers,\n    cookies,\n    content: {\n      size: bodyDetails.size,\n      mimeType: contentType,\n      text: bodyDetails.text,\n      encoding: bodyDetails.encoding,\n    },\n    redirectURL,\n    headersSize,\n    bodySize: bodyDetails.size,\n  }\n\n  return harResponse\n}\n\nconst processResponseHeaders = (response: Response) => {\n  return Array.from(response.headers.entries()).reduce<{\n    headers: { name: string; value: string }[]\n    headersSize: number\n    cookies: { name: string; value: string }[]\n  }>(\n    (acc, [name, value]) => {\n      acc.headers.push({ name, value })\n      acc.headersSize += name.length + 2 + value.length + 2\n\n      // Parse Set-Cookie headers into cookies array\n      if (name.toLowerCase() === 'set-cookie') {\n        const cookie = parseSetCookieHeader(value)\n        if (cookie) {\n          acc.cookies.push(cookie)\n        }\n      }\n\n      return acc\n    },\n    { headers: [], headersSize: 0, cookies: [] },\n  )\n}\n\nconst processResponseBody = async (response: Response) => {\n  const contentType = response.headers.get('content-type')\n  if (!contentType || !isTextBasedContent(contentType)) {\n    return { text: '', size: -1, encoding: undefined }\n  }\n\n  try {\n    // Read as ArrayBuffer to get the size\n    const arrayBuffer = await response.arrayBuffer()\n    const bodySize = arrayBuffer.byteLength\n    const text = new TextDecoder('utf-8').decode(arrayBuffer)\n    return { text, size: bodySize, encoding: undefined }\n  } catch {\n    // If body cannot be read, leave it empty\n    return { text: '', size: -1, encoding: undefined }\n  }\n}\n\n/**\n * Checks if the content type is text-based and should be included in HAR.\n * Text-based content types include:\n * - text/* (text/plain, text/html, text/css, etc.)\n * - application/json\n * - application/xml and text/xml\n * - application/javascript\n * - application/*+json and application/*+xml variants\n */\nexport const isTextBasedContent = (contentType: string): boolean => {\n  const lowerContentType = contentType.toLowerCase()\n\n  // Check for text/* types\n  if (lowerContentType.startsWith('text/')) {\n    return true\n  }\n\n  // Check for JSON types\n  if (lowerContentType.includes('application/json') || lowerContentType.includes('+json')) {\n    return true\n  }\n\n  // Check for XML types\n  if (\n    lowerContentType.includes('application/xml') ||\n    lowerContentType.includes('text/xml') ||\n    lowerContentType.includes('+xml')\n  ) {\n    return true\n  }\n\n  // Check for JavaScript\n  if (lowerContentType.includes('application/javascript') || lowerContentType.includes('application/x-javascript')) {\n    return true\n  }\n\n  // Check for common text-based formats\n  if (\n    lowerContentType.includes('application/x-www-form-urlencoded') ||\n    lowerContentType.includes('application/graphql')\n  ) {\n    return true\n  }\n\n  return false\n}\n\n/**\n * Parses a Set-Cookie header value into a cookie object.\n * This is a simplified parser that extracts the name and value.\n * For full cookie parsing with attributes, a more robust parser would be needed.\n */\nconst parseSetCookieHeader = (setCookieValue: string): { name: string; value: string } | null => {\n  // Set-Cookie format: name=value; attribute1=value1; attribute2=value2\n  const parts = setCookieValue.split(';')\n  if (parts.length === 0 || !parts[0]) {\n    return null\n  }\n\n  const cookiePart = parts[0].trim()\n  const equalIndex = cookiePart.indexOf('=')\n\n  if (equalIndex === -1) {\n    return null\n  }\n\n  const name = cookiePart.substring(0, equalIndex).trim()\n  const value = cookiePart.substring(equalIndex + 1).trim()\n\n  return { name, value }\n}\n"],
+  "mappings": "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",
+  "names": []
+}

package/dist/mutators/har-to-operation.d.ts

@@ -0,0 +1,37 @@
+import type { HarRequest } from '@scalar/snippetz';
+import type { OperationObject } from '@scalar/workspace-store/schemas/v3.1/strict/openapi-document';
+type HarToOperationProps = {
+    /** HAR request to convert */
+    harRequest: HarRequest;
+    /** Name of the example to populate (e.g., 'default', 'example1') */
+    exampleKey: string;
+    /** Optional base operation to merge with */
+    baseOperation?: OperationObject;
+    /** Optional path variables to merge with */
+    pathVariables?: Record<string, string>;
+};
+/**
+ * Converts a HAR request back to an OpenAPI Operation object with populated examples.
+ *
+ * This function is the reverse of operationToHar - it takes a HAR request and
+ * converts it back into an OpenAPI operation structure, populating the example
+ * values based on the HAR request data.
+ *
+ * The conversion handles:
+ * - URL parsing to extract path and query parameters
+ * - Header extraction and mapping to operation parameters
+ * - Query string parsing and mapping to parameters
+ * - Cookie extraction and mapping to cookie parameters
+ * - Request body extraction and mapping to requestBody with examples
+ * - Content-Type detection and media type assignment
+ *
+ * Note: This function focuses on populating examples and does not reconstruct
+ * schema definitions. If you need full schema generation, consider combining
+ * this with a schema inference tool.
+ *
+ * @see https://w3c.github.io/web-performance/specs/HAR/Overview.html
+ * @see https://spec.openapis.org/oas/v3.1.0#operation-object
+ */
+export declare const harToOperation: ({ harRequest, exampleKey, baseOperation, pathVariables, }: HarToOperationProps) => OperationObject;
+export {};
+//# sourceMappingURL=har-to-operation.d.ts.map

package/dist/mutators/har-to-operation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"har-to-operation.d.ts","sourceRoot":"","sources":["../../src/mutators/har-to-operation.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAA;AAElD,OAAO,KAAK,EAAE,eAAe,EAAmB,MAAM,8DAA8D,CAAA;AAKpH,KAAK,mBAAmB,GAAG;IACzB,6BAA6B;IAC7B,UAAU,EAAE,UAAU,CAAA;IACtB,oEAAoE;IACpE,UAAU,EAAE,MAAM,CAAA;IAClB,4CAA4C;IAC5C,aAAa,CAAC,EAAE,eAAe,CAAA;IAC/B,4CAA4C;IAC5C,aAAa,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;CACvC,CAAA;AAyBD;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,eAAO,MAAM,cAAc,GAAI,2DAK5B,mBAAmB,KAAG,eAyHxB,CAAA"}

package/dist/mutators/har-to-operation.js

@@ -0,0 +1,146 @@
+import { getResolvedRef } from "@scalar/workspace-store/helpers/get-resolved-ref";
+import { isContentTypeParameterObject } from "../schemas/v3.1/strict/type-guards.js";
+const preprocessParameters = (parameters, pathVariables, exampleKey) => {
+  parameters.forEach((param) => {
+    const resolvedParam = getResolvedRef(param);
+    if (isContentTypeParameterObject(resolvedParam)) {
+      return;
+    }
+    setParameterDisabled(getResolvedRef(param), exampleKey, true);
+    if (resolvedParam.in === "path") {
+      resolvedParam.examples ||= {};
+      resolvedParam.examples[exampleKey] = {
+        value: pathVariables[resolvedParam.name] ?? "",
+        "x-disabled": false
+      };
+    }
+  });
+};
+const harToOperation = ({
+  harRequest,
+  exampleKey,
+  baseOperation = {},
+  pathVariables = {}
+}) => {
+  if (!baseOperation.parameters) {
+    baseOperation.parameters = [];
+  }
+  preprocessParameters(baseOperation.parameters, pathVariables, exampleKey);
+  if (harRequest.queryString && harRequest.queryString.length > 0) {
+    for (const queryParam of harRequest.queryString) {
+      const param = findOrCreateParameter(baseOperation.parameters, queryParam.name, "query");
+      if (!param || isContentTypeParameterObject(param)) {
+        continue;
+      }
+      param.examples ||= {};
+      param.examples[exampleKey] = {
+        value: queryParam.value,
+        "x-disabled": false
+      };
+    }
+  }
+  if (harRequest.headers && harRequest.headers.length > 0) {
+    for (const header of harRequest.headers) {
+      const param = findOrCreateParameter(baseOperation.parameters, header.name, "header");
+      if (!param || isContentTypeParameterObject(param)) {
+        continue;
+      }
+      param.examples ||= {};
+      param.examples[exampleKey] = {
+        value: header.value,
+        "x-disabled": false
+      };
+    }
+  }
+  if (harRequest.cookies && harRequest.cookies.length > 0) {
+    for (const cookie of harRequest.cookies) {
+      const param = findOrCreateParameter(baseOperation.parameters, cookie.name, "cookie");
+      if (!param || isContentTypeParameterObject(param)) {
+        continue;
+      }
+      param.examples ||= {};
+      param.examples[exampleKey] = {
+        value: cookie.value,
+        "x-disabled": false
+      };
+    }
+  }
+  if (harRequest.postData) {
+    const { mimeType, text, params } = harRequest.postData;
+    if (!baseOperation.requestBody) {
+      baseOperation.requestBody = {
+        content: {}
+      };
+    }
+    const requestBody = getResolvedRef(baseOperation.requestBody);
+    if (!requestBody.content[mimeType]) {
+      requestBody.content[mimeType] = {
+        schema: {
+          type: "object"
+        }
+      };
+    }
+    const mediaType = requestBody.content[mimeType];
+    if (!mediaType) {
+      return baseOperation;
+    }
+    mediaType.examples ||= {};
+    let exampleValue;
+    if (params && params.length > 0) {
+      exampleValue = [];
+      for (const param of params) {
+        exampleValue.push({
+          name: param.name,
+          value: param.value,
+          "x-disabled": false
+        });
+      }
+    } else {
+      exampleValue = text;
+    }
+    mediaType.examples[exampleKey] = {
+      value: exampleValue,
+      "x-disabled": false
+    };
+    requestBody["x-scalar-selected-content-type"] ||= {};
+    requestBody["x-scalar-selected-content-type"][exampleKey] = mimeType;
+  }
+  return baseOperation;
+};
+const setParameterDisabled = (param, exampleKey, disabled) => {
+  if (isContentTypeParameterObject(param)) {
+    return;
+  }
+  if (!param.examples?.[exampleKey]) {
+    return;
+  }
+  getResolvedRef(param.examples[exampleKey])["x-disabled"] = disabled;
+};
+const findOrCreateParameter = (parameters, name, inValue) => {
+  for (const param of parameters) {
+    const resolved = getResolvedRef(param);
+    if (isContentTypeParameterObject(resolved)) {
+      continue;
+    }
+    if (resolved.in !== inValue) {
+      continue;
+    }
+    const namesMatch = inValue === "header" ? resolved.name.toLowerCase() === name.toLowerCase() : resolved.name === name;
+    if (namesMatch) {
+      return resolved;
+    }
+  }
+  const newParam = {
+    name,
+    in: inValue,
+    schema: {
+      type: "string"
+    }
+  };
+  parameters.push(newParam);
+  return newParam;
+};
+export {
+  harToOperation
+};
+//# sourceMappingURL=har-to-operation.js.map