@scalar/helpers 0.4.0 → 0.4.2

package/dist/string/generate-hash.js

@@ -1,130 +1,156 @@
-const generateHash = (input) => {
-  const seed = 0;
-  let h1 = seed;
-  let h2 = seed;
-  const len = input.length;
-  const remainder = len & 15;
-  const bytes = len - remainder;
-  const c1 = 2277735313;
-  const c2 = 1291169091;
-  const c3 = 1390208809;
-  const c4 = 944331445;
-  for (let i = 0; i < bytes; i += 16) {
-    let k1 = input.charCodeAt(i) & 255 | (input.charCodeAt(i + 1) & 255) << 8 | (input.charCodeAt(i + 2) & 255) << 16 | (input.charCodeAt(i + 3) & 255) << 24;
-    let k2 = input.charCodeAt(i + 4) & 255 | (input.charCodeAt(i + 5) & 255) << 8 | (input.charCodeAt(i + 6) & 255) << 16 | (input.charCodeAt(i + 7) & 255) << 24;
-    let k3 = input.charCodeAt(i + 8) & 255 | (input.charCodeAt(i + 9) & 255) << 8 | (input.charCodeAt(i + 10) & 255) << 16 | (input.charCodeAt(i + 11) & 255) << 24;
-    let k4 = input.charCodeAt(i + 12) & 255 | (input.charCodeAt(i + 13) & 255) << 8 | (input.charCodeAt(i + 14) & 255) << 16 | (input.charCodeAt(i + 15) & 255) << 24;
-    k1 = Math.imul(k1, c1);
-    k1 = k1 << 15 | k1 >>> 17;
-    k1 = Math.imul(k1, c2);
-    h1 ^= k1;
-    h1 = h1 << 13 | h1 >>> 19;
-    h1 = Math.imul(h1, 5) + 3864292196;
-    k2 = Math.imul(k2, c2);
-    k2 = k2 << 16 | k2 >>> 16;
-    k2 = Math.imul(k2, c3);
-    h2 ^= k2;
-    h2 = h2 << 17 | h2 >>> 15;
-    h2 = Math.imul(h2, 5) + 461845907;
-    k3 = Math.imul(k3, c3);
-    k3 = k3 << 17 | k3 >>> 15;
-    k3 = Math.imul(k3, c4);
-    h1 ^= k3;
-    h1 = h1 << 15 | h1 >>> 17;
-    h1 = Math.imul(h1, 5) + 1390208809;
-    k4 = Math.imul(k4, c4);
-    k4 = k4 << 18 | k4 >>> 14;
-    k4 = Math.imul(k4, c1);
-    h2 ^= k4;
-    h2 = h2 << 13 | h2 >>> 19;
-    h2 = Math.imul(h2, 5) + 944331445;
-  }
-  if (remainder > 0) {
-    let k1 = 0;
-    let k2 = 0;
-    let k3 = 0;
-    let k4 = 0;
-    if (remainder >= 15) {
-      k4 ^= (input.charCodeAt(bytes + 14) & 255) << 16;
+/**
+ * MurmurHash3 implementation
+ *
+ * Generate a hash from a string using the MurmurHash3 algorithm
+ * Provides 64-bit hash output with excellent speed and distribution
+ *
+ * We had to move away from xxhash-wasm since it was causing issues with content security policy (CSP) violations.
+ *
+ * We cannot use crypto.subtle because it is only available in secure contexts (HTTPS) or on localhost.
+ *
+ * @param input - The string to hash
+ * @returns The 64-bit hash of the input string as a 16-character hex string
+ */
+export const generateHash = (input) => {
+    const seed = 0;
+    // Working with 64-bit values using pairs of 32-bit integers
+    let h1 = seed;
+    let h2 = seed;
+    const len = input.length;
+    const remainder = len & 15; // len % 16
+    const bytes = len - remainder;
+    const c1 = 0x87c37b91;
+    const c2 = 0x4cf5ad43;
+    const c3 = 0x52dce729;
+    const c4 = 0x38495ab5;
+    // Process 16-byte chunks
+    for (let i = 0; i < bytes; i += 16) {
+        let k1 = (input.charCodeAt(i) & 0xff) |
+            ((input.charCodeAt(i + 1) & 0xff) << 8) |
+            ((input.charCodeAt(i + 2) & 0xff) << 16) |
+            ((input.charCodeAt(i + 3) & 0xff) << 24);
+        let k2 = (input.charCodeAt(i + 4) & 0xff) |
+            ((input.charCodeAt(i + 5) & 0xff) << 8) |
+            ((input.charCodeAt(i + 6) & 0xff) << 16) |
+            ((input.charCodeAt(i + 7) & 0xff) << 24);
+        let k3 = (input.charCodeAt(i + 8) & 0xff) |
+            ((input.charCodeAt(i + 9) & 0xff) << 8) |
+            ((input.charCodeAt(i + 10) & 0xff) << 16) |
+            ((input.charCodeAt(i + 11) & 0xff) << 24);
+        let k4 = (input.charCodeAt(i + 12) & 0xff) |
+            ((input.charCodeAt(i + 13) & 0xff) << 8) |
+            ((input.charCodeAt(i + 14) & 0xff) << 16) |
+            ((input.charCodeAt(i + 15) & 0xff) << 24);
+        k1 = Math.imul(k1, c1);
+        k1 = (k1 << 15) | (k1 >>> 17);
+        k1 = Math.imul(k1, c2);
+        h1 ^= k1;
+        h1 = (h1 << 13) | (h1 >>> 19);
+        h1 = Math.imul(h1, 5) + 0xe6546b64;
+        k2 = Math.imul(k2, c2);
+        k2 = (k2 << 16) | (k2 >>> 16);
+        k2 = Math.imul(k2, c3);
+        h2 ^= k2;
+        h2 = (h2 << 17) | (h2 >>> 15);
+        h2 = Math.imul(h2, 5) + 0x1b873593;
+        k3 = Math.imul(k3, c3);
+        k3 = (k3 << 17) | (k3 >>> 15);
+        k3 = Math.imul(k3, c4);
+        h1 ^= k3;
+        h1 = (h1 << 15) | (h1 >>> 17);
+        h1 = Math.imul(h1, 5) + 0x52dce729;
+        k4 = Math.imul(k4, c4);
+        k4 = (k4 << 18) | (k4 >>> 14);
+        k4 = Math.imul(k4, c1);
+        h2 ^= k4;
+        h2 = (h2 << 13) | (h2 >>> 19);
+        h2 = Math.imul(h2, 5) + 0x38495ab5;
     }
-    if (remainder >= 14) {
-      k4 ^= (input.charCodeAt(bytes + 13) & 255) << 8;
+    // Process remaining bytes
+    if (remainder > 0) {
+        let k1 = 0;
+        let k2 = 0;
+        let k3 = 0;
+        let k4 = 0;
+        if (remainder >= 15) {
+            k4 ^= (input.charCodeAt(bytes + 14) & 0xff) << 16;
+        }
+        if (remainder >= 14) {
+            k4 ^= (input.charCodeAt(bytes + 13) & 0xff) << 8;
+        }
+        if (remainder >= 13) {
+            k4 ^= input.charCodeAt(bytes + 12) & 0xff;
+            k4 = Math.imul(k4, c4);
+            k4 = (k4 << 18) | (k4 >>> 14);
+            k4 = Math.imul(k4, c1);
+            h2 ^= k4;
+        }
+        if (remainder >= 12) {
+            k3 ^= (input.charCodeAt(bytes + 11) & 0xff) << 24;
+        }
+        if (remainder >= 11) {
+            k3 ^= (input.charCodeAt(bytes + 10) & 0xff) << 16;
+        }
+        if (remainder >= 10) {
+            k3 ^= (input.charCodeAt(bytes + 9) & 0xff) << 8;
+        }
+        if (remainder >= 9) {
+            k3 ^= input.charCodeAt(bytes + 8) & 0xff;
+            k3 = Math.imul(k3, c3);
+            k3 = (k3 << 17) | (k3 >>> 15);
+            k3 = Math.imul(k3, c4);
+            h1 ^= k3;
+        }
+        if (remainder >= 8) {
+            k2 ^= (input.charCodeAt(bytes + 7) & 0xff) << 24;
+        }
+        if (remainder >= 7) {
+            k2 ^= (input.charCodeAt(bytes + 6) & 0xff) << 16;
+        }
+        if (remainder >= 6) {
+            k2 ^= (input.charCodeAt(bytes + 5) & 0xff) << 8;
+        }
+        if (remainder >= 5) {
+            k2 ^= input.charCodeAt(bytes + 4) & 0xff;
+            k2 = Math.imul(k2, c2);
+            k2 = (k2 << 16) | (k2 >>> 16);
+            k2 = Math.imul(k2, c3);
+            h2 ^= k2;
+        }
+        if (remainder >= 4) {
+            k1 ^= (input.charCodeAt(bytes + 3) & 0xff) << 24;
+        }
+        if (remainder >= 3) {
+            k1 ^= (input.charCodeAt(bytes + 2) & 0xff) << 16;
+        }
+        if (remainder >= 2) {
+            k1 ^= (input.charCodeAt(bytes + 1) & 0xff) << 8;
+        }
+        if (remainder >= 1) {
+            k1 ^= input.charCodeAt(bytes) & 0xff;
+            k1 = Math.imul(k1, c1);
+            k1 = (k1 << 15) | (k1 >>> 17);
+            k1 = Math.imul(k1, c2);
+            h1 ^= k1;
+        }
     }
-    if (remainder >= 13) {
-      k4 ^= input.charCodeAt(bytes + 12) & 255;
-      k4 = Math.imul(k4, c4);
-      k4 = k4 << 18 | k4 >>> 14;
-      k4 = Math.imul(k4, c1);
-      h2 ^= k4;
-    }
-    if (remainder >= 12) {
-      k3 ^= (input.charCodeAt(bytes + 11) & 255) << 24;
-    }
-    if (remainder >= 11) {
-      k3 ^= (input.charCodeAt(bytes + 10) & 255) << 16;
-    }
-    if (remainder >= 10) {
-      k3 ^= (input.charCodeAt(bytes + 9) & 255) << 8;
-    }
-    if (remainder >= 9) {
-      k3 ^= input.charCodeAt(bytes + 8) & 255;
-      k3 = Math.imul(k3, c3);
-      k3 = k3 << 17 | k3 >>> 15;
-      k3 = Math.imul(k3, c4);
-      h1 ^= k3;
-    }
-    if (remainder >= 8) {
-      k2 ^= (input.charCodeAt(bytes + 7) & 255) << 24;
-    }
-    if (remainder >= 7) {
-      k2 ^= (input.charCodeAt(bytes + 6) & 255) << 16;
-    }
-    if (remainder >= 6) {
-      k2 ^= (input.charCodeAt(bytes + 5) & 255) << 8;
-    }
-    if (remainder >= 5) {
-      k2 ^= input.charCodeAt(bytes + 4) & 255;
-      k2 = Math.imul(k2, c2);
-      k2 = k2 << 16 | k2 >>> 16;
-      k2 = Math.imul(k2, c3);
-      h2 ^= k2;
-    }
-    if (remainder >= 4) {
-      k1 ^= (input.charCodeAt(bytes + 3) & 255) << 24;
-    }
-    if (remainder >= 3) {
-      k1 ^= (input.charCodeAt(bytes + 2) & 255) << 16;
-    }
-    if (remainder >= 2) {
-      k1 ^= (input.charCodeAt(bytes + 1) & 255) << 8;
-    }
-    if (remainder >= 1) {
-      k1 ^= input.charCodeAt(bytes) & 255;
-      k1 = Math.imul(k1, c1);
-      k1 = k1 << 15 | k1 >>> 17;
-      k1 = Math.imul(k1, c2);
-      h1 ^= k1;
-    }
-  }
-  h1 ^= len;
-  h2 ^= len;
-  h1 += h2;
-  h2 += h1;
-  h1 ^= h1 >>> 16;
-  h1 = Math.imul(h1, 2246822507);
-  h1 ^= h1 >>> 13;
-  h1 = Math.imul(h1, 3266489909);
-  h1 ^= h1 >>> 16;
-  h2 ^= h2 >>> 16;
-  h2 = Math.imul(h2, 2246822507);
-  h2 ^= h2 >>> 13;
-  h2 = Math.imul(h2, 3266489909);
-  h2 ^= h2 >>> 16;
-  h1 += h2;
-  h2 += h1;
-  return (h1 >>> 0).toString(16).padStart(8, "0") + (h2 >>> 0).toString(16).padStart(8, "0");
-};
-export {
-  generateHash
+    // Finalization
+    h1 ^= len;
+    h2 ^= len;
+    h1 += h2;
+    h2 += h1;
+    h1 ^= h1 >>> 16;
+    h1 = Math.imul(h1, 0x85ebca6b);
+    h1 ^= h1 >>> 13;
+    h1 = Math.imul(h1, 0xc2b2ae35);
+    h1 ^= h1 >>> 16;
+    h2 ^= h2 >>> 16;
+    h2 = Math.imul(h2, 0x85ebca6b);
+    h2 ^= h2 >>> 13;
+    h2 = Math.imul(h2, 0xc2b2ae35);
+    h2 ^= h2 >>> 16;
+    h1 += h2;
+    h2 += h1;
+    // Return 64-bit hash as hex string (two 32-bit values concatenated)
+    return (h1 >>> 0).toString(16).padStart(8, '0') + (h2 >>> 0).toString(16).padStart(8, '0');
 };
-//# sourceMappingURL=generate-hash.js.map

package/dist/string/iterate-title.js

@@ -1,12 +1,14 @@
-const iterateTitle = (title, checkDuplicates, separator = " #") => {
-  if (!checkDuplicates(title)) {
-    return title;
-  }
-  const split = title.split(separator);
-  const newTitle = split.length > 1 ? `${split.slice(0, -1).join()}${separator}${Number(split.at(-1)) + 1}` : `${split.join()}${separator}2`;
-  return iterateTitle(newTitle, checkDuplicates, separator);
+/**
+ * Check for duplicate titles, and iterate title
+ */
+export const iterateTitle = (title, checkDuplicates, separator = ' #') => {
+    // If the title is not a duplicate return
+    if (!checkDuplicates(title)) {
+        return title;
+    }
+    const split = title.split(separator);
+    const newTitle = split.length > 1
+        ? `${split.slice(0, -1).join()}${separator}${Number(split.at(-1)) + 1}`
+        : `${split.join()}${separator}2`;
+    return iterateTitle(newTitle, checkDuplicates, separator);
 };
-export {
-  iterateTitle
-};
-//# sourceMappingURL=iterate-title.js.map

package/dist/string/truncate.js

@@ -1,10 +1,17 @@
-const truncate = (str, maxLength = 18) => {
-  if (str.length <= maxLength) {
-    return str;
-  }
-  return str.slice(0, maxLength) + "\u2026";
+/**
+ * Truncates a string to a specified length and adds an ellipsis if it's longer in JS
+ *
+ * @param str - The string to truncate
+ * @param maxLength - The maximum length before truncation (default: 18)
+ * @returns The truncated string with ellipsis if needed
+ *
+ * @example
+ * truncate('Very long name that needs truncation') // 'Very long name th…'
+ * truncate('Short') // 'Short'
+ */
+export const truncate = (str, maxLength = 18) => {
+    if (str.length <= maxLength) {
+        return str;
+    }
+    return str.slice(0, maxLength) + '…';
 };
-export {
-  truncate
-};
-//# sourceMappingURL=truncate.js.map

package/dist/testing/console-spies.js

@@ -1,25 +1,20 @@
-import { vi } from "vitest";
-const consoleWarnSpy = vi.spyOn(console, "warn");
-let isConsoleWarnEnabled = false;
-const consoleErrorSpy = vi.spyOn(console, "error");
-let isConsoleErrorEnabled = false;
-const resetConsoleSpies = () => {
-  consoleWarnSpy.mockClear();
-  consoleErrorSpy.mockClear();
+import { vi } from 'vitest';
+/** Spy on console.warn */
+export const consoleWarnSpy = vi.spyOn(console, 'warn');
+export let isConsoleWarnEnabled = false;
+/** Spy on console.error */
+export const consoleErrorSpy = vi.spyOn(console, 'error');
+export let isConsoleErrorEnabled = false;
+/** Reset the spies */
+export const resetConsoleSpies = () => {
+    consoleWarnSpy.mockClear();
+    consoleErrorSpy.mockClear();
 };
-const enableConsoleWarn = () => isConsoleWarnEnabled = true;
-const disableConsoleWarn = () => isConsoleWarnEnabled = false;
-const enableConsoleError = () => isConsoleErrorEnabled = true;
-const disableConsoleError = () => isConsoleErrorEnabled = false;
-export {
-  consoleErrorSpy,
-  consoleWarnSpy,
-  disableConsoleError,
-  disableConsoleWarn,
-  enableConsoleError,
-  enableConsoleWarn,
-  isConsoleErrorEnabled,
-  isConsoleWarnEnabled,
-  resetConsoleSpies
-};
-//# sourceMappingURL=console-spies.js.map
+/** Helper to re-enable console warn checks */
+export const enableConsoleWarn = () => (isConsoleWarnEnabled = true);
+/** Helper to disable console warn checks */
+export const disableConsoleWarn = () => (isConsoleWarnEnabled = false);
+/** Helper to enable console error checks */
+export const enableConsoleError = () => (isConsoleErrorEnabled = true);
+/** Helper to disable console error checks */
+export const disableConsoleError = () => (isConsoleErrorEnabled = false);

package/dist/testing/measure.js

@@ -1,21 +1,44 @@
-const measureSync = (name, fn) => {
-  const start = performance.now();
-  const result = fn();
-  const end = performance.now();
-  const duration = Math.round(end - start);
-  console.info(`${name}: ${duration} ms`);
-  return result;
+/**
+ * Measures the execution time of a function and logs it.
+ *
+ * Works only with sync functions and returns the result of the measured function.
+ *
+ * @example
+ *
+ * ```ts
+ * // Sync function
+ * const result = measureSync('computation', () => {
+ *   return heavyComputation()
+ * })
+ * ```
+ */
+export const measureSync = (name, fn) => {
+    const start = performance.now();
+    const result = fn();
+    const end = performance.now();
+    const duration = Math.round(end - start);
+    console.info(`${name}: ${duration} ms`);
+    return result;
 };
-const measureAsync = async (name, fn) => {
-  const start = performance.now();
-  const result = await fn();
-  const end = performance.now();
-  const duration = Math.round(end - start);
-  console.info(`${name}: ${duration} ms`);
-  return result;
+/**
+ * Measures the execution time of an async function and logs it.
+ *
+ * Works only with async functions and returns the result of the measured function.
+ *
+ * @example
+ *
+ * ```ts
+ * // Async function
+ * const result = await measure('api-call', async () => {
+ *   return await fetchData()
+ * })
+ * ````
+ */
+export const measureAsync = async (name, fn) => {
+    const start = performance.now();
+    const result = await fn();
+    const end = performance.now();
+    const duration = Math.round(end - start);
+    console.info(`${name}: ${duration} ms`);
+    return result;
 };
-export {
-  measureAsync,
-  measureSync
-};
-//# sourceMappingURL=measure.js.map

package/dist/testing/measure.test-d.js

@@ -1,12 +1,15 @@
-import { describe, vi } from "vitest";
-import { measureAsync, measureSync } from "./measure.js";
+import { describe, vi } from 'vitest';
+import { measureAsync, measureSync } from './measure.js';
 const asyncFunction = vi.fn();
-describe("measureAsync types", async () => {
-  await measureAsync("test", asyncFunction);
-  await measureAsync("test", () => 1);
+describe('measureAsync types', async () => {
+    // works with async methods
+    await measureAsync('test', asyncFunction);
+    // @ts-expect-error should error because `fn` doesn't return a Promise
+    await measureAsync('test', () => 1);
 });
-describe("measureSync types", () => {
-  measureSync("test", () => 1);
-  measureSync("test", asyncFunction);
+describe('measureSync types', () => {
+    // works with sync methods
+    measureSync('test', () => 1);
+    // @ts-expect-error should error because `fn` doesn't return a Promise
+    measureSync('test', asyncFunction);
 });
-//# sourceMappingURL=measure.test-d.js.map

package/dist/testing/sleep.js

@@ -1,5 +1,5 @@
-const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
-export {
-  sleep
-};
-//# sourceMappingURL=sleep.js.map
+/**
+ * Little helper for sleeping for x milliseconds
+ * an async await friendly setTimeout
+ */
+export const sleep = (ms) => new Promise((r) => setTimeout(r, ms));

package/dist/url/ensure-protocol.js

@@ -1,11 +1,9 @@
-import { REGEX } from "../regex/regex-helpers.js";
-function ensureProtocol(url) {
-  if (REGEX.PROTOCOL.test(url)) {
-    return url;
-  }
-  return `http://${url.replace(/^\//, "")}`;
+import { REGEX } from '../regex/regex-helpers.js';
+/** Ensure URL has a protocol prefix */
+export function ensureProtocol(url) {
+    if (REGEX.PROTOCOL.test(url)) {
+        return url;
+    }
+    // Default to http if no protocol is specified
+    return `http://${url.replace(/^\//, '')}`;
 }
-export {
-  ensureProtocol
-};
-//# sourceMappingURL=ensure-protocol.js.map

package/dist/url/extract-server-from-path.js

@@ -1,32 +1,57 @@
-const extractServerFromPath = (path = "") => {
-  if (!path.trim()) {
-    return null;
-  }
-  if (path.startsWith("//")) {
-    try {
-      const url = new URL(`https:${path}`);
-      if (url.origin === "null") {
+/**
+ * Extracts the server from a string, used to check for servers in paths during migration
+ *
+ * @param path - The URL string to parse. If no protocol is provided, the URL API will throw an error.
+ * @returns A tuple of [origin, remainingPath] or null if the input is empty, whitespace-only, or invalid.
+ *
+ * @example
+ * extractServer('https://api.example.com/v1/users?id=123')
+ * // Returns: ['https://api.example.com', '/v1/users?id=123']
+ *
+ * @example
+ * extractServer('/users')
+ * // Returns: null
+ *
+ * @example
+ * extractServer('/users')
+ * // Returns: null
+ *
+ * @example
+ * extractServer('//api.example.com/v1/users')
+ * // Returns: ['//api.example.com', '/v1/users']
+ */
+export const extractServerFromPath = (path = '') => {
+    if (!path.trim()) {
         return null;
-      }
-      const origin = url.origin.replace(/^https?:/, "");
-      const remainingPath = decodeURIComponent(url.pathname) + url.search + url.hash;
-      return [origin, remainingPath];
-    } catch {
-      return null;
     }
-  }
-  try {
-    const url = new URL(path);
-    if (url.origin === "null") {
-      return null;
+    /** Handle protocol-relative URLs (e.g., "//api.example.com") */
+    if (path.startsWith('//')) {
+        try {
+            /** Use dummy protocol to parse, then strip it */
+            const url = new URL(`https:${path}`);
+            if (url.origin === 'null') {
+                return null;
+            }
+            const origin = url.origin.replace(/^https?:/, '');
+            /** Decode pathname to preserve OpenAPI template variables like {userId} */
+            const remainingPath = decodeURIComponent(url.pathname) + url.search + url.hash;
+            return [origin, remainingPath];
+        }
+        catch {
+            return null;
+        }
+    }
+    try {
+        const url = new URL(path);
+        /** URL API returns "null" for file:// and other invalid protocols */
+        if (url.origin === 'null') {
+            return null;
+        }
+        /** Decode pathname to preserve OpenAPI template variables like {userId} */
+        const remainingPath = decodeURIComponent(url.pathname) + url.search + url.hash;
+        return [url.origin, remainingPath];
+    }
+    catch {
+        return null;
     }
-    const remainingPath = decodeURIComponent(url.pathname) + url.search + url.hash;
-    return [url.origin, remainingPath];
-  } catch {
-    return null;
-  }
-};
-export {
-  extractServerFromPath
 };
-//# sourceMappingURL=extract-server-from-path.js.map

package/dist/url/is-local-url.js

@@ -1,21 +1,27 @@
-const LOCAL_HOSTNAMES = ["localhost", "127.0.0.1", "[::1]", "0.0.0.0"];
-const RESERVED_TLDS = ["test", "example", "invalid", "localhost"];
-function isLocalUrl(url) {
-  try {
-    const { hostname } = new URL(url);
-    if (LOCAL_HOSTNAMES.includes(hostname)) {
-      return true;
+/** Obviously local hostnames */
+const LOCAL_HOSTNAMES = ['localhost', '127.0.0.1', '[::1]', '0.0.0.0'];
+/** Reserved TLDs that are guaranteed to never be assigned */
+const RESERVED_TLDS = ['test', 'example', 'invalid', 'localhost'];
+/**
+ * Detect requests to localhost or reserved TLDs
+ */
+export function isLocalUrl(url) {
+    try {
+        const { hostname } = new URL(url);
+        // Check if hostname is in the local hostnames list
+        if (LOCAL_HOSTNAMES.includes(hostname)) {
+            return true;
+        }
+        // Check if hostname ends with a reserved TLD
+        const tld = hostname.split('.').pop();
+        if (tld && RESERVED_TLDS.includes(tld)) {
+            return true;
+        }
+        return false;
     }
-    const tld = hostname.split(".").pop();
-    if (tld && RESERVED_TLDS.includes(tld)) {
-      return true;
+    catch {
+        // If it's not a valid URL, we can't use the proxy anyway,
+        // but it also covers cases like relative URLs (e.g. `openapi.json`).
+        return true;
     }
-    return false;
-  } catch {
-    return true;
-  }
 }
-export {
-  isLocalUrl
-};
-//# sourceMappingURL=is-local-url.js.map