@scalar/oas-utils 0.2.140 → 0.2.142

package/dist/helpers/redirect-to-proxy.js

@@ -1,92 +1,55 @@
-import { isLocalUrl } from './is-local-url.js';
-import { REGEX } from './regex-helpers.js';
-
-/**
- * Redirects the request to a proxy server with a given URL. But not for:
- *
- * - Relative URLs
- * - URLs that seem to point to a local IP (except the proxy is on the same domain)
- * - URLs that don’t look like a domain
- **/
+import { isLocalUrl } from "./is-local-url.js";
+import { REGEX } from "./regex-helpers.js";
 function redirectToProxy(proxyUrl, url) {
-    try {
-        if (!shouldUseProxy(proxyUrl, url)) {
-            console.log('should not use proxy', proxyUrl, url);
-            return url ?? '';
-        }
-        // Create new URL object from url
-        const newUrl = new URL(url);
-        // Add temporary domain for relative proxy URLs
-        //
-        // Q: Why isn’t proxyUrl type guarded?
-        // A: Type guarding works for one parameter only (as of now).
-        //
-        // Q: Why do we need to add http://localhost to relative proxy URLs?
-        // A: Because the `new URL()` would otherwise fail.
-        //
-        const temporaryProxyUrl = isRelativePath(proxyUrl) ? `http://localhost${proxyUrl}` : proxyUrl;
-        // Rewrite the URL with the proxy
-        newUrl.href = temporaryProxyUrl;
-        // Add the original URL as a query parameter
-        newUrl.searchParams.append('scalar_url', url);
-        // Remove the temporary domain if we added it, but only from the start of the URL
-        const result = isRelativePath(proxyUrl)
-            ? newUrl.toString().replace(/^http:\/\/localhost/, '')
-            : newUrl.toString();
-        return result;
-    }
-    catch {
-        return url ?? '';
+  try {
+    if (!shouldUseProxy(proxyUrl, url)) {
+      console.log("should not use proxy", proxyUrl, url);
+      return url ?? "";
     }
+    const newUrl = new URL(url);
+    const temporaryProxyUrl = isRelativePath(proxyUrl) ? `http://localhost${proxyUrl}` : proxyUrl;
+    newUrl.href = temporaryProxyUrl;
+    newUrl.searchParams.append("scalar_url", url);
+    const result = isRelativePath(proxyUrl) ? newUrl.toString().replace(/^http:\/\/localhost/, "") : newUrl.toString();
+    return result;
+  } catch {
+    return url ?? "";
+  }
 }
-/**
- * Check if the URL is relative or if it's a domain without protocol
- **/
 const isRelativePath = (url) => {
-    // Allow http:// https:// and other protocols such as file://
-    if (REGEX.PROTOCOL.test(url)) {
-        return false;
-    }
-    // Check if it looks like a domain (contains dots and no spaces)
-    // This catches cases like "galaxy.scalar.com/planets"
-    if (/^[a-zA-Z0-9-]+\.[a-zA-Z0-9-.]+(\/|$)/.test(url)) {
-        return false;
-    }
-    return true;
+  if (REGEX.PROTOCOL.test(url)) {
+    return false;
+  }
+  if (/^[a-zA-Z0-9-]+\.[a-zA-Z0-9-.]+(\/|$)/.test(url)) {
+    return false;
+  }
+  return true;
 };
-/**
- * Returns false for requests to localhost, relative URLs, if no proxy is defined …
- **/
 function shouldUseProxy(proxyUrl, url) {
-    try {
-        // ❌ We don’t have a proxy URL or the URL
-        if (!proxyUrl || !url) {
-            return false;
-        }
-        // ❌ Request to relative URLs (won’t be blocked by CORS anyway)
-        if (isRelativePath(url)) {
-            return false;
-        }
-        // ✅ Proxy URL is on the same domain (e.g. /proxy)
-        // It’s more likely (not guaranteed, though) that the proxy has access to local domains.
-        if (isRelativePath(proxyUrl)) {
-            return true;
-        }
-        // ✅ Proxy URL is local
-        if (isLocalUrl(proxyUrl)) {
-            return true;
-        }
-        // ❌ Requests to localhost
-        // We won’t reach them from a (likely remote) proxy.
-        if (isLocalUrl(url)) {
-            return false;
-        }
-        // ✅ Seems fine (e.g. remote proxy + remote URL)
-        return true;
+  try {
+    if (!proxyUrl || !url) {
+      return false;
+    }
+    if (isRelativePath(url)) {
+      return false;
     }
-    catch {
-        return false;
+    if (isRelativePath(proxyUrl)) {
+      return true;
     }
+    if (isLocalUrl(proxyUrl)) {
+      return true;
+    }
+    if (isLocalUrl(url)) {
+      return false;
+    }
+    return true;
+  } catch {
+    return false;
+  }
 }
-
-export { isRelativePath, redirectToProxy, shouldUseProxy };
+export {
+  isRelativePath,
+  redirectToProxy,
+  shouldUseProxy
+};
+//# sourceMappingURL=redirect-to-proxy.js.map

package/dist/helpers/redirect-to-proxy.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/helpers/redirect-to-proxy.ts"],
+  "sourcesContent": ["import { isLocalUrl } from './is-local-url'\nimport { REGEX } from './regex-helpers'\n\n/**\n * Redirects the request to a proxy server with a given URL. But not for:\n *\n * - Relative URLs\n * - URLs that seem to point to a local IP (except the proxy is on the same domain)\n * - URLs that don\u2019t look like a domain\n **/\nexport function redirectToProxy(proxyUrl?: string, url?: string): string {\n  try {\n    if (!shouldUseProxy(proxyUrl, url)) {\n      console.log('should not use proxy', proxyUrl, url)\n      return url ?? ''\n    }\n\n    // Create new URL object from url\n    const newUrl = new URL(url)\n\n    // Add temporary domain for relative proxy URLs\n    //\n    // Q: Why isn\u2019t proxyUrl type guarded?\n    // A: Type guarding works for one parameter only (as of now).\n    //\n    // Q: Why do we need to add http://localhost to relative proxy URLs?\n    // A: Because the `new URL()` would otherwise fail.\n    //\n    const temporaryProxyUrl = isRelativePath(proxyUrl as string) ? `http://localhost${proxyUrl}` : (proxyUrl as string)\n\n    // Rewrite the URL with the proxy\n    newUrl.href = temporaryProxyUrl\n\n    // Add the original URL as a query parameter\n    newUrl.searchParams.append('scalar_url', url)\n\n    // Remove the temporary domain if we added it, but only from the start of the URL\n    const result = isRelativePath(proxyUrl as string)\n      ? newUrl.toString().replace(/^http:\\/\\/localhost/, '')\n      : newUrl.toString()\n\n    return result\n  } catch {\n    return url ?? ''\n  }\n}\n\n/**\n * Check if the URL is relative or if it's a domain without protocol\n **/\nexport const isRelativePath = (url: string) => {\n  // Allow http:// https:// and other protocols such as file://\n  if (REGEX.PROTOCOL.test(url)) {\n    return false\n  }\n\n  // Check if it looks like a domain (contains dots and no spaces)\n  // This catches cases like \"galaxy.scalar.com/planets\"\n  if (/^[a-zA-Z0-9-]+\\.[a-zA-Z0-9-.]+(\\/|$)/.test(url)) {\n    return false\n  }\n\n  return true\n}\n\n/**\n * Returns false for requests to localhost, relative URLs, if no proxy is defined \u2026\n **/\nexport function shouldUseProxy(proxyUrl?: string, url?: string): url is string {\n  try {\n    // \u274C We don\u2019t have a proxy URL or the URL\n    if (!proxyUrl || !url) {\n      return false\n    }\n\n    // \u274C Request to relative URLs (won\u2019t be blocked by CORS anyway)\n    if (isRelativePath(url)) {\n      return false\n    }\n\n    // \u2705 Proxy URL is on the same domain (e.g. /proxy)\n    // It\u2019s more likely (not guaranteed, though) that the proxy has access to local domains.\n    if (isRelativePath(proxyUrl)) {\n      return true\n    }\n\n    // \u2705 Proxy URL is local\n    if (isLocalUrl(proxyUrl)) {\n      return true\n    }\n\n    // \u274C Requests to localhost\n    // We won\u2019t reach them from a (likely remote) proxy.\n    if (isLocalUrl(url)) {\n      return false\n    }\n\n    // \u2705 Seems fine (e.g. remote proxy + remote URL)\n    return true\n  } catch {\n    return false\n  }\n}\n"],
+  "mappings": "AAAA,SAAS,kBAAkB;AAC3B,SAAS,aAAa;AASf,SAAS,gBAAgB,UAAmB,KAAsB;AACvE,MAAI;AACF,QAAI,CAAC,eAAe,UAAU,GAAG,GAAG;AAClC,cAAQ,IAAI,wBAAwB,UAAU,GAAG;AACjD,aAAO,OAAO;AAAA,IAChB;AAGA,UAAM,SAAS,IAAI,IAAI,GAAG;AAU1B,UAAM,oBAAoB,eAAe,QAAkB,IAAI,mBAAmB,QAAQ,KAAM;AAGhG,WAAO,OAAO;AAGd,WAAO,aAAa,OAAO,cAAc,GAAG;AAG5C,UAAM,SAAS,eAAe,QAAkB,IAC5C,OAAO,SAAS,EAAE,QAAQ,uBAAuB,EAAE,IACnD,OAAO,SAAS;AAEpB,WAAO;AAAA,EACT,QAAQ;AACN,WAAO,OAAO;AAAA,EAChB;AACF;AAKO,MAAM,iBAAiB,CAAC,QAAgB;AAE7C,MAAI,MAAM,SAAS,KAAK,GAAG,GAAG;AAC5B,WAAO;AAAA,EACT;AAIA,MAAI,uCAAuC,KAAK,GAAG,GAAG;AACpD,WAAO;AAAA,EACT;AAEA,SAAO;AACT;AAKO,SAAS,eAAe,UAAmB,KAA6B;AAC7E,MAAI;AAEF,QAAI,CAAC,YAAY,CAAC,KAAK;AACrB,aAAO;AAAA,IACT;AAGA,QAAI,eAAe,GAAG,GAAG;AACvB,aAAO;AAAA,IACT;AAIA,QAAI,eAAe,QAAQ,GAAG;AAC5B,aAAO;AAAA,IACT;AAGA,QAAI,WAAW,QAAQ,GAAG;AACxB,aAAO;AAAA,IACT;AAIA,QAAI,WAAW,GAAG,GAAG;AACnB,aAAO;AAAA,IACT;AAGA,WAAO;AAAA,EACT,QAAQ;AACN,WAAO;AAAA,EACT;AACF;",
+  "names": []
+}

package/dist/helpers/redirect-to-proxy.test.js

@@ -0,0 +1,54 @@
+import { describe, expect, it } from "vitest";
+import { isRelativePath, redirectToProxy } from "./redirect-to-proxy.js";
+describe("redirectToProxy", () => {
+  it("rewrites URLs", () => {
+    expect(redirectToProxy("https://proxy.scalar.com", "https://example.com")).toBe(
+      "https://proxy.scalar.com/?scalar_url=https%3A%2F%2Fexample.com"
+    );
+  });
+  it("keeps query parameters", () => {
+    expect(redirectToProxy("https://proxy.scalar.com?foo=bar", "https://example.com")).toBe(
+      "https://proxy.scalar.com/?foo=bar&scalar_url=https%3A%2F%2Fexample.com"
+    );
+  });
+  it("uses the proxy when the proxyUrl is relative", () => {
+    expect(redirectToProxy("/proxy", "http://localhost:3000/api")).toBe(
+      "/proxy?scalar_url=http%3A%2F%2Flocalhost%3A3000%2Fapi"
+    );
+  });
+  it("skips the proxy if no proxy url is passed", () => {
+    expect(redirectToProxy("", "https://example.com")).toBe("https://example.com");
+  });
+  it("skips the proxy for relative URLs starting with a slash", () => {
+    expect(redirectToProxy("https://proxy.scalar.com", "/api")).toBe("/api");
+  });
+  it("skips the proxy for relative URLs not starting with a slash", () => {
+    expect(redirectToProxy("https://proxy.scalar.com", "api")).toBe("api");
+  });
+  it("skips the proxy for relative URLs not starting with a slash, but containing a dot", () => {
+    expect(redirectToProxy("https://proxy.scalar.com", "openapi.json")).toBe("openapi.json");
+  });
+  it("uses the proxy when it\u2019s local", () => {
+    expect(redirectToProxy("http://localhost:3000/proxy", "http://localhost:3000/api")).toBe(
+      "http://localhost:3000/proxy?scalar_url=http%3A%2F%2Flocalhost%3A3000%2Fapi"
+    );
+  });
+});
+describe("isRelativePath", () => {
+  it("returns true for relative paths starting with a slash", () => {
+    expect(isRelativePath("/api")).toBe(true);
+  });
+  it("returns true for relative paths without a slash", () => {
+    expect(isRelativePath("api")).toBe(true);
+  });
+  it("returns false for absolute URLs with http", () => {
+    expect(isRelativePath("http://example.com")).toBe(false);
+  });
+  it("returns false for absolute URLs with https", () => {
+    expect(isRelativePath("https://example.com")).toBe(false);
+  });
+  it("returns false for domain-like URLs without protocol", () => {
+    expect(isRelativePath("example.com/api")).toBe(false);
+  });
+});
+//# sourceMappingURL=redirect-to-proxy.test.js.map

package/dist/helpers/redirect-to-proxy.test.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/helpers/redirect-to-proxy.test.ts"],
+  "sourcesContent": ["import { describe, expect, it } from 'vitest'\n\nimport { isRelativePath, redirectToProxy } from './redirect-to-proxy'\n\ndescribe('redirectToProxy', () => {\n  it('rewrites URLs', () => {\n    expect(redirectToProxy('https://proxy.scalar.com', 'https://example.com')).toBe(\n      'https://proxy.scalar.com/?scalar_url=https%3A%2F%2Fexample.com',\n    )\n  })\n\n  it('keeps query parameters', () => {\n    expect(redirectToProxy('https://proxy.scalar.com?foo=bar', 'https://example.com')).toBe(\n      'https://proxy.scalar.com/?foo=bar&scalar_url=https%3A%2F%2Fexample.com',\n    )\n  })\n\n  it('uses the proxy when the proxyUrl is relative', () => {\n    expect(redirectToProxy('/proxy', 'http://localhost:3000/api')).toBe(\n      '/proxy?scalar_url=http%3A%2F%2Flocalhost%3A3000%2Fapi',\n    )\n  })\n\n  it('skips the proxy if no proxy url is passed', () => {\n    expect(redirectToProxy('', 'https://example.com')).toBe('https://example.com')\n  })\n\n  it('skips the proxy for relative URLs starting with a slash', () => {\n    expect(redirectToProxy('https://proxy.scalar.com', '/api')).toBe('/api')\n  })\n\n  it('skips the proxy for relative URLs not starting with a slash', () => {\n    expect(redirectToProxy('https://proxy.scalar.com', 'api')).toBe('api')\n  })\n\n  it('skips the proxy for relative URLs not starting with a slash, but containing a dot', () => {\n    expect(redirectToProxy('https://proxy.scalar.com', 'openapi.json')).toBe('openapi.json')\n  })\n\n  it('uses the proxy when it\u2019s local', () => {\n    expect(redirectToProxy('http://localhost:3000/proxy', 'http://localhost:3000/api')).toBe(\n      'http://localhost:3000/proxy?scalar_url=http%3A%2F%2Flocalhost%3A3000%2Fapi',\n    )\n  })\n})\n\ndescribe('isRelativePath', () => {\n  it('returns true for relative paths starting with a slash', () => {\n    expect(isRelativePath('/api')).toBe(true)\n  })\n\n  it('returns true for relative paths without a slash', () => {\n    expect(isRelativePath('api')).toBe(true)\n  })\n\n  it('returns false for absolute URLs with http', () => {\n    expect(isRelativePath('http://example.com')).toBe(false)\n  })\n\n  it('returns false for absolute URLs with https', () => {\n    expect(isRelativePath('https://example.com')).toBe(false)\n  })\n\n  it('returns false for domain-like URLs without protocol', () => {\n    expect(isRelativePath('example.com/api')).toBe(false)\n  })\n})\n"],
+  "mappings": "AAAA,SAAS,UAAU,QAAQ,UAAU;AAErC,SAAS,gBAAgB,uBAAuB;AAEhD,SAAS,mBAAmB,MAAM;AAChC,KAAG,iBAAiB,MAAM;AACxB,WAAO,gBAAgB,4BAA4B,qBAAqB,CAAC,EAAE;AAAA,MACzE;AAAA,IACF;AAAA,EACF,CAAC;AAED,KAAG,0BAA0B,MAAM;AACjC,WAAO,gBAAgB,oCAAoC,qBAAqB,CAAC,EAAE;AAAA,MACjF;AAAA,IACF;AAAA,EACF,CAAC;AAED,KAAG,gDAAgD,MAAM;AACvD,WAAO,gBAAgB,UAAU,2BAA2B,CAAC,EAAE;AAAA,MAC7D;AAAA,IACF;AAAA,EACF,CAAC;AAED,KAAG,6CAA6C,MAAM;AACpD,WAAO,gBAAgB,IAAI,qBAAqB,CAAC,EAAE,KAAK,qBAAqB;AAAA,EAC/E,CAAC;AAED,KAAG,2DAA2D,MAAM;AAClE,WAAO,gBAAgB,4BAA4B,MAAM,CAAC,EAAE,KAAK,MAAM;AAAA,EACzE,CAAC;AAED,KAAG,+DAA+D,MAAM;AACtE,WAAO,gBAAgB,4BAA4B,KAAK,CAAC,EAAE,KAAK,KAAK;AAAA,EACvE,CAAC;AAED,KAAG,qFAAqF,MAAM;AAC5F,WAAO,gBAAgB,4BAA4B,cAAc,CAAC,EAAE,KAAK,cAAc;AAAA,EACzF,CAAC;AAED,KAAG,uCAAkC,MAAM;AACzC,WAAO,gBAAgB,+BAA+B,2BAA2B,CAAC,EAAE;AAAA,MAClF;AAAA,IACF;AAAA,EACF,CAAC;AACH,CAAC;AAED,SAAS,kBAAkB,MAAM;AAC/B,KAAG,yDAAyD,MAAM;AAChE,WAAO,eAAe,MAAM,CAAC,EAAE,KAAK,IAAI;AAAA,EAC1C,CAAC;AAED,KAAG,mDAAmD,MAAM;AAC1D,WAAO,eAAe,KAAK,CAAC,EAAE,KAAK,IAAI;AAAA,EACzC,CAAC;AAED,KAAG,6CAA6C,MAAM;AACpD,WAAO,eAAe,oBAAoB,CAAC,EAAE,KAAK,KAAK;AAAA,EACzD,CAAC;AAED,KAAG,8CAA8C,MAAM;AACrD,WAAO,eAAe,qBAAqB,CAAC,EAAE,KAAK,KAAK;AAAA,EAC1D,CAAC;AAED,KAAG,uDAAuD,MAAM;AAC9D,WAAO,eAAe,iBAAiB,CAAC,EAAE,KAAK,KAAK;AAAA,EACtD,CAAC;AACH,CAAC;",
+  "names": []
+}

package/dist/helpers/regex-helpers.js

@@ -1,11 +1,13 @@
 const REGEX = {
-    /** Checks for a valid scheme */
-    PROTOCOL: /^(?:https?|ftp|file|mailto|tel|data|wss?)*:\/\//,
-    /** Finds multiple slashes after the scheme to replace with a single slash */
-    MULTIPLE_SLASHES: /(?<!:)\/{2,}/g,
-    VARIABLES: /{{((?:[^{}]|{[^{}]*})*)}}/g,
-    PATH: /(?:{)([^{}]+)}(?!})/g,
-    TEMPLATE_VARIABLE: /{{\s*([^}\s]+?)\s*}}|{\s*([^}\s]+?)\s*}|:\b[\w.]+\b/g,
+  /** Checks for a valid scheme */
+  PROTOCOL: /^(?:https?|ftp|file|mailto|tel|data|wss?)*:\/\//,
+  /** Finds multiple slashes after the scheme to replace with a single slash */
+  MULTIPLE_SLASHES: /(?<!:)\/{2,}/g,
+  VARIABLES: /{{((?:[^{}]|{[^{}]*})*)}}/g,
+  PATH: /(?:{)([^{}]+)}(?!})/g,
+  TEMPLATE_VARIABLE: /{{\s*([^}\s]+?)\s*}}|{\s*([^}\s]+?)\s*}|:\b[\w.]+\b/g
 };
