@scalar/helpers 0.4.1 → 0.4.2

package/dist/url/is-relative-path.js

@@ -1,14 +1,16 @@
-import { REGEX } from "../regex/regex-helpers.js";
-const isRelativePath = (url) => {
-  if (REGEX.PROTOCOL.test(url)) {
-    return false;
-  }
-  if (/^[a-zA-Z0-9-]+\.[a-zA-Z0-9-.]+(\/|$)/.test(url)) {
-    return false;
-  }
-  return true;
+import { REGEX } from '../regex/regex-helpers.js';
+/**
+ * Check if the URL is relative or if it's a domain without protocol
+ **/
+export 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;
 };
-export {
-  isRelativePath
-};
-//# sourceMappingURL=is-relative-path.js.map

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

@@ -1,11 +1,18 @@
-function isValidUrl(url) {
-  try {
-    return Boolean(new URL(url));
-  } catch {
-    return false;
-  }
+/**
+ * Checks if a given string is a valid URL.
+ *
+ * @param {string} url - The string to be validated as a URL.
+ * @returns {boolean} Returns true if the string is a valid URL, false otherwise.
+ *
+ * @example
+ * isValidUrl('https://www.example.com'); // returns true
+ * isValidUrl('not a url'); // returns false
+ */
+export function isValidUrl(url) {
+    try {
+        return Boolean(new URL(url));
+    }
+    catch {
+        return false;
+    }
 }
-export {
-  isValidUrl
-};
-//# sourceMappingURL=is-valid-url.js.map

package/dist/url/make-url-absolute.js

@@ -1,30 +1,41 @@
-import { combineUrlAndPath } from "../url/merge-urls.js";
-const makeUrlAbsolute = (url, {
-  /** Optional base URL to resolve against (defaults to window.location.href) */
-  baseUrl,
-  /** If we have a basePath then we resolve against window.location.origin + basePath */
-  basePath
-} = {}) => {
-  if (typeof window === "undefined" && !baseUrl) {
-    return url;
-  }
-  try {
-    new URL(url);
-    return url;
-  } catch {
-  }
-  try {
-    let base = baseUrl || window.location.href;
-    if (basePath) {
-      const origin = baseUrl ? new URL(baseUrl).origin : window.location.origin;
-      base = combineUrlAndPath(origin, basePath + "/");
+import { combineUrlAndPath } from '../url/merge-urls.js';
+/**
+ * Converts a relative URL to an absolute URL using the provided base URL or current window location.
+ * @param url - The URL to make absolute
+ * @param options - Configuration options
+ * @param options.baseUrl - Optional base URL to resolve against (defaults to window.location.href)
+ * @param options.basePath - If provided, combines with baseUrl or window.location.origin before resolving
+ * @returns The absolute URL, or the original URL if it's already absolute or invalid
+ */
+export const makeUrlAbsolute = (url, { 
+/** Optional base URL to resolve against (defaults to window.location.href) */
+baseUrl, 
+/** If we have a basePath then we resolve against window.location.origin + basePath */
+basePath, } = {}) => {
+    // If no base URL provided and we're not in a browser environment, return as-is
+    if (typeof window === 'undefined' && !baseUrl) {
+        return url;
+    }
+    try {
+        // If we can create a URL object without a base, it's already absolute
+        new URL(url);
+        return url;
+    }
+    catch {
+        // URL is relative, proceed with resolution
+    }
+    // Use URL constructor which handles path normalization automatically
+    try {
+        let base = baseUrl || window.location.href;
+        // If basePath is provided, combine it with the base URL
+        if (basePath) {
+            const origin = baseUrl ? new URL(baseUrl).origin : window.location.origin;
+            base = combineUrlAndPath(origin, basePath + '/');
+        }
+        return new URL(url, base).toString();
+    }
+    catch {
+        // If URL construction fails, return the original URL
+        return url;
     }
-    return new URL(url, base).toString();
-  } catch {
-    return url;
-  }
-};
-export {
-  makeUrlAbsolute
 };
-//# sourceMappingURL=make-url-absolute.js.map

package/dist/url/merge-urls.js

@@ -1,56 +1,78 @@
-import { REGEX } from "../regex/regex-helpers.js";
-import { isRelativePath } from "./is-relative-path.js";
-import { ensureProtocol } from "./ensure-protocol.js";
-const mergeSearchParams = (...params) => {
-  const merged = {};
-  params.forEach((p) => {
-    const keys = Array.from(p.keys());
-    const uniqueKeys = new Set(keys);
-    uniqueKeys.forEach((key) => {
-      const values = p.getAll(key);
-      const value = values.length > 1 ? values : values[0] ?? "";
-      merged[key] = value;
+import { REGEX } from '../regex/regex-helpers.js';
+import { isRelativePath } from './is-relative-path.js';
+import { ensureProtocol } from './ensure-protocol.js';
+/**
+ * Merges multiple URLSearchParams objects, preserving multiple values per param
+ * within each source, but later sources overwrite earlier ones completely
+ * This should de-dupe our query params while allowing multiple keys for "arrays"
+ */
+export const mergeSearchParams = (...params) => {
+    // We keep a merged record to ensure the next group will overwrite the previous
+    const merged = {};
+    // Loops over each group and grabs unique keys
+    params.forEach((p) => {
+        const keys = Array.from(p.keys());
+        const uniqueKeys = new Set(keys);
+        uniqueKeys.forEach((key) => {
+            const values = p.getAll(key);
+            const value = values.length > 1 ? values : (values[0] ?? '');
+            merged[key] = value;
+        });
     });
-  });
-  const result = new URLSearchParams();
-  Object.entries(merged).forEach(([key, value]) => {
-    if (Array.isArray(value)) {
-      value.forEach((v) => result.append(key, v));
-    } else {
-      result.append(key, value);
-    }
-  });
-  return result;
-};
-const combineUrlAndPath = (url, path) => {
-  if (!path || url === path) {
-    return url.trim();
-  }
-  if (!url) {
-    return path.trim();
-  }
-  return `${url.trim()}/${path.trim()}`.replace(REGEX.MULTIPLE_SLASHES, "/");
+    const result = new URLSearchParams();
+    // We maintain multiple values for each key if they existed
+    Object.entries(merged).forEach(([key, value]) => {
+        if (Array.isArray(value)) {
+            value.forEach((v) => result.append(key, v));
+        }
+        else {
+            result.append(key, value);
+        }
+    });
+    return result;
 };
-const mergeUrls = (url, path, urlParams = new URLSearchParams(), disableOriginPrefix = false) => {
-  if (url && (!isRelativePath(url) || typeof window !== "undefined")) {
-    const base = disableOriginPrefix ? url : isRelativePath(url) ? combineUrlAndPath(window.location.origin, url) : ensureProtocol(url);
-    const [baseUrl = "", baseQuery] = base.split("?");
-    const baseParams = new URLSearchParams(baseQuery || "");
-    const [pathWithoutQuery = "", pathQuery] = path.split("?");
-    const pathParams = new URLSearchParams(pathQuery || "");
-    const mergedUrl = url === path ? baseUrl : combineUrlAndPath(baseUrl, pathWithoutQuery);
-    const mergedSearchParams = mergeSearchParams(baseParams, pathParams, urlParams);
-    const search = mergedSearchParams.toString();
-    return search ? `${mergedUrl}?${search}` : mergedUrl;
-  }
-  if (path) {
-    return combineUrlAndPath(url, path);
-  }
-  return "";
+/** Combines a base URL and a path ensuring there's only one slash between them */
+export const combineUrlAndPath = (url, path) => {
+    if (!path || url === path) {
+        return url.trim();
+    }
+    if (!url) {
+        return path.trim();
+    }
+    return `${url.trim()}/${path.trim()}`.replace(REGEX.MULTIPLE_SLASHES, '/');
 };
-export {
-  combineUrlAndPath,
-  mergeSearchParams,
-  mergeUrls
+/**
+ * Creates a URL from the path and server
+ * also optionally merges query params if you include urlSearchParams
+ * This was re-written without using URL to support variables in the scheme
+ */
+export const mergeUrls = (url, path, urlParams = new URLSearchParams(), 
+/** To disable prefixing the url with the origin or a scheme*/
+disableOriginPrefix = false) => {
+    // Extract and merge all query params
+    if (url && (!isRelativePath(url) || typeof window !== 'undefined')) {
+        /** Prefix the url with the origin if it is relative and we wish to */
+        const base = disableOriginPrefix
+            ? url
+            : isRelativePath(url)
+                ? combineUrlAndPath(window.location.origin, url)
+                : ensureProtocol(url);
+        // Extract search params from base URL if any
+        const [baseUrl = '', baseQuery] = base.split('?');
+        const baseParams = new URLSearchParams(baseQuery || '');
+        // Extract search params from path if any
+        const [pathWithoutQuery = '', pathQuery] = path.split('?');
+        const pathParams = new URLSearchParams(pathQuery || '');
+        // Merge the baseUrl and path
+        const mergedUrl = url === path ? baseUrl : combineUrlAndPath(baseUrl, pathWithoutQuery);
+        // Merge all search params
+        const mergedSearchParams = mergeSearchParams(baseParams, pathParams, urlParams);
+        // Build the final URL
+        const search = mergedSearchParams.toString();
+        return search ? `${mergedUrl}?${search}` : mergedUrl;
+    }
+    if (path) {
+        return combineUrlAndPath(url, path);
+    }
+    return '';
 };
-//# sourceMappingURL=merge-urls.js.map

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

@@ -1,44 +1,73 @@
-import { isLocalUrl } from "./is-local-url.js";
-import { isRelativePath } from "./is-relative-path.js";
-const redirectToProxy = (proxyUrl, url) => {
-  try {
-    if (!shouldUseProxy(proxyUrl, url)) {
-      return url ?? "";
+import { isLocalUrl } from './is-local-url.js';
+import { isRelativePath } from './is-relative-path.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
+ **/
+export const redirectToProxy = (proxyUrl, url) => {
+    try {
+        if (!shouldUseProxy(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;
     }
-    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 ?? "";
-  }
-};
-const shouldUseProxy = (proxyUrl, url) => {
-  try {
-    if (!proxyUrl || !url) {
-      return false;
-    }
-    if (isRelativePath(url)) {
-      return false;
-    }
-    if (isRelativePath(proxyUrl)) {
-      return true;
+    catch {
+        return url ?? '';
     }
-    if (isLocalUrl(proxyUrl)) {
-      return true;
+};
+/**
+ * Returns false for requests to localhost, relative URLs, if no proxy is defined …
+ **/
+export const 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;
     }
-    if (isLocalUrl(url)) {
-      return false;
+    catch {
+        return false;
     }
-    return true;
-  } catch {
-    return false;
-  }
-};
-export {
-  redirectToProxy,
-  shouldUseProxy
 };
-//# sourceMappingURL=redirect-to-proxy.js.map

package/package.json

@@ -14,7 +14,7 @@
     "helpers",
     "js"
   ],
-  "version": "0.4.1",
+  "version": "0.4.2",
   "engines": {
     "node": ">=22"
   },
@@ -99,16 +99,12 @@
   ],
   "devDependencies": {
     "jsdom": "27.4.0",
-    "vite": "^7.3.1",
-    "vitest": "4.0.16",
-    "@scalar/build-tooling": "0.5.0"
+    "vite": "8.0.0",
+    "vitest": "4.1.0"
   },
   "scripts": {
-    "build": "scalar-build-esbuild",
-    "lint:check": "biome lint --diagnostic-level=error",
-    "lint:fix": "biome lint --write",
+    "build": "tsc -p tsconfig.build.json && tsc-alias -p tsconfig.build.json",
     "test": "vitest",
-    "types:build": "scalar-types-build",
-    "types:check": "scalar-types-check"
+    "types:check": "tsc --noEmit"
   }
 }

package/dist/array/add-to-map-array.js.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../src/array/add-to-map-array.ts"],
-  "sourcesContent": ["/**\n * A little helper to add a value to a map array where the type is Map<string, any[]>\n */\nexport const addToMapArray = (map: Map<string, unknown[]>, key: string, value: unknown) => {\n  const prev = map.get(key) ?? []\n  prev.push(value)\n  map.set(key, prev)\n}\n"],
-  "mappings": "AAGO,MAAM,gBAAgB,CAAC,KAA6B,KAAa,UAAmB;AACzF,QAAM,OAAO,IAAI,IAAI,GAAG,KAAK,CAAC;AAC9B,OAAK,KAAK,KAAK;AACf,MAAI,IAAI,KAAK,IAAI;AACnB;",
-  "names": []
-}

package/dist/array/is-defined.js.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../src/array/is-defined.ts"],
-  "sourcesContent": ["/**\n * Type safe alternative to array.filter(Boolean)\n *\n * @example\n *\n * ```ts\n * const dataArray = [1, null, 2, undefined, 3].filter(isDefined)\n * ```\n *\n * @see https://jaketrent.com/post/typescript-type-safe-filter-boolean/\n */\nexport const isDefined = <T>(value: T | null | undefined): value is NonNullable<T> =>\n  value !== null && value !== undefined\n"],
-  "mappings": "AAWO,MAAM,YAAY,CAAI,UAC3B,UAAU,QAAQ,UAAU;",
-  "names": []
-}

package/dist/array/sort-by-order.js.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../src/array/sort-by-order.ts"],
-  "sourcesContent": ["/**\n * Immutably sorts an array based on a given custom order, as specified by a separate list of identifiers.\n *\n * Note: Make sure that the identifier is unique for each item in the array.\n * If the identifier is not unique, only the last occurrence of the identifier will be sorted.\n * Any other elements will be overridden by the last occurrence of the identifier.\n *\n * This function efficiently arranges elements of an input array so that items whose IDs (obtained via the `getId` callback)\n * match the order array will appear first, strictly in the order specified. Items not found in the order array will be\n * appended after, maintaining their original order.\n *\n * This is a flexible utility: the identifier can be extracted from any data structure via the `getId` callback,\n * and any primitive (string, number, symbol, etc.) can serve as the identifier type.\n * Sorting is O(n) with respect to the array size, making it performant even for large arrays.\n *\n * @template T - The type of array elements.\n * @template N - The type of values in the order array and the identifier returned by the getId callback.\n * @param arr - The array to be sorted.\n * @param order - Array specifying the desired sequence (contains identifiers returned by getId).\n * @param getId - A callback to extract the unique identifier from each array element.\n * @returns A new array sorted according to the order provided, with unmatched elements following.\n *\n * @example\n * // Sorting an array of objects:\n * const items = [\n *   { id: 'a', name: 'Alpha' },\n *   { id: 'b', name: 'Bravo' },\n *   { id: 'c', name: 'Charlie' }\n * ];\n * const order = ['c', 'a'];\n * const sorted = sortByOrder(items, order, item => item.id);\n * // Result:\n * // [\n * //   { id: 'c', name: 'Charlie' },\n * //   { id: 'a', name: 'Alpha' },\n * //   { id: 'b', name: 'Bravo' }\n * // ]\n *\n * @example\n * // Sorting an array of primitive values:\n * const input = ['a', 'b', 'c', 'd'];\n * const order = ['c', 'a'];\n * sortByOrder(input, order, item => item);\n * // Result: ['c', 'a', 'b', 'd']\n */\nexport function sortByOrder<T, N>(arr: T[], order: N[], getId: (item: T) => N): T[] {\n  // Map the order to keep a single lookup table\n  const orderMap = new Map<N, number>()\n  order.forEach((e, idx) => orderMap.set(e, idx))\n\n  const sorted: T[] = []\n  const untagged: T[] = []\n\n  arr.forEach((e) => {\n    const sortedIdx = orderMap.get(getId(e))\n    if (sortedIdx === undefined) {\n      untagged.push(e)\n      return\n    }\n    sorted[sortedIdx] = e\n  })\n\n  return [...sorted.filter((it) => it !== undefined), ...untagged]\n}\n"],
-  "mappings": "AA6CO,SAAS,YAAkB,KAAU,OAAY,OAA4B;AAElF,QAAM,WAAW,oBAAI,IAAe;AACpC,QAAM,QAAQ,CAAC,GAAG,QAAQ,SAAS,IAAI,GAAG,GAAG,CAAC;AAE9C,QAAM,SAAc,CAAC;AACrB,QAAM,WAAgB,CAAC;AAEvB,MAAI,QAAQ,CAAC,MAAM;AACjB,UAAM,YAAY,SAAS,IAAI,MAAM,CAAC,CAAC;AACvC,QAAI,cAAc,QAAW;AAC3B,eAAS,KAAK,CAAC;AACf;AAAA,IACF;AACA,WAAO,SAAS,IAAI;AAAA,EACtB,CAAC;AAED,SAAO,CAAC,GAAG,OAAO,OAAO,CAAC,OAAO,OAAO,MAAS,GAAG,GAAG,QAAQ;AACjE;",
-  "names": []
-}

package/dist/consts/content-types.js.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../src/consts/content-types.ts"],
-  "sourcesContent": ["/**\n * Content types that we automatically add in the client\n */\nexport const CONTENT_TYPES = {\n  'multipart/form-data': 'Multipart Form',\n  'application/x-www-form-urlencoded': 'Form URL Encoded',\n  'application/octet-stream': 'Binary File',\n  'application/json': 'JSON',\n  'application/xml': 'XML',\n  'application/yaml': 'YAML',\n  'application/edn': 'EDN',\n  'other': 'Other',\n  'none': 'None',\n} as const\n"],
-  "mappings": "AAGO,MAAM,gBAAgB;AAAA,EAC3B,uBAAuB;AAAA,EACvB,qCAAqC;AAAA,EACrC,4BAA4B;AAAA,EAC5B,oBAAoB;AAAA,EACpB,mBAAmB;AAAA,EACnB,oBAAoB;AAAA,EACpB,mBAAmB;AAAA,EACnB,SAAS;AAAA,EACT,QAAQ;AACV;",
-  "names": []
-}

package/dist/dom/freeze-element.js.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../src/dom/freeze-element.ts"],
-  "sourcesContent": ["/**\n * Scroll Freezing Utility\n * \"Freezes\" the scroll position of an element, so that it doesn't move when the rest of the content changes\n *\n * @example\n * const unfreeze = freezeElement(document.querySelector('#your-element'))\n * ... content changes ...\n * unfreeze()\n */\nexport const freezeElement = (element: HTMLElement) => {\n  if (!element) {\n    return () => null\n  }\n\n  // Get initial position relative to viewport\n  const rect = element.getBoundingClientRect()\n  const initialViewportTop = rect.top\n  let rafId: number | null = null\n\n  // Create mutation observer to watch for DOM changes\n  const observer = new MutationObserver((mutations) => {\n    // Only process if we have mutations that might affect layout\n    const shouldProcess = mutations.some(\n      (mutation) =>\n        mutation.type === 'childList' ||\n        (mutation.type === 'attributes' && (mutation.attributeName === 'style' || mutation.attributeName === 'class')),\n    )\n\n    if (!shouldProcess) {\n      return\n    }\n\n    // Cancel any pending animation frame\n    if (rafId !== null) {\n      cancelAnimationFrame(rafId)\n    }\n\n    // Schedule the scroll adjustment for the next frame\n    rafId = requestAnimationFrame(() => {\n      const newRect = element.getBoundingClientRect()\n      const currentViewportTop = newRect.top\n\n      // If element has moved from its initial viewport position\n      if (currentViewportTop !== initialViewportTop) {\n        // Calculate how far it moved\n        const diff = currentViewportTop - initialViewportTop\n        // Adjust scroll to maintain position\n        window.scrollBy(0, diff)\n      }\n      rafId = null\n    })\n  })\n\n  // Start observing with more specific configuration\n  observer.observe(document.body, {\n    childList: true,\n    subtree: true,\n    attributes: true,\n    attributeFilter: ['style', 'class'],\n    characterData: false,\n  })\n\n  // Return function to stop maintaining position\n  return () => {\n    if (rafId !== null) {\n      cancelAnimationFrame(rafId)\n    }\n    observer.disconnect()\n  }\n}\n"],
-  "mappings": "AASO,MAAM,gBAAgB,CAAC,YAAyB;AACrD,MAAI,CAAC,SAAS;AACZ,WAAO,MAAM;AAAA,EACf;AAGA,QAAM,OAAO,QAAQ,sBAAsB;AAC3C,QAAM,qBAAqB,KAAK;AAChC,MAAI,QAAuB;AAG3B,QAAM,WAAW,IAAI,iBAAiB,CAAC,cAAc;AAEnD,UAAM,gBAAgB,UAAU;AAAA,MAC9B,CAAC,aACC,SAAS,SAAS,eACjB,SAAS,SAAS,iBAAiB,SAAS,kBAAkB,WAAW,SAAS,kBAAkB;AAAA,IACzG;AAEA,QAAI,CAAC,eAAe;AAClB;AAAA,IACF;AAGA,QAAI,UAAU,MAAM;AAClB,2BAAqB,KAAK;AAAA,IAC5B;AAGA,YAAQ,sBAAsB,MAAM;AAClC,YAAM,UAAU,QAAQ,sBAAsB;AAC9C,YAAM,qBAAqB,QAAQ;AAGnC,UAAI,uBAAuB,oBAAoB;AAE7C,cAAM,OAAO,qBAAqB;AAElC,eAAO,SAAS,GAAG,IAAI;AAAA,MACzB;AACA,cAAQ;AAAA,IACV,CAAC;AAAA,EACH,CAAC;AAGD,WAAS,QAAQ,SAAS,MAAM;AAAA,IAC9B,WAAW;AAAA,IACX,SAAS;AAAA,IACT,YAAY;AAAA,IACZ,iBAAiB,CAAC,SAAS,OAAO;AAAA,IAClC,eAAe;AAAA,EACjB,CAAC;AAGD,SAAO,MAAM;AACX,QAAI,UAAU,MAAM;AAClB,2BAAqB,KAAK;AAAA,IAC5B;AACA,aAAS,WAAW;AAAA,EACtB;AACF;",
-  "names": []
-}

package/dist/dom/scroll-to-id.js.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../src/dom/scroll-to-id.ts"],
-  "sourcesContent": ["/**\n * Tiny wrapper around the scrollIntoView API\n *\n * Also focuses the element if the focus flag is true\n */\nexport const scrollToId = (id: string, focus?: boolean): void => {\n  const scrollToElement = (element: HTMLElement) => {\n    element.scrollIntoView()\n    if (focus) {\n      element.focus()\n    }\n  }\n\n  // Try to find the element immediately\n  const element = document.getElementById(id)\n  if (element) {\n    scrollToElement(element)\n    return\n  }\n\n  /** Try to find the element for up to 1 second\n   * allowing it to render for instance in markdown heading usage\n   */\n  const stopTime = Date.now() + 1000\n\n  const tryScroll = (): void => {\n    const element = document.getElementById(id)\n    if (element) {\n      scrollToElement(element)\n      return\n    }\n\n    if (Date.now() < stopTime) {\n      requestAnimationFrame(tryScroll)\n    }\n  }\n\n  // Start the retry process if the element doesn't exist yet\n  requestAnimationFrame(tryScroll)\n}\n"],
-  "mappings": "AAKO,MAAM,aAAa,CAAC,IAAY,UAA0B;AAC/D,QAAM,kBAAkB,CAACA,aAAyB;AAChD,IAAAA,SAAQ,eAAe;AACvB,QAAI,OAAO;AACT,MAAAA,SAAQ,MAAM;AAAA,IAChB;AAAA,EACF;AAGA,QAAM,UAAU,SAAS,eAAe,EAAE;AAC1C,MAAI,SAAS;AACX,oBAAgB,OAAO;AACvB;AAAA,EACF;AAKA,QAAM,WAAW,KAAK,IAAI,IAAI;AAE9B,QAAM,YAAY,MAAY;AAC5B,UAAMA,WAAU,SAAS,eAAe,EAAE;AAC1C,QAAIA,UAAS;AACX,sBAAgBA,QAAO;AACvB;AAAA,IACF;AAEA,QAAI,KAAK,IAAI,IAAI,UAAU;AACzB,4BAAsB,SAAS;AAAA,IACjC;AAAA,EACF;AAGA,wBAAsB,SAAS;AACjC;",
-  "names": ["element"]
-}

package/dist/file/json2xml.js.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../src/file/json2xml.ts"],
-  "sourcesContent": ["/**\n * Character map for XML escaping to prevent XML injection attacks.\n */\nconst XML_ESCAPE_MAP: Record<string, string> = {\n  '&': '&amp;',\n  '<': '&lt;',\n  '>': '&gt;',\n  '\"': '&quot;',\n  \"'\": '&apos;',\n}\n\n/**\n * Escapes special XML characters to prevent injection attacks.\n */\nfunction escapeXml(str: string): string {\n  return str.replace(/[&<>\"']/g, (char) => XML_ESCAPE_MAP[char] ?? char)\n}\n\n/**\n * This function converts an object to XML.\n * Values are automatically escaped to prevent XML injection attacks.\n */\nexport function json2xml(\n  data: Record<string, any>,\n  options: {\n    indent?: string\n    format?: boolean\n    xmlDeclaration?: boolean\n  } = {},\n) {\n  const { indent = '  ', format = true, xmlDeclaration = true } = options\n\n  const toXml = (value: any, key: string, currentIndent: string): string => {\n    let xml = ''\n\n    if (Array.isArray(value)) {\n      for (let i = 0, n = value.length; i < n; i++) {\n        xml += toXml(value[i], key, currentIndent)\n      }\n    } else if (typeof value === 'object' && value !== null) {\n      let hasChild = false\n      let attributes = ''\n      let children = ''\n\n      // Handle attributes (keys starting with @)\n      for (const attr in value) {\n        if (attr.charAt(0) === '@') {\n          attributes += ' ' + attr.substr(1) + '=\"' + escapeXml(value[attr].toString()) + '\"'\n        }\n      }\n\n      // Handle children and special content\n      for (const child in value) {\n        if (child === '#text') {\n          children += escapeXml(value[child]?.toString() ?? '')\n        } else if (child === '#cdata') {\n          // Escape ]]> sequences to prevent CDATA injection\n          const cdataContent = value[child]?.toString() ?? ''\n          children += '<![CDATA[' + cdataContent.replace(/]]>/g, ']]]]><![CDATA[>') + ']]>'\n        } else if (child.charAt(0) !== '@') {\n          hasChild = true\n          children += toXml(value[child], child, currentIndent + indent)\n        }\n      }\n\n      if (hasChild || children) {\n        xml += currentIndent + '<' + key + attributes + '>\\n'\n        xml += children\n        xml += currentIndent + '</' + key + '>\\n'\n      } else {\n        xml += currentIndent + '<' + key + attributes + '/>\\n'\n      }\n    } else {\n      xml += currentIndent + '<' + key + '>' + escapeXml(value?.toString() || '') + '</' + key + '>\\n'\n    }\n\n    return xml\n  }\n\n  let xml = ''\n\n  // Add XML declaration if requested\n  if (xmlDeclaration) {\n    xml += '<?xml version=\"1.0\" encoding=\"UTF-8\"?>'\n    if (format) {\n      xml += '\\n'\n    }\n  }\n\n  // Convert data to XML\n  for (const key in data) {\n    if (Object.hasOwn(data, key)) {\n      xml += toXml(data[key], key, '')\n    }\n  }\n\n  // Format or compact the output\n  if (format) {\n    return xml.trim()\n  }\n\n  // Remove all newlines and extra spaces, but keep the XML declaration clean\n  return xml.replace(/\\n/g, '').replace(/>\\s+</g, '><').trim()\n}\n"],
-  "mappings": "AAGA,MAAM,iBAAyC;AAAA,EAC7C,KAAK;AAAA,EACL,KAAK;AAAA,EACL,KAAK;AAAA,EACL,KAAK;AAAA,EACL,KAAK;AACP;AAKA,SAAS,UAAU,KAAqB;AACtC,SAAO,IAAI,QAAQ,YAAY,CAAC,SAAS,eAAe,IAAI,KAAK,IAAI;AACvE;AAMO,SAAS,SACd,MACA,UAII,CAAC,GACL;AACA,QAAM,EAAE,SAAS,MAAM,SAAS,MAAM,iBAAiB,KAAK,IAAI;AAEhE,QAAM,QAAQ,CAAC,OAAY,KAAa,kBAAkC;AACxE,QAAIA,OAAM;AAEV,QAAI,MAAM,QAAQ,KAAK,GAAG;AACxB,eAAS,IAAI,GAAG,IAAI,MAAM,QAAQ,IAAI,GAAG,KAAK;AAC5C,QAAAA,QAAO,MAAM,MAAM,CAAC,GAAG,KAAK,aAAa;AAAA,MAC3C;AAAA,IACF,WAAW,OAAO,UAAU,YAAY,UAAU,MAAM;AACtD,UAAI,WAAW;AACf,UAAI,aAAa;AACjB,UAAI,WAAW;AAGf,iBAAW,QAAQ,OAAO;AACxB,YAAI,KAAK,OAAO,CAAC,MAAM,KAAK;AAC1B,wBAAc,MAAM,KAAK,OAAO,CAAC,IAAI,OAAO,UAAU,MAAM,IAAI,EAAE,SAAS,CAAC,IAAI;AAAA,QAClF;AAAA,MACF;AAGA,iBAAW,SAAS,OAAO;AACzB,YAAI,UAAU,SAAS;AACrB,sBAAY,UAAU,MAAM,KAAK,GAAG,SAAS,KAAK,EAAE;AAAA,QACtD,WAAW,UAAU,UAAU;AAE7B,gBAAM,eAAe,MAAM,KAAK,GAAG,SAAS,KAAK;AACjD,sBAAY,cAAc,aAAa,QAAQ,QAAQ,iBAAiB,IAAI;AAAA,QAC9E,WAAW,MAAM,OAAO,CAAC,MAAM,KAAK;AAClC,qBAAW;AACX,sBAAY,MAAM,MAAM,KAAK,GAAG,OAAO,gBAAgB,MAAM;AAAA,QAC/D;AAAA,MACF;AAEA,UAAI,YAAY,UAAU;AACxB,QAAAA,QAAO,gBAAgB,MAAM,MAAM,aAAa;AAChD,QAAAA,QAAO;AACP,QAAAA,QAAO,gBAAgB,OAAO,MAAM;AAAA,MACtC,OAAO;AACL,QAAAA,QAAO,gBAAgB,MAAM,MAAM,aAAa;AAAA,MAClD;AAAA,IACF,OAAO;AACL,MAAAA,QAAO,gBAAgB,MAAM,MAAM,MAAM,UAAU,OAAO,SAAS,KAAK,EAAE,IAAI,OAAO,MAAM;AAAA,IAC7F;AAEA,WAAOA;AAAA,EACT;AAEA,MAAI,MAAM;AAGV,MAAI,gBAAgB;AAClB,WAAO;AACP,QAAI,QAAQ;AACV,aAAO;AAAA,IACT;AAAA,EACF;AAGA,aAAW,OAAO,MAAM;AACtB,QAAI,OAAO,OAAO,MAAM,GAAG,GAAG;AAC5B,aAAO,MAAM,KAAK,GAAG,GAAG,KAAK,EAAE;AAAA,IACjC;AAAA,EACF;AAGA,MAAI,QAAQ;AACV,WAAO,IAAI,KAAK;AAAA,EAClB;AAGA,SAAO,IAAI,QAAQ,OAAO,EAAE,EAAE,QAAQ,UAAU,IAAI,EAAE,KAAK;AAC7D;",
-  "names": ["xml"]
-}

package/dist/general/create-limiter.js.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../src/general/create-limiter.ts"],
-  "sourcesContent": ["import { Queue } from '../queue/queue'\n\n/**\n * Creates a function that limits the number of concurrent executions of async functions.\n *\n * @param maxConcurrent - Maximum number of concurrent executions allowed\n * @returns A function that wraps async functions to limit their concurrent execution\n *\n * @example\n * ```ts\n * const limiter = createLimiter(2) // Allow max 2 concurrent executions\n *\n * // These will run with max 2 at a time\n * const results = await Promise.all([\n *   limiter(() => fetch('/api/1')),\n *   limiter(() => fetch('/api/2')),\n *   limiter(() => fetch('/api/3')),\n *   limiter(() => fetch('/api/4'))\n * ])\n * ```\n */\nexport function createLimiter(maxConcurrent: number) {\n  let activeCount = 0\n  const queue = new Queue<() => void>()\n\n  const next = () => {\n    if (queue.isEmpty() || activeCount >= maxConcurrent) {\n      return\n    }\n\n    const resolve = queue.dequeue()\n\n    if (resolve) {\n      resolve()\n    }\n  }\n\n  const run = async <T>(fn: () => Promise<T>): Promise<T> => {\n    if (activeCount >= maxConcurrent) {\n      await new Promise<void>((resolve) => queue.enqueue(resolve))\n    }\n\n    activeCount++\n    try {\n      const result = await fn()\n      return result\n    } finally {\n      activeCount--\n      next()\n    }\n  }\n\n  return run\n}\n"],
-  "mappings": "AAAA,SAAS,aAAa;AAqBf,SAAS,cAAc,eAAuB;AACnD,MAAI,cAAc;AAClB,QAAM,QAAQ,IAAI,MAAkB;AAEpC,QAAM,OAAO,MAAM;AACjB,QAAI,MAAM,QAAQ,KAAK,eAAe,eAAe;AACnD;AAAA,IACF;AAEA,UAAM,UAAU,MAAM,QAAQ;AAE9B,QAAI,SAAS;AACX,cAAQ;AAAA,IACV;AAAA,EACF;AAEA,QAAM,MAAM,OAAU,OAAqC;AACzD,QAAI,eAAe,eAAe;AAChC,YAAM,IAAI,QAAc,CAAC,YAAY,MAAM,QAAQ,OAAO,CAAC;AAAA,IAC7D;AAEA;AACA,QAAI;AACF,YAAM,SAAS,MAAM,GAAG;AACxB,aAAO;AAAA,IACT,UAAE;AACA;AACA,WAAK;AAAA,IACP;AAAA,EACF;AAEA,SAAO;AACT;",
-  "names": []
-}

package/dist/general/debounce.js.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../src/general/debounce.ts"],
-  "sourcesContent": ["/**\n * Options for configuring the debounce behavior.\n */\nexport type DebounceOptions = {\n  /** The delay in milliseconds before executing the function. Defaults to 100ms. */\n  delay?: number\n  /** Maximum time in milliseconds to wait before forcing execution, even with continuous calls. */\n  maxWait?: number\n}\n\n/**\n * Creates a debounced function executor that delays execution until after a specified time.\n * Multiple calls with the same key will cancel previous pending executions.\n *\n * This is useful for batching rapid updates (like auto-save or API calls) to avoid\n * unnecessary processing or network requests.\n *\n * @param options - Configuration options for delay, maxWait, and key separator\n * @returns A function that accepts a key array and callback to execute\n *\n * @example\n * const debouncedSave = debounce({ delay: 328 })\n * debouncedSave.execute(['user', '123'], () => saveUser(user))\n *\n * @example\n * // With maxWait to guarantee execution even with continuous calls\n * const debouncedSave = debounce({ delay: 328, maxWait: 2000 })\n * debouncedSave.execute(['user', '123'], () => saveUser(user))\n */\nexport const debounce = (options: DebounceOptions = {}) => {\n  const { delay = 328, maxWait } = options\n  const timeouts = new Map<string, ReturnType<typeof setTimeout>>()\n  const maxWaitTimeouts = new Map<string, ReturnType<typeof setTimeout>>()\n  const latestFunctions = new Map<string, () => unknown | Promise<unknown>>()\n\n  const cleanup = (): void => {\n    timeouts.forEach(clearTimeout)\n    maxWaitTimeouts.forEach(clearTimeout)\n    timeouts.clear()\n    maxWaitTimeouts.clear()\n    latestFunctions.clear()\n  }\n\n  /** Executes the function and cleans up all associated timeouts */\n  const executeAndCleanup = (key: string): void => {\n    // Get the latest function for this key\n    const fn = latestFunctions.get(key)\n\n    // Clear both timeout types\n    const timeout = timeouts.get(key)\n    if (timeout !== undefined) {\n      clearTimeout(timeout)\n      timeouts.delete(key)\n    }\n\n    const maxWaitTimeout = maxWaitTimeouts.get(key)\n    if (maxWaitTimeout !== undefined) {\n      clearTimeout(maxWaitTimeout)\n      maxWaitTimeouts.delete(key)\n    }\n\n    // Clear the latest function reference\n    latestFunctions.delete(key)\n\n    // Execute the function if it exists\n    if (fn !== undefined) {\n      try {\n        fn()\n      } catch {\n        // Errors are silently caught to prevent the debounce mechanism from breaking\n      }\n    }\n  }\n\n  const execute = (key: string, fn: () => unknown | Promise<unknown>): void => {\n    // Store the latest function for this key\n    latestFunctions.set(key, fn)\n\n    // Clear existing debounce timeout\n    const existingTimeout = timeouts.get(key)\n    if (existingTimeout !== undefined) {\n      clearTimeout(existingTimeout)\n    }\n\n    // Set debounce timeout\n    timeouts.set(\n      key,\n      setTimeout(() => executeAndCleanup(key), delay),\n    )\n\n    // Set maxWait timeout only if configured and this is a new sequence\n    if (maxWait !== undefined && !maxWaitTimeouts.has(key)) {\n      maxWaitTimeouts.set(\n        key,\n        setTimeout(() => executeAndCleanup(key), maxWait),\n      )\n    }\n  }\n\n  const flush = (key: string): void => {\n    if (!latestFunctions.has(key)) {\n      return\n    }\n\n    executeAndCleanup(key)\n  }\n\n  const flushAll = (): void => {\n    const keys = [...latestFunctions.keys()]\n    for (const key of keys) {\n      executeAndCleanup(key)\n    }\n  }\n\n  return { execute, cleanup, flush, flushAll }\n}\n"],
-  "mappings": "AA6BO,MAAM,WAAW,CAAC,UAA2B,CAAC,MAAM;AACzD,QAAM,EAAE,QAAQ,KAAK,QAAQ,IAAI;AACjC,QAAM,WAAW,oBAAI,IAA2C;AAChE,QAAM,kBAAkB,oBAAI,IAA2C;AACvE,QAAM,kBAAkB,oBAAI,IAA8C;AAE1E,QAAM,UAAU,MAAY;AAC1B,aAAS,QAAQ,YAAY;AAC7B,oBAAgB,QAAQ,YAAY;AACpC,aAAS,MAAM;AACf,oBAAgB,MAAM;AACtB,oBAAgB,MAAM;AAAA,EACxB;AAGA,QAAM,oBAAoB,CAAC,QAAsB;AAE/C,UAAM,KAAK,gBAAgB,IAAI,GAAG;AAGlC,UAAM,UAAU,SAAS,IAAI,GAAG;AAChC,QAAI,YAAY,QAAW;AACzB,mBAAa,OAAO;AACpB,eAAS,OAAO,GAAG;AAAA,IACrB;AAEA,UAAM,iBAAiB,gBAAgB,IAAI,GAAG;AAC9C,QAAI,mBAAmB,QAAW;AAChC,mBAAa,cAAc;AAC3B,sBAAgB,OAAO,GAAG;AAAA,IAC5B;AAGA,oBAAgB,OAAO,GAAG;AAG1B,QAAI,OAAO,QAAW;AACpB,UAAI;AACF,WAAG;AAAA,MACL,QAAQ;AAAA,MAER;AAAA,IACF;AAAA,EACF;AAEA,QAAM,UAAU,CAAC,KAAa,OAA+C;AAE3E,oBAAgB,IAAI,KAAK,EAAE;AAG3B,UAAM,kBAAkB,SAAS,IAAI,GAAG;AACxC,QAAI,oBAAoB,QAAW;AACjC,mBAAa,eAAe;AAAA,IAC9B;AAGA,aAAS;AAAA,MACP;AAAA,MACA,WAAW,MAAM,kBAAkB,GAAG,GAAG,KAAK;AAAA,IAChD;AAGA,QAAI,YAAY,UAAa,CAAC,gBAAgB,IAAI,GAAG,GAAG;AACtD,sBAAgB;AAAA,QACd;AAAA,QACA,WAAW,MAAM,kBAAkB,GAAG,GAAG,OAAO;AAAA,MAClD;AAAA,IACF;AAAA,EACF;AAEA,QAAM,QAAQ,CAAC,QAAsB;AACnC,QAAI,CAAC,gBAAgB,IAAI,GAAG,GAAG;AAC7B;AAAA,IACF;AAEA,sBAAkB,GAAG;AAAA,EACvB;AAEA,QAAM,WAAW,MAAY;AAC3B,UAAM,OAAO,CAAC,GAAG,gBAAgB,KAAK,CAAC;AACvC,eAAW,OAAO,MAAM;AACtB,wBAAkB,GAAG;AAAA,IACvB;AAAA,EACF;AAEA,SAAO,EAAE,SAAS,SAAS,OAAO,SAAS;AAC7C;",
-  "names": []
-}

package/dist/general/extract-config-secrets.js.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../src/general/extract-config-secrets.ts"],
-  "sourcesContent": ["import { objectEntries } from '../object/object-entries'\n\n/**\n * Mapping of field names to their corresponding x-scalar-secret extension names.\n */\nconst SECRET_FIELD_MAPPINGS = {\n  clientSecret: 'x-scalar-secret-client-secret',\n  password: 'x-scalar-secret-password',\n  token: 'x-scalar-secret-token',\n  username: 'x-scalar-secret-username',\n  value: 'x-scalar-secret-token',\n  'x-scalar-client-id': 'x-scalar-secret-client-id',\n  'x-scalar-redirect-uri': 'x-scalar-secret-redirect-uri',\n} as const\n\n/**\n * Extracts secret fields from the config or the old schemes\n * Maps original field names to their x-scalar-secret extension equivalents.\n */\nexport const extractConfigSecrets = (input: Record<string, unknown>): Record<string, string> =>\n  objectEntries(SECRET_FIELD_MAPPINGS).reduce<Record<string, string>>((result, [field, secretField]) => {\n    const value = input[field]\n    if (value && typeof value === 'string') {\n      result[secretField] = value\n    }\n    return result\n  }, {})\n\n/** Set of all secret fields */\nconst SECRETS_SET = new Set<string>(\n  objectEntries(SECRET_FIELD_MAPPINGS).flatMap(([oldSecret, newSecret]) => [oldSecret, newSecret]),\n)\n\n/** Removes all secret fields from the input object */\nexport const removeSecretFields = (input: Record<string, unknown>): Record<string, unknown> =>\n  objectEntries(input).reduce<Record<string, unknown>>((result, [key, value]) => {\n    if (!SECRETS_SET.has(key)) {\n      result[key] = value\n    }\n    return result\n  }, {})\n"],
-  "mappings": "AAAA,SAAS,qBAAqB;AAK9B,MAAM,wBAAwB;AAAA,EAC5B,cAAc;AAAA,EACd,UAAU;AAAA,EACV,OAAO;AAAA,EACP,UAAU;AAAA,EACV,OAAO;AAAA,EACP,sBAAsB;AAAA,EACtB,yBAAyB;AAC3B;AAMO,MAAM,uBAAuB,CAAC,UACnC,cAAc,qBAAqB,EAAE,OAA+B,CAAC,QAAQ,CAAC,OAAO,WAAW,MAAM;AACpG,QAAM,QAAQ,MAAM,KAAK;AACzB,MAAI,SAAS,OAAO,UAAU,UAAU;AACtC,WAAO,WAAW,IAAI;AAAA,EACxB;AACA,SAAO;AACT,GAAG,CAAC,CAAC;AAGP,MAAM,cAAc,IAAI;AAAA,EACtB,cAAc,qBAAqB,EAAE,QAAQ,CAAC,CAAC,WAAW,SAAS,MAAM,CAAC,WAAW,SAAS,CAAC;AACjG;AAGO,MAAM,qBAAqB,CAAC,UACjC,cAAc,KAAK,EAAE,OAAgC,CAAC,QAAQ,CAAC,KAAK,KAAK,MAAM;AAC7E,MAAI,CAAC,YAAY,IAAI,GAAG,GAAG;AACzB,WAAO,GAAG,IAAI;AAAA,EAChB;AACA,SAAO;AACT,GAAG,CAAC,CAAC;",
-  "names": []
-}

