@scalar/helpers 0.4.1 → 0.4.3

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

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.3",
   "engines": {
     "node": ">=22"
   },
@@ -47,6 +47,11 @@
       "types": "./dist/file/*.d.ts",
       "default": "./dist/file/*.js"
     },
+    "./formatters/*": {
+      "import": "./dist/formatters/*.js",
+      "types": "./dist/formatters/*.d.ts",
+      "default": "./dist/formatters/*.js"
+    },
     "./general/*": {
       "import": "./dist/general/*.js",
       "types": "./dist/general/*.d.ts",
@@ -62,6 +67,11 @@
       "types": "./dist/json/*.d.ts",
       "default": "./dist/json/*.js"
     },
+    "./markdown/*": {
+      "import": "./dist/markdown/*.js",
+      "types": "./dist/markdown/*.d.ts",
+      "default": "./dist/markdown/*.js"
+    },
     "./node/*": {
       "import": "./dist/node/*.js",
       "types": "./dist/node/*.d.ts",
@@ -97,18 +107,14 @@
     "dist",
     "CHANGELOG.md"
   ],
+  "sideEffects": false,
   "devDependencies": {
     "jsdom": "27.4.0",
-    "vite": "^7.3.1",
-    "vitest": "4.0.16",
-    "@scalar/build-tooling": "0.5.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"]
-}