-
-export { REGEX };
+export {
+  REGEX
+};
+//# sourceMappingURL=regex-helpers.js.map

package/dist/helpers/regex-helpers.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/helpers/regex-helpers.ts"],
+  "sourcesContent": ["export const REGEX = {\n  /** Checks for a valid scheme */\n  PROTOCOL: /^(?:https?|ftp|file|mailto|tel|data|wss?)*:\\/\\//,\n  /** Finds multiple slashes after the scheme to replace with a single slash */\n  MULTIPLE_SLASHES: /(?<!:)\\/{2,}/g,\n  VARIABLES: /{{((?:[^{}]|{[^{}]*})*)}}/g,\n  PATH: /(?:{)([^{}]+)}(?!})/g,\n  TEMPLATE_VARIABLE: /{{\\s*([^}\\s]+?)\\s*}}|{\\s*([^}\\s]+?)\\s*}|:\\b[\\w.]+\\b/g,\n} as const\n"],
+  "mappings": "AAAO,MAAM,QAAQ;AAAA;AAAA,EAEnB,UAAU;AAAA;AAAA,EAEV,kBAAkB;AAAA,EAClB,WAAW;AAAA,EACX,MAAM;AAAA,EACN,mBAAmB;AACrB;",
+  "names": []
+}

package/dist/helpers/regex-helpers.test.js

@@ -0,0 +1,154 @@
+import { describe, expect, it } from "vitest";
+import { REGEX } from "./regex-helpers.js";
+describe("protocolRegex", () => {
+  it("allows http://", () => {
+    const text = "http://example.com";
+    expect(text.match(REGEX.PROTOCOL)).toBeTruthy();
+  });
+  it("allows https://", () => {
+    const text = "https://example.com";
+    expect(text.match(REGEX.PROTOCOL)).toBeTruthy();
+  });
+  it("allows file://", () => {
+    const text = "file://example.com";
+    expect(text.match(REGEX.PROTOCOL)).toBeTruthy();
+  });
+  it("allows ftp://", () => {
+    const text = "ftp://example.com";
+    expect(text.match(REGEX.PROTOCOL)).toBeTruthy();
+  });
+  it("allows mailto://", () => {
+    const text = "mailto://example.com";
+    expect(text.match(REGEX.PROTOCOL)).toBeTruthy();
+  });
+  it("does not allow variables before ://", () => {
+    const text = "{protocol}://example.com";
+    expect(text.match(REGEX.PROTOCOL)).toBeNull();
+  });
+  it("does not allow no protocol with a variable", () => {
+    const text = "{base}/api";
+    expect(text.match(REGEX.PROTOCOL)).toBeNull();
+  });
+  it("does not allow no protocol with no variables", () => {
+    const text = "example.com";
+    expect(text.match(REGEX.PROTOCOL)).toBeNull();
+  });
+});
+describe("multipleSlashesRegex", () => {
+  it("matches multiple slashes", () => {
+    const text = "http://example.com//api".replace(REGEX.MULTIPLE_SLASHES, "/");
+    expect(text).toBe("http://example.com/api");
+  });
+  it("matches multiple slashes in the path", () => {
+    const text = "http://example.com/api//users////{id}".replace(REGEX.MULTIPLE_SLASHES, "/");
+    expect(text).toBe("http://example.com/api/users/{id}");
+  });
+  it("does not match single slash or the scheme", () => {
+    const text = "http://example.com/api/users/{id}";
+    expect(text.match(REGEX.MULTIPLE_SLASHES)).toBeNull();
+  });
+  it("does not do anything to the query params", () => {
+    const text = "http://example.com/api/users/{id}?query=param";
+    expect(text.replace(REGEX.MULTIPLE_SLASHES, "/")).toBe("http://example.com/api/users/{id}?query=param");
+  });
+});
+describe("variableRegex", () => {
+  it("matches variables with double curly braces", () => {
+    const text = "{{example.com}}";
+    const matches = [...text.matchAll(REGEX.VARIABLES)];
+    expect(matches.length).toBe(1);
+    expect(matches[0][1]).toBe("example.com");
+  });
+  it("matches variables with nested curly braces", () => {
+    const text = "{{example.com:{port}}}";
+    const matches = [...text.matchAll(REGEX.VARIABLES)];
+    expect(matches.length).toBe(1);
+    expect(matches[0][1]).toBe("example.com:{port}");
+  });
+  it("matches multiple variables", () => {
+    const text = "{{{host}.example.com:{port}}}";
+    const matches = [...text.matchAll(REGEX.VARIABLES)];
+    expect(matches.length).toBe(1);
+    expect(matches[0][1]).toBe("{host}.example.com:{port}");
+  });
+  it("does not match single curly braces", () => {
+    const text = "{example.com}";
+    const matches = [...text.matchAll(REGEX.VARIABLES)];
+    expect(matches.length).toBe(0);
+  });
+  it("does not match unbalanced curly braces", () => {
+    const text = "{{example.com}";
+    const matches = [...text.matchAll(REGEX.VARIABLES)];
+    expect(matches.length).toBe(0);
+  });
+  it("matches variables with whitespace", () => {
+    const text = "{{ example.com }}";
+    const matches = [...text.matchAll(REGEX.VARIABLES)];
+    expect(matches.length).toBe(1);
+    expect(matches[0][1]).toBe(" example.com ");
+  });
+  it("matches variables in longer text", () => {
+    const text = "prefix {{variable}} suffix";
+    const matches = [...text.matchAll(REGEX.VARIABLES)];
+    expect(matches.length).toBe(1);
+    expect(matches[0][1]).toBe("variable");
+  });
+  it("matches multiple separate variables", () => {
+    const text = "{{first}} middle {{second}}";
+    const matches = [...text.matchAll(REGEX.VARIABLES)];
+    expect(matches.length).toBe(2);
+    expect(matches[0][1]).toBe("first");
+    expect(matches[1][1]).toBe("second");
+  });
+});
+describe("pathRegex", () => {
+  it("matches path parameters", () => {
+    const text = "/users/{id}";
+    const matches = [...text.matchAll(REGEX.PATH)];
+    expect(matches.length).toBe(1);
+    expect(matches[0][1]).toBe("id");
+  });
+  it("matches multiple path parameters", () => {
+    const text = "/users/{userId}/posts/{postId}";
+    const matches = [...text.matchAll(REGEX.PATH)];
+    expect(matches.length).toBe(2);
+    expect(matches[0][1]).toBe("userId");
+    expect(matches[1][1]).toBe("postId");
+  });
+  it("does not match double curly braces", () => {
+    const text = "/users/{{id}}";
+    const matches = [...text.matchAll(REGEX.PATH)];
+    expect(matches.length).toBe(0);
+  });
+  it("matches path parameters with dots", () => {
+    const text = "/api/{version}/users";
+    const matches = [...text.matchAll(REGEX.PATH)];
+    expect(matches.length).toBe(1);
+    expect(matches[0][1]).toBe("version");
+  });
+  it("matches path parameters with hyphens and underscores", () => {
+    const text = "/users/{user-id}/posts/{post_id}";
+    const matches = [...text.matchAll(REGEX.PATH)];
+    expect(matches.length).toBe(2);
+    expect(matches[0][1]).toBe("user-id");
+    expect(matches[1][1]).toBe("post_id");
+  });
+  it("does not match nested curly braces", () => {
+    const text = "/users/{outer{inner}}";
+    const matches = [...text.matchAll(REGEX.PATH)];
+    expect(matches.length).toBe(0);
+  });
+  it("matches path parameters at start of string", () => {
+    const text = "{version}/api";
+    const matches = [...text.matchAll(REGEX.PATH)];
+    expect(matches.length).toBe(1);
+    expect(matches[0][1]).toBe("version");
+  });
+  it("matches path parameters at end of string", () => {
+    const text = "/api/{version}";
+    const matches = [...text.matchAll(REGEX.PATH)];
+    expect(matches.length).toBe(1);
+    expect(matches[0][1]).toBe("version");
+  });
+});
+//# sourceMappingURL=regex-helpers.test.js.map

package/dist/helpers/regex-helpers.test.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/helpers/regex-helpers.test.ts"],
+  "sourcesContent": ["import { describe, expect, it } from 'vitest'\n\nimport { REGEX } from './regex-helpers'\n\ndescribe('protocolRegex', () => {\n  it('allows http://', () => {\n    const text = 'http://example.com'\n    expect(text.match(REGEX.PROTOCOL)).toBeTruthy()\n  })\n\n  it('allows https://', () => {\n    const text = 'https://example.com'\n    expect(text.match(REGEX.PROTOCOL)).toBeTruthy()\n  })\n\n  it('allows file://', () => {\n    const text = 'file://example.com'\n    expect(text.match(REGEX.PROTOCOL)).toBeTruthy()\n  })\n\n  it('allows ftp://', () => {\n    const text = 'ftp://example.com'\n    expect(text.match(REGEX.PROTOCOL)).toBeTruthy()\n  })\n\n  it('allows mailto://', () => {\n    const text = 'mailto://example.com'\n    expect(text.match(REGEX.PROTOCOL)).toBeTruthy()\n  })\n\n  it('does not allow variables before ://', () => {\n    const text = '{protocol}://example.com'\n    expect(text.match(REGEX.PROTOCOL)).toBeNull()\n  })\n\n  it('does not allow no protocol with a variable', () => {\n    const text = '{base}/api'\n    expect(text.match(REGEX.PROTOCOL)).toBeNull()\n  })\n\n  it('does not allow no protocol with no variables', () => {\n    const text = 'example.com'\n    expect(text.match(REGEX.PROTOCOL)).toBeNull()\n  })\n})\n\ndescribe('multipleSlashesRegex', () => {\n  it('matches multiple slashes', () => {\n    const text = 'http://example.com//api'.replace(REGEX.MULTIPLE_SLASHES, '/')\n    expect(text).toBe('http://example.com/api')\n  })\n\n  it('matches multiple slashes in the path', () => {\n    const text = 'http://example.com/api//users////{id}'.replace(REGEX.MULTIPLE_SLASHES, '/')\n    expect(text).toBe('http://example.com/api/users/{id}')\n  })\n\n  it('does not match single slash or the scheme', () => {\n    const text = 'http://example.com/api/users/{id}'\n    expect(text.match(REGEX.MULTIPLE_SLASHES)).toBeNull()\n  })\n\n  it('does not do anything to the query params', () => {\n    const text = 'http://example.com/api/users/{id}?query=param'\n    expect(text.replace(REGEX.MULTIPLE_SLASHES, '/')).toBe('http://example.com/api/users/{id}?query=param')\n  })\n})\n\ndescribe('variableRegex', () => {\n  it('matches variables with double curly braces', () => {\n    const text = '{{example.com}}'\n    const matches = [...text.matchAll(REGEX.VARIABLES)]\n    expect(matches.length).toBe(1)\n    expect(matches[0]![1]).toBe('example.com')\n  })\n\n  it('matches variables with nested curly braces', () => {\n    const text = '{{example.com:{port}}}'\n    const matches = [...text.matchAll(REGEX.VARIABLES)]\n    expect(matches.length).toBe(1)\n    expect(matches[0]![1]).toBe('example.com:{port}')\n  })\n\n  it('matches multiple variables', () => {\n    const text = '{{{host}.example.com:{port}}}'\n    const matches = [...text.matchAll(REGEX.VARIABLES)]\n    expect(matches.length).toBe(1)\n    expect(matches[0]![1]).toBe('{host}.example.com:{port}')\n  })\n\n  it('does not match single curly braces', () => {\n    const text = '{example.com}'\n    const matches = [...text.matchAll(REGEX.VARIABLES)]\n    expect(matches.length).toBe(0)\n  })\n\n  it('does not match unbalanced curly braces', () => {\n    const text = '{{example.com}'\n    const matches = [...text.matchAll(REGEX.VARIABLES)]\n    expect(matches.length).toBe(0)\n  })\n\n  it('matches variables with whitespace', () => {\n    const text = '{{ example.com }}'\n    const matches = [...text.matchAll(REGEX.VARIABLES)]\n    expect(matches.length).toBe(1)\n    expect(matches[0]![1]).toBe(' example.com ')\n  })\n\n  it('matches variables in longer text', () => {\n    const text = 'prefix {{variable}} suffix'\n    const matches = [...text.matchAll(REGEX.VARIABLES)]\n    expect(matches.length).toBe(1)\n    expect(matches[0]![1]).toBe('variable')\n  })\n\n  it('matches multiple separate variables', () => {\n    const text = '{{first}} middle {{second}}'\n    const matches = [...text.matchAll(REGEX.VARIABLES)]\n    expect(matches.length).toBe(2)\n    expect(matches[0]![1]).toBe('first')\n    expect(matches[1]![1]).toBe('second')\n  })\n})\n\ndescribe('pathRegex', () => {\n  it('matches path parameters', () => {\n    const text = '/users/{id}'\n    const matches = [...text.matchAll(REGEX.PATH)]\n    expect(matches.length).toBe(1)\n    expect(matches[0]![1]).toBe('id')\n  })\n\n  it('matches multiple path parameters', () => {\n    const text = '/users/{userId}/posts/{postId}'\n    const matches = [...text.matchAll(REGEX.PATH)]\n    expect(matches.length).toBe(2)\n    expect(matches[0]![1]).toBe('userId')\n    expect(matches[1]![1]).toBe('postId')\n  })\n\n  it('does not match double curly braces', () => {\n    const text = '/users/{{id}}'\n    const matches = [...text.matchAll(REGEX.PATH)]\n    expect(matches.length).toBe(0)\n  })\n\n  it('matches path parameters with dots', () => {\n    const text = '/api/{version}/users'\n    const matches = [...text.matchAll(REGEX.PATH)]\n    expect(matches.length).toBe(1)\n    expect(matches[0]![1]).toBe('version')\n  })\n\n  it('matches path parameters with hyphens and underscores', () => {\n    const text = '/users/{user-id}/posts/{post_id}'\n    const matches = [...text.matchAll(REGEX.PATH)]\n    expect(matches.length).toBe(2)\n    expect(matches[0]![1]).toBe('user-id')\n    expect(matches[1]![1]).toBe('post_id')\n  })\n\n  it('does not match nested curly braces', () => {\n    const text = '/users/{outer{inner}}'\n    const matches = [...text.matchAll(REGEX.PATH)]\n    expect(matches.length).toBe(0)\n  })\n\n  it('matches path parameters at start of string', () => {\n    const text = '{version}/api'\n    const matches = [...text.matchAll(REGEX.PATH)]\n    expect(matches.length).toBe(1)\n    expect(matches[0]![1]).toBe('version')\n  })\n\n  it('matches path parameters at end of string', () => {\n    const text = '/api/{version}'\n    const matches = [...text.matchAll(REGEX.PATH)]\n    expect(matches.length).toBe(1)\n    expect(matches[0]![1]).toBe('version')\n  })\n})\n"],
+  "mappings": "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",
+  "names": []
+}

package/dist/helpers/replace-variables.js

@@ -1,18 +1,15 @@
-/**
- * This function takes a string and replace {variables} with given values.
- */
 function replaceVariables(value, variablesOrCallback) {
-    // Replace all variables (example: {{ baseurl }} with an HTML tag)
-    const doubleCurlyBrackets = /{{\s*([\w.-]+)\s*}}/g;
-    const singleCurlyBrackets = /{\s*([\w.-]+)\s*}/g;
-    const callback = (_, match) => {
-        if (typeof variablesOrCallback === 'function') {
-            return variablesOrCallback(match);
-        }
-        return variablesOrCallback[match]?.toString() || `{${match}}`;
-    };
-    // Loop through all matches and replace the match with the variable value
-    return value.replace(doubleCurlyBrackets, callback).replace(singleCurlyBrackets, callback);
+  const doubleCurlyBrackets = /{{\s*([\w.-]+)\s*}}/g;
+  const singleCurlyBrackets = /{\s*([\w.-]+)\s*}/g;
+  const callback = (_, match) => {
+    if (typeof variablesOrCallback === "function") {
+      return variablesOrCallback(match);
+    }
+    return variablesOrCallback[match]?.toString() || `{${match}}`;
+  };
+  return value.replace(doubleCurlyBrackets, callback).replace(singleCurlyBrackets, callback);
 }