package/dist/general/has-modifier.js.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../src/general/has-modifier.ts"],
-  "sourcesContent": ["import { isMacOS } from './is-mac-os'\n\n/**\n * Checks for the modifier key\n *\n * Which is meta on macOs and ctrl on linux/windows\n */\nexport const hasModifier = (keydown: KeyboardEvent) => {\n  const modifier = isMacOS() ? 'metaKey' : 'ctrlKey'\n  return keydown[modifier]\n}\n"],
-  "mappings": "AAAA,SAAS,eAAe;AAOjB,MAAM,cAAc,CAAC,YAA2B;AACrD,QAAM,WAAW,QAAQ,IAAI,YAAY;AACzC,SAAO,QAAQ,QAAQ;AACzB;",
-  "names": []
-}

package/dist/general/is-mac-os.js.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../src/general/is-mac-os.ts"],
-  "sourcesContent": ["/**\n * Checks whether the user is on macOS\n * Uses the modern navigator.userAgentData API with a fallback to navigator.userAgent\n */\nconst getUserAgentDataPlatform = (nav: Navigator): string | undefined => {\n  const userAgentData: unknown = Reflect.get(nav, 'userAgentData')\n\n  if (!userAgentData || typeof userAgentData !== 'object') {\n    return undefined\n  }\n\n  if (!('platform' in userAgentData) || typeof userAgentData.platform !== 'string') {\n    return undefined\n  }\n\n  return userAgentData.platform\n}\n\nexport const isMacOS = () => {\n  if (typeof navigator === 'undefined') {\n    return false\n  }\n\n  // Modern approach using navigator.userAgentData\n  const userAgentDataPlatform = getUserAgentDataPlatform(navigator)\n  if (userAgentDataPlatform) {\n    return userAgentDataPlatform.toLowerCase().includes('mac')\n  }\n\n  // Fallback to userAgent\n  return /Mac/.test(navigator.userAgent)\n}\n"],
-  "mappings": "AAIA,MAAM,2BAA2B,CAAC,QAAuC;AACvE,QAAM,gBAAyB,QAAQ,IAAI,KAAK,eAAe;AAE/D,MAAI,CAAC,iBAAiB,OAAO,kBAAkB,UAAU;AACvD,WAAO;AAAA,EACT;AAEA,MAAI,EAAE,cAAc,kBAAkB,OAAO,cAAc,aAAa,UAAU;AAChF,WAAO;AAAA,EACT;AAEA,SAAO,cAAc;AACvB;AAEO,MAAM,UAAU,MAAM;AAC3B,MAAI,OAAO,cAAc,aAAa;AACpC,WAAO;AAAA,EACT;AAGA,QAAM,wBAAwB,yBAAyB,SAAS;AAChE,MAAI,uBAAuB;AACzB,WAAO,sBAAsB,YAAY,EAAE,SAAS,KAAK;AAAA,EAC3D;AAGA,SAAO,MAAM,KAAK,UAAU,SAAS;AACvC;",
-  "names": []
-}