-
-export { replaceVariables };
+export {
+  replaceVariables
+};
+//# sourceMappingURL=replace-variables.js.map

package/dist/helpers/replace-variables.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/helpers/replace-variables.ts"],
+  "sourcesContent": ["/**\n * This function takes a string and replace {variables} with given values.\n */\nexport function replaceVariables(\n  value: string,\n  variablesOrCallback: Record<string, string | number> | ((match: string) => string),\n) {\n  // Replace all variables (example: {{ baseurl }} with an HTML tag)\n  const doubleCurlyBrackets = /{{\\s*([\\w.-]+)\\s*}}/g\n  const singleCurlyBrackets = /{\\s*([\\w.-]+)\\s*}/g\n\n  const callback = (_: string, match: string): string => {\n    if (typeof variablesOrCallback === 'function') {\n      return variablesOrCallback(match)\n    }\n    return variablesOrCallback[match]?.toString() || `{${match}}`\n  }\n\n  // Loop through all matches and replace the match with the variable value\n  return value.replace(doubleCurlyBrackets, callback).replace(singleCurlyBrackets, callback)\n}\n"],
+  "mappings": "AAGO,SAAS,iBACd,OACA,qBACA;AAEA,QAAM,sBAAsB;AAC5B,QAAM,sBAAsB;AAE5B,QAAM,WAAW,CAAC,GAAW,UAA0B;AACrD,QAAI,OAAO,wBAAwB,YAAY;AAC7C,aAAO,oBAAoB,KAAK;AAAA,IAClC;AACA,WAAO,oBAAoB,KAAK,GAAG,SAAS,KAAK,IAAI,KAAK;AAAA,EAC5D;AAGA,SAAO,MAAM,QAAQ,qBAAqB,QAAQ,EAAE,QAAQ,qBAAqB,QAAQ;AAC3F;",
+  "names": []
+}

package/dist/helpers/replace-variables.test.js

@@ -0,0 +1,30 @@
+import { describe, expect, it } from "vitest";
+import { replaceVariables } from "./replace-variables.js";
+describe("replaceVariables", () => {
+  it("replaces variables with a single bracket", () => {
+    expect(
+      replaceVariables("foo{bar}foo", {
+        bar: "foo"
+      })
+    ).toMatchObject("foofoofoo");
+  });
+  it("replaces variables with a double bracket", () => {
+    expect(
+      replaceVariables("foo{{bar}}foo", {
+        bar: "foo"
+      })
+    ).toMatchObject("foofoofoo");
+  });
+  it("replaces variables with a custom callback", () => {
+    expect(replaceVariables("foo{{bar}}foo", (match) => match === "bar" ? "<span>foo</span>" : "")).toMatchObject(
+      "foo<span>foo</span>foo"
+    );
+  });
+  it("returns variable in curly braces when value is empty", () => {
+    const template = "http://{host}:{port}/api";
+    const variables = { host: "localhost", port: "" };
+    const result = replaceVariables(template, variables);
+    expect(result).toBe("http://localhost:{port}/api");
+  });
+});
+//# sourceMappingURL=replace-variables.test.js.map

package/dist/helpers/replace-variables.test.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/helpers/replace-variables.test.ts"],
+  "sourcesContent": ["import { describe, expect, it } from 'vitest'\n\nimport { replaceVariables } from './replace-variables'\n\ndescribe('replaceVariables', () => {\n  it('replaces variables with a single bracket', () => {\n    expect(\n      replaceVariables('foo{bar}foo', {\n        bar: 'foo',\n      }),\n    ).toMatchObject('foofoofoo')\n  })\n\n  it('replaces variables with a double bracket', () => {\n    expect(\n      replaceVariables('foo{{bar}}foo', {\n        bar: 'foo',\n      }),\n    ).toMatchObject('foofoofoo')\n  })\n\n  it('replaces variables with a custom callback', () => {\n    expect(replaceVariables('foo{{bar}}foo', (match) => (match === 'bar' ? '<span>foo</span>' : ''))).toMatchObject(\n      'foo<span>foo</span>foo',\n    )\n  })\n\n  it('returns variable in curly braces when value is empty', () => {\n    const template = 'http://{host}:{port}/api'\n    const variables = { host: 'localhost', port: '' }\n\n    const result = replaceVariables(template, variables)\n\n    expect(result).toBe('http://localhost:{port}/api')\n  })\n})\n"],
+  "mappings": "AAAA,SAAS,UAAU,QAAQ,UAAU;AAErC,SAAS,wBAAwB;AAEjC,SAAS,oBAAoB,MAAM;AACjC,KAAG,4CAA4C,MAAM;AACnD;AAAA,MACE,iBAAiB,eAAe;AAAA,QAC9B,KAAK;AAAA,MACP,CAAC;AAAA,IACH,EAAE,cAAc,WAAW;AAAA,EAC7B,CAAC;AAED,KAAG,4CAA4C,MAAM;AACnD;AAAA,MACE,iBAAiB,iBAAiB;AAAA,QAChC,KAAK;AAAA,MACP,CAAC;AAAA,IACH,EAAE,cAAc,WAAW;AAAA,EAC7B,CAAC;AAED,KAAG,6CAA6C,MAAM;AACpD,WAAO,iBAAiB,iBAAiB,CAAC,UAAW,UAAU,QAAQ,qBAAqB,EAAG,CAAC,EAAE;AAAA,MAChG;AAAA,IACF;AAAA,EACF,CAAC;AAED,KAAG,wDAAwD,MAAM;AAC/D,UAAM,WAAW;AACjB,UAAM,YAAY,EAAE,MAAM,aAAa,MAAM,GAAG;AAEhD,UAAM,SAAS,iBAAiB,UAAU,SAAS;AAEnD,WAAO,MAAM,EAAE,KAAK,6BAA6B;AAAA,EACnD,CAAC;AACH,CAAC;",
+  "names": []
+}

package/dist/helpers/schema-model.js

@@ -1,16 +1,17 @@
-/** Parse a Zod */
 function schemaModel(data, schema, throwError = true, errorLocation) {
-    const result = schema.safeParse(data);
-    if (!result.success) {
-        console.group('Schema Error' + (errorLocation ? ` - ${errorLocation}` : ''));
-        console.warn(JSON.stringify(result.error.format(), null, 2));
-        console.log('Received: ', data);
-        console.groupEnd();
-    }
-    if (throwError && !result.success) {
-        throw new Error('Zod validation failure');
-    }
-    return result.data;
+  const result = schema.safeParse(data);
+  if (!result.success) {
+    console.group("Schema Error" + (errorLocation ? ` - ${errorLocation}` : ""));
+    console.warn(JSON.stringify(result.error.format(), null, 2));
+    console.log("Received: ", data);
+    console.groupEnd();
+  }
+  if (throwError && !result.success) {
+    throw new Error("Zod validation failure");
+  }
+  return result.data;
 }
-
-export { schemaModel };
+export {
+  schemaModel
+};
+//# sourceMappingURL=schema-model.js.map

package/dist/helpers/schema-model.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/helpers/schema-model.ts"],
+  "sourcesContent": ["import type { ZodSchema, ZodTypeDef } from 'zod'\n\n/** Parse an value from a given schema with optional error or null return */\nexport function schemaModel<T, I = any>(\n  data: I,\n  schema: ZodSchema<T, ZodTypeDef, any>,\n  throwError?: true,\n  errorLocation?: string,\n): T\nexport function schemaModel<T, I = any>(\n  data: I,\n  schema: ZodSchema<T, ZodTypeDef, any>,\n  throwError?: false,\n  errorLocation?: string,\n): T | null\n/** Parse a Zod */\nexport function schemaModel<T, I = any>(\n  data: I,\n  schema: ZodSchema<T, ZodTypeDef, any>,\n  throwError = true,\n  errorLocation?: string,\n) {\n  const result = schema.safeParse(data)\n\n  if (!result.success) {\n    console.group('Schema Error' + (errorLocation ? ` - ${errorLocation}` : ''))\n    console.warn(JSON.stringify(result.error.format(), null, 2))\n    console.log('Received: ', data)\n    console.groupEnd()\n  }\n\n  if (throwError && !result.success) {\n    throw new Error('Zod validation failure')\n  }\n\n  return result.data\n}\n"],
+  "mappings": "AAgBO,SAAS,YACd,MACA,QACA,aAAa,MACb,eACA;AACA,QAAM,SAAS,OAAO,UAAU,IAAI;AAEpC,MAAI,CAAC,OAAO,SAAS;AACnB,YAAQ,MAAM,kBAAkB,gBAAgB,MAAM,aAAa,KAAK,GAAG;AAC3E,YAAQ,KAAK,KAAK,UAAU,OAAO,MAAM,OAAO,GAAG,MAAM,CAAC,CAAC;AAC3D,YAAQ,IAAI,cAAc,IAAI;AAC9B,YAAQ,SAAS;AAAA,EACnB;AAEA,MAAI,cAAc,CAAC,OAAO,SAAS;AACjC,UAAM,IAAI,MAAM,wBAAwB;AAAA,EAC1C;AAEA,SAAO,OAAO;AAChB;",
+  "names": []
+}

package/dist/helpers/security/get-schemes.d.ts

@@ -1,5 +1,5 @@
 import type { SecurityScheme } from '@scalar/types/entities';
-import type { Operation } from '../../entities/spec/operation.ts';
+import type { Operation } from '../../entities/spec/operation.js';
 /** Parses a list of selected security scheme uids which may be an array or single uid and returns a flattened array of security schemes */
 export declare const getSchemes: (selectedSecuritySchemes: Operation["selectedSecuritySchemeUids"], securitySchemes: Record<SecurityScheme["uid"], SecurityScheme>) => NonNullable<{
     name: string;

package/dist/helpers/security/get-schemes.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"get-schemes.d.ts","sourceRoot":"","sources":["../../../src/helpers/security/get-schemes.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAA;AAE5D,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,8BAA8B,CAAA;AAG7D,2IAA2I;AAC3I,eAAO,MAAM,UAAU,4BACI,SAAS,CAAC,4BAA4B,CAAC,mBAC/C,MAAM,CAAC,cAAc,CAAC,KAAK,CAAC,EAAE,cAAc,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gBAOyr3D,CAAC;;;;;;;;;;;;gBAA4X,CAAC;;;;;;;;;;yBAA4V,CAAC;;;;;;;;;;yBAAkV,CAAC;;;;;;;;;;;;;;;;IADty5D,CAAA"}
+{"version":3,"file":"get-schemes.d.ts","sourceRoot":"","sources":["../../../src/helpers/security/get-schemes.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAA;AAE5D,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,2BAA2B,CAAA;AAG1D,2IAA2I;AAC3I,eAAO,MAAM,UAAU,4BACI,SAAS,CAAC,4BAA4B,CAAC,mBAC/C,MAAM,CAAC,cAAc,CAAC,KAAK,CAAC,EAAE,cAAc,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gBAO+r3D,CAAC;;;;;;;;;;;;gBAA4X,CAAC;;;;;;;;;;yBAA4V,CAAC;;;;;;;;;;yBAAkV,CAAC;;;;;;;;;;;;;;;;IAD5y5D,CAAA"}

package/dist/helpers/security/get-schemes.js

@@ -1,11 +1,9 @@
-import { isDefined } from '../is-defined.js';
-
-/** Parses a list of selected security scheme uids which may be an array or single uid and returns a flattened array of security schemes */
+import { isDefined } from "../../helpers/is-defined.js";
 const getSchemes = (selectedSecuritySchemes, securitySchemes) => {
-    const uids = new Set(selectedSecuritySchemes.flat());
-    return Array.from(uids)
-        .map((uid) => securitySchemes[uid])
-        .filter(isDefined);
+  const uids = new Set(selectedSecuritySchemes.flat());
+  return Array.from(uids).map((uid) => securitySchemes[uid]).filter(isDefined);
 };
-
-export { getSchemes };
+export {
+  getSchemes
+};
+//# sourceMappingURL=get-schemes.js.map

package/dist/helpers/security/get-schemes.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/helpers/security/get-schemes.ts"],
+  "sourcesContent": ["import type { SecurityScheme } from '@scalar/types/entities'\n\nimport type { Operation } from '@/entities/spec/operation'\nimport { isDefined } from '@/helpers/is-defined'\n\n/** Parses a list of selected security scheme uids which may be an array or single uid and returns a flattened array of security schemes */\nexport const getSchemes = (\n  selectedSecuritySchemes: Operation['selectedSecuritySchemeUids'],\n  securitySchemes: Record<SecurityScheme['uid'], SecurityScheme>,\n) => {\n  const uids = new Set(selectedSecuritySchemes.flat())\n  return Array.from(uids)\n    .map((uid) => securitySchemes[uid])\n    .filter(isDefined)\n}\n"],
+  "mappings": "AAGA,SAAS,iBAAiB;AAGnB,MAAM,aAAa,CACxB,yBACA,oBACG;AACH,QAAM,OAAO,IAAI,IAAI,wBAAwB,KAAK,CAAC;AACnD,SAAO,MAAM,KAAK,IAAI,EACnB,IAAI,CAAC,QAAQ,gBAAgB,GAAG,CAAC,EACjC,OAAO,SAAS;AACrB;",
+  "names": []
+}