package/dist/http/can-method-have-body.js.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../src/http/can-method-have-body.ts"],
-  "sourcesContent": ["import type { HttpMethod } from './http-methods'\n\n/** HTTP Methods which can have a body */\nconst BODY_METHODS = ['post', 'put', 'patch', 'delete'] as const satisfies HttpMethod[]\ntype BodyMethod = (typeof BODY_METHODS)[number]\n\n/** Makes a check to see if this method CAN have a body */\nexport const canMethodHaveBody = (method: HttpMethod): method is BodyMethod =>\n  BODY_METHODS.includes(method.toLowerCase() as BodyMethod)\n"],
-  "mappings": "AAGA,MAAM,eAAe,CAAC,QAAQ,OAAO,SAAS,QAAQ;AAI/C,MAAM,oBAAoB,CAAC,WAChC,aAAa,SAAS,OAAO,YAAY,CAAe;",
-  "names": []
-}

package/dist/http/http-info.js.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../src/http/http-info.ts"],
-  "sourcesContent": ["import type { HttpMethod } from './http-methods'\n\nexport type HttpInfo = {\n  short: string\n  colorClass: `text-${string}`\n  colorVar: `var(--scalar-color-${string})`\n  backgroundColor: string\n}\n\n/**\n * HTTP methods in a specific order\n * Do not change the order\n */\nexport const REQUEST_METHODS = {\n  get: {\n    short: 'GET',\n    colorClass: 'text-blue',\n    colorVar: 'var(--scalar-color-blue)',\n    backgroundColor: 'bg-blue/10',\n  },\n  post: {\n    short: 'POST',\n    colorClass: 'text-green',\n    colorVar: 'var(--scalar-color-green)',\n    backgroundColor: 'bg-green/10',\n  },\n  put: {\n    short: 'PUT',\n    colorClass: 'text-orange',\n    colorVar: 'var(--scalar-color-orange)',\n    backgroundColor: 'bg-orange/10',\n  },\n  patch: {\n    short: 'PATCH',\n    colorClass: 'text-yellow',\n    colorVar: 'var(--scalar-color-yellow)',\n    backgroundColor: 'bg-yellow/10',\n  },\n  delete: {\n    short: 'DEL',\n    colorClass: 'text-red',\n    colorVar: 'var(--scalar-color-red)',\n    backgroundColor: 'bg-red/10',\n  },\n  options: {\n    short: 'OPTS',\n    colorClass: 'text-purple',\n    colorVar: 'var(--scalar-color-purple)',\n    backgroundColor: 'bg-purple/10',\n  },\n  head: {\n    short: 'HEAD',\n    colorClass: 'text-c-2',\n    colorVar: 'var(--scalar-color-2)',\n    backgroundColor: 'bg-c-2/10',\n  },\n  trace: {\n    short: 'TRACE',\n    colorClass: 'text-c-2',\n    colorVar: 'var(--scalar-color-2)',\n    backgroundColor: 'bg-c-2/10',\n  },\n} as const satisfies Record<HttpMethod, HttpInfo>\n\n/**\n * Accepts an HTTP Method name and returns some properties for the tag\n */\nexport const getHttpMethodInfo = (methodName: string) => {\n  const normalizedMethod = methodName.trim().toLowerCase() as HttpMethod\n  return (\n    REQUEST_METHODS[normalizedMethod] ?? {\n      short: normalizedMethod,\n      color: 'text-c-2',\n      backgroundColor: 'bg-c-2',\n    }\n  )\n}\n"],
-  "mappings": "AAaO,MAAM,kBAAkB;AAAA,EAC7B,KAAK;AAAA,IACH,OAAO;AAAA,IACP,YAAY;AAAA,IACZ,UAAU;AAAA,IACV,iBAAiB;AAAA,EACnB;AAAA,EACA,MAAM;AAAA,IACJ,OAAO;AAAA,IACP,YAAY;AAAA,IACZ,UAAU;AAAA,IACV,iBAAiB;AAAA,EACnB;AAAA,EACA,KAAK;AAAA,IACH,OAAO;AAAA,IACP,YAAY;AAAA,IACZ,UAAU;AAAA,IACV,iBAAiB;AAAA,EACnB;AAAA,EACA,OAAO;AAAA,IACL,OAAO;AAAA,IACP,YAAY;AAAA,IACZ,UAAU;AAAA,IACV,iBAAiB;AAAA,EACnB;AAAA,EACA,QAAQ;AAAA,IACN,OAAO;AAAA,IACP,YAAY;AAAA,IACZ,UAAU;AAAA,IACV,iBAAiB;AAAA,EACnB;AAAA,EACA,SAAS;AAAA,IACP,OAAO;AAAA,IACP,YAAY;AAAA,IACZ,UAAU;AAAA,IACV,iBAAiB;AAAA,EACnB;AAAA,EACA,MAAM;AAAA,IACJ,OAAO;AAAA,IACP,YAAY;AAAA,IACZ,UAAU;AAAA,IACV,iBAAiB;AAAA,EACnB;AAAA,EACA,OAAO;AAAA,IACL,OAAO;AAAA,IACP,YAAY;AAAA,IACZ,UAAU;AAAA,IACV,iBAAiB;AAAA,EACnB;AACF;AAKO,MAAM,oBAAoB,CAAC,eAAuB;AACvD,QAAM,mBAAmB,WAAW,KAAK,EAAE,YAAY;AACvD,SACE,gBAAgB,gBAAgB,KAAK;AAAA,IACnC,OAAO;AAAA,IACP,OAAO;AAAA,IACP,iBAAiB;AAAA,EACnB;AAEJ;",
-  "names": []
-}

package/dist/http/http-methods.js.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../src/http/http-methods.ts"],
-  "sourcesContent": ["/** All OpenAPI HTTP methods */\nexport const HTTP_METHODS = ['delete', 'get', 'head', 'options', 'patch', 'post', 'put', 'trace'] as const\n\n/** All http methods we support */\nexport type HttpMethod = (typeof HTTP_METHODS)[number]\n\n/** Set of all http methods we support */\nexport const httpMethods = Object.freeze(new Set(HTTP_METHODS))\n"],
-  "mappings": "AACO,MAAM,eAAe,CAAC,UAAU,OAAO,QAAQ,WAAW,SAAS,QAAQ,OAAO,OAAO;AAMzF,MAAM,cAAc,OAAO,OAAO,IAAI,IAAI,YAAY,CAAC;",
-  "names": []
-}