@prosopo/better-auth-procaptcha-plugin 0.0.0-stage → 0.0.0

package/coverage/sorter.js

@@ -0,0 +1,205 @@
+/* eslint-disable */
+var addSorting = (function () {
+  "use strict";
+  var cols,
+    currentSort = {
+      index: 0,
+      desc: false,
+    };
+
+  // returns the summary table element
+  function getTable() {
+    return document.querySelector(".coverage-summary");
+  }
+  // returns the thead element of the summary table
+  function getTableHeader() {
+    return getTable().querySelector("thead tr");
+  }
+  // returns the tbody element of the summary table
+  function getTableBody() {
+    return getTable().querySelector("tbody");
+  }
+  // returns the th element for nth column
+  function getNthColumn(n) {
+    return getTableHeader().querySelectorAll("th")[n];
+  }
+
+  function onFilterInput() {
+    const searchValue = document.getElementById("fileSearch").value;
+    const rows = document.getElementsByTagName("tbody")[0].children;
+
+    // Try to create a RegExp from the searchValue. If it fails (invalid regex),
+    // it will be treated as a plain text search
+    let searchRegex;
+    try {
+      searchRegex = new RegExp(searchValue, "i"); // 'i' for case-insensitive
+    } catch (error) {
+      searchRegex = null;
+    }
+
+    for (let i = 0; i < rows.length; i++) {
+      const row = rows[i];
+      let isMatch = false;
+
+      if (searchRegex) {
+        // If a valid regex was created, use it for matching
+        isMatch = searchRegex.test(row.textContent);
+      } else {
+        // Otherwise, fall back to the original plain text search
+        isMatch = row.textContent.toLowerCase().includes(searchValue.toLowerCase());
+      }
+
+      row.style.display = isMatch ? "" : "none";
+    }
+  }
+
+  // loads the search box
+  function addSearchBox() {
+    var template = document.getElementById("filterTemplate");
+    var templateClone = template.content.cloneNode(true);
+    templateClone.getElementById("fileSearch").oninput = onFilterInput;
+    template.parentElement.appendChild(templateClone);
+  }
+
+  // loads all columns
+  function loadColumns() {
+    var colNodes = getTableHeader().querySelectorAll("th"),
+      colNode,
+      cols = [],
+      col,
+      i;
+
+    for (i = 0; i < colNodes.length; i += 1) {
+      colNode = colNodes[i];
+      col = {
+        key: colNode.getAttribute("data-col"),
+        sortable: !colNode.getAttribute("data-nosort"),
+        type: colNode.getAttribute("data-type") || "string",
+      };
+      cols.push(col);
+      if (col.sortable) {
+        col.defaultDescSort = col.type === "number";
+        colNode.innerHTML = colNode.innerHTML + '<span class="sorter"></span>';
+      }
+    }
+    return cols;
+  }
+  // attaches a data attribute to every tr element with an object
+  // of data values keyed by column name
+  function loadRowData(tableRow) {
+    var tableCols = tableRow.querySelectorAll("td"),
+      colNode,
+      col,
+      data = {},
+      i,
+      val;
+    for (i = 0; i < tableCols.length; i += 1) {
+      colNode = tableCols[i];
+      col = cols[i];
+      val = colNode.getAttribute("data-value");
+      if (col.type === "number") {
+        val = Number(val);
+      }
+      data[col.key] = val;
+    }
+    return data;
+  }
+  // loads all row data
+  function loadData() {
+    var rows = getTableBody().querySelectorAll("tr"),
+      i;
+
+    for (i = 0; i < rows.length; i += 1) {
+      rows[i].data = loadRowData(rows[i]);
+    }
+  }
+  // sorts the table using the data for the ith column
+  function sortByIndex(index, desc) {
+    var key = cols[index].key,
+      sorter = function (a, b) {
+        a = a.data[key];
+        b = b.data[key];
+        return a < b ? -1 : a > b ? 1 : 0;
+      },
+      finalSorter = sorter,
+      tableBody = document.querySelector(".coverage-summary tbody"),
+      rowNodes = tableBody.querySelectorAll("tr"),
+      rows = [],
+      i;
+
+    if (desc) {
+      finalSorter = function (a, b) {
+        return -1 * sorter(a, b);
+      };
+    }
+
+    for (i = 0; i < rowNodes.length; i += 1) {
+      rows.push(rowNodes[i]);
+      tableBody.removeChild(rowNodes[i]);
+    }
+
+    rows.sort(finalSorter);
+
+    for (i = 0; i < rows.length; i += 1) {
+      tableBody.appendChild(rows[i]);
+    }
+  }
+  // removes sort indicators for current column being sorted
+  function removeSortIndicators() {
+    var col = getNthColumn(currentSort.index),
+      cls = col.className;
+
+    cls = cls.replace(/ sorted$/, "").replace(/ sorted-desc$/, "");
+    col.className = cls;
+  }
+  // adds sort indicators for current column being sorted
+  function addSortIndicators() {
+    getNthColumn(currentSort.index).className += currentSort.desc ? " sorted-desc" : " sorted";
+  }
+  // adds event listeners for all sorter widgets
+  function enableUI() {
+    var i,
+      el,
+      ithSorter = function ithSorter(i) {
+        var col = cols[i];
+
+        return function () {
+          var desc = col.defaultDescSort;
+
+          if (currentSort.index === i) {
+            desc = !currentSort.desc;
+          }
+          sortByIndex(i, desc);
+          removeSortIndicators();
+          currentSort.index = i;
+          currentSort.desc = desc;
+          addSortIndicators();
+        };
+      };
+    for (i = 0; i < cols.length; i += 1) {
+      if (cols[i].sortable) {
+        // add the click event handler on the th so users
+        // dont have to click on those tiny arrows
+        el = getNthColumn(i).querySelector(".sorter").parentElement;
+        if (el.addEventListener) {
+          el.addEventListener("click", ithSorter(i));
+        } else {
+          el.attachEvent("onclick", ithSorter(i));
+        }
+      }
+    }
+  }
+  // adds sorting functionality to the UI
+  return function () {
+    if (!getTable()) {
+      return;
+    }
+    cols = loadColumns();
+    loadData();
+    addSearchBox();
+    addSortIndicators();
+    enableUI();
+  };
+})();
+
+window.addEventListener("load", addSorting);

package/dist/cjs/client.cjs

@@ -0,0 +1,32 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_constants = require("./constants.cjs");
+const require_path = require("./path.cjs");
+//#region src/client.ts
+var procaptchaHeaders = (token, headerName = require_constants.PROCAPTCHA_HEADER) => ({ [headerName]: token });
+var authPathOf = (url, baseURL) => {
+	const requestURL = new URL(url, "http://localhost");
+	const basePath = baseURL ? new URL(baseURL, requestURL).pathname : "";
+	return require_path.normalizeAuthPath(requestURL.pathname, basePath);
+};
+var procaptchaClient = (options = {}) => {
+	const { getToken } = options;
+	const headerName = options.headerName ?? "x-captcha-response";
+	const isProtected = require_path.createPathMatcher(options.endpoints?.length ? options.endpoints : require_constants.DEFAULT_ENDPOINTS);
+	return {
+		id: "procaptcha",
+		$InferServerPlugin: {},
+		fetchPlugins: getToken ? [{
+			id: "procaptcha",
+			name: "procaptcha",
+			hooks: { onRequest: async (context) => {
+				if (context.headers.has(headerName) || !isProtected(authPathOf(context.url, context.baseURL))) return context;
+				const token = await getToken();
+				if (token) context.headers.set(headerName, token);
+				return context;
+			} }
+		}] : []
+	};
+};
+//#endregion
+exports.procaptchaClient = procaptchaClient;
+exports.procaptchaHeaders = procaptchaHeaders;

package/dist/cjs/constants.cjs

@@ -0,0 +1,22 @@
+let better_auth = require("better-auth");
+//#region src/constants.ts
+var PROCAPTCHA_SITEVERIFY_URL = "https://api.prosopo.io/siteverify";
+var PROCAPTCHA_HEADER = "x-captcha-response";
+var DEFAULT_ENDPOINTS = [
+	"/sign-up/email",
+	"/sign-in/email",
+	"/request-password-reset"
+];
+var DEFAULT_TIMEOUT_MS = 1e4;
+var PROCAPTCHA_ERROR_CODES = (0, better_auth.defineErrorCodes)({
+	PROCAPTCHA_MISSING_RESPONSE: "Missing Procaptcha response",
+	PROCAPTCHA_VERIFICATION_FAILED: "Procaptcha verification failed",
+	PROCAPTCHA_SERVICE_UNAVAILABLE: "Procaptcha service unavailable",
+	PROCAPTCHA_UNKNOWN_ERROR: "Something went wrong"
+});
+//#endregion
+exports.DEFAULT_ENDPOINTS = DEFAULT_ENDPOINTS;
+exports.DEFAULT_TIMEOUT_MS = DEFAULT_TIMEOUT_MS;
+exports.PROCAPTCHA_ERROR_CODES = PROCAPTCHA_ERROR_CODES;
+exports.PROCAPTCHA_HEADER = PROCAPTCHA_HEADER;
+exports.PROCAPTCHA_SITEVERIFY_URL = PROCAPTCHA_SITEVERIFY_URL;

package/dist/cjs/index.cjs

@@ -0,0 +1,80 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_constants = require("./constants.cjs");
+const require_path = require("./path.cjs");
+const require_siteverify = require("./siteverify.cjs");
+let better_auth_api = require("better-auth/api");
+//#region src/index.ts
+var errorResponse = (code, status) => ({ response: Response.json({
+	code,
+	message: require_constants.PROCAPTCHA_ERROR_CODES[code].message
+}, { status }) });
+var resolveClientIP = (request, options) => (0, better_auth_api.getIP)(request, {
+	...options,
+	advanced: {
+		...options.advanced,
+		ipAddress: {
+			...options.advanced?.ipAddress,
+			ipv6Subnet: 128
+		}
+	}
+}) ?? void 0;
+var readEmailDomain = async (request) => {
+	if (!request.headers.get("content-type")?.includes("application/json")) return;
+	try {
+		const body = await request.clone().json();
+		if (typeof body !== "object" || body === null || !("email" in body)) return;
+		const { email } = body;
+		if (typeof email !== "string") return;
+		const domain = email.slice(email.lastIndexOf("@") + 1).trim();
+		return email.includes("@") && domain ? domain.toLowerCase() : void 0;
+	} catch {
+		return;
+	}
+};
+var procaptcha = (options) => {
+	const isProtected = require_path.createPathMatcher(options.endpoints?.length ? options.endpoints : require_constants.DEFAULT_ENDPOINTS);
+	const headerName = options.headerName ?? "x-captcha-response";
+	return {
+		id: "procaptcha",
+		$ERROR_CODES: require_constants.PROCAPTCHA_ERROR_CODES,
+		onRequest: async (request, ctx) => {
+			const path = require_path.normalizeAuthPath(new URL(request.url).pathname, ctx.options.basePath ?? "/api/auth");
+			if (!isProtected(path)) return;
+			if (!options.secretKey) {
+				ctx.logger.error("Procaptcha: secretKey is not configured");
+				return errorResponse("PROCAPTCHA_UNKNOWN_ERROR", 500);
+			}
+			const token = request.headers.get(headerName);
+			if (!token) return errorResponse("PROCAPTCHA_MISSING_RESPONSE", 400);
+			const ip = options.sendIP === false ? void 0 : resolveClientIP(request, ctx.options);
+			const email = options.sendEmailDomain ? await readEmailDomain(request) : void 0;
+			const result = await require_siteverify.verifyProcaptchaToken({
+				secretKey: options.secretKey,
+				token,
+				...ip ? { ip } : {},
+				...email ? { email } : {},
+				siteVerifyURL: options.siteVerifyURL ?? "https://api.prosopo.io/siteverify",
+				timeoutMs: options.timeoutMs ?? 1e4,
+				...options.fetch ? { fetch: options.fetch } : {}
+			});
+			if (result.outcome === "error") {
+				ctx.logger.error("Procaptcha siteverify failed", {
+					status: result.status,
+					key: result.key,
+					message: result.message
+				});
+				return result.transient ? errorResponse("PROCAPTCHA_SERVICE_UNAVAILABLE", 503) : errorResponse("PROCAPTCHA_UNKNOWN_ERROR", 500);
+			}
+			if (result.outcome === "rejected") return errorResponse("PROCAPTCHA_VERIFICATION_FAILED", 403);
+			if (options.maxScore !== void 0 && result.score !== void 0 && result.score > options.maxScore) return errorResponse("PROCAPTCHA_VERIFICATION_FAILED", 403);
+		},
+		options
+	};
+};
+//#endregion
+exports.DEFAULT_ENDPOINTS = require_constants.DEFAULT_ENDPOINTS;
+exports.PROCAPTCHA_ERROR_CODES = require_constants.PROCAPTCHA_ERROR_CODES;
+exports.PROCAPTCHA_HEADER = require_constants.PROCAPTCHA_HEADER;
+exports.PROCAPTCHA_SITEVERIFY_URL = require_constants.PROCAPTCHA_SITEVERIFY_URL;
+exports.procaptcha = procaptcha;
+exports.verifyProcaptchaToken = require_siteverify.verifyProcaptchaToken;

package/dist/cjs/path.cjs

@@ -0,0 +1,41 @@
+//#region src/path.ts
+var normalizeAuthPath = (pathname, basePath) => {
+	const collapsed = `/${basePath && pathname.startsWith(basePath) ? pathname.slice(basePath.length) : pathname}`.replace(/\/{2,}/g, "/");
+	return collapsed.length > 1 ? collapsed.replace(/\/$/, "") : collapsed;
+};
+var matchesSegment = (pattern, segment) => {
+	const parts = pattern.split("*");
+	if (parts.length === 1) return pattern === segment;
+	const first = parts[0] ?? "";
+	const last = parts[parts.length - 1] ?? "";
+	if (segment.length < first.length + last.length || !segment.startsWith(first) || !segment.endsWith(last)) return false;
+	let cursor = first.length;
+	const end = segment.length - last.length;
+	for (const part of parts.slice(1, -1)) {
+		const found = segment.indexOf(part, cursor);
+		if (found === -1 || found + part.length > end) return false;
+		cursor = found + part.length;
+	}
+	return true;
+};
+var matchesSegments = (patterns, segments) => {
+	const [pattern, ...restPatterns] = patterns;
+	if (pattern === void 0) return segments.length === 0;
+	if (pattern === "**") {
+		for (let skip = 0; skip <= segments.length; skip++) if (matchesSegments(restPatterns, segments.slice(skip))) return true;
+		return false;
+	}
+	const [segment, ...restSegments] = segments;
+	return segment !== void 0 && matchesSegment(pattern, segment) && matchesSegments(restPatterns, restSegments);
+};
+var createPathMatcher = (endpoints) => {
+	const matchers = endpoints.map((endpoint) => {
+		if (!endpoint.includes("*")) return (path) => path === endpoint;
+		const patterns = endpoint.split("/");
+		return (path) => matchesSegments(patterns, path.split("/"));
+	});
+	return (path) => matchers.some((matches) => matches(path));
+};
+//#endregion
+exports.createPathMatcher = createPathMatcher;
+exports.normalizeAuthPath = normalizeAuthPath;

package/dist/cjs/siteverify.cjs

@@ -0,0 +1,68 @@
+const require_constants = require("./constants.cjs");
+//#region src/siteverify.ts
+var isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var isSiteVerifyResponse = (value) => isRecord(value) && typeof value.status === "string" && typeof value.verified === "boolean" && (value.score === void 0 || typeof value.score === "number") && (value.reason === void 0 || typeof value.reason === "string");
+var isSiteVerifyErrorResponse = (value) => isRecord(value) && isRecord(value.error) && typeof value.error.key === "string";
+var readJson = async (response) => {
+	try {
+		return await response.json();
+	} catch {
+		return;
+	}
+};
+var isTransientStatus = (status) => status === 429 || status >= 500;
+var verifyProcaptchaToken = async ({ secretKey, token, ip, email, siteVerifyURL = require_constants.PROCAPTCHA_SITEVERIFY_URL, timeoutMs = require_constants.DEFAULT_TIMEOUT_MS, fetch: fetchImpl = fetch }) => {
+	const body = {
+		secret: secretKey,
+		token,
+		...ip ? { ip } : {},
+		...email ? { email } : {}
+	};
+	let response;
+	try {
+		response = await fetchImpl(siteVerifyURL, {
+			method: "POST",
+			headers: {
+				"Content-Type": "application/json",
+				Accept: "application/json"
+			},
+			body: JSON.stringify(body),
+			signal: AbortSignal.timeout(timeoutMs)
+		});
+	} catch (error) {
+		return {
+			outcome: "error",
+			transient: true,
+			message: error instanceof Error ? error.message : String(error)
+		};
+	}
+	const payload = await readJson(response);
+	if (!response.ok) {
+		const errorBody = isSiteVerifyErrorResponse(payload) ? payload.error : void 0;
+		return {
+			outcome: "error",
+			transient: isTransientStatus(response.status),
+			status: response.status,
+			...errorBody ? { key: errorBody.key } : {},
+			message: typeof errorBody?.message === "string" ? errorBody.message : `siteverify responded with HTTP ${response.status}`
+		};
+	}
+	if (!isSiteVerifyResponse(payload)) return {
+		outcome: "error",
+		transient: true,
+		status: response.status,
+		message: "siteverify returned an unexpected response body"
+	};
+	const score = payload.score === void 0 ? {} : { score: payload.score };
+	if (!payload.verified) return {
+		outcome: "rejected",
+		...payload.reason ? { reason: payload.reason } : {},
+		...score
+	};
+	return {
+		outcome: "verified",
+		...score
+	};
+};
+//#endregion
+exports.verifyProcaptchaToken = verifyProcaptchaToken;

package/dist/esm/_virtual/_rolldown/runtime.js

@@ -0,0 +1,3 @@
+import "node:module";
+//#endregion
+export {};

package/dist/esm/client.js

@@ -0,0 +1,31 @@
+import "./_virtual/_rolldown/runtime.js";
+import { DEFAULT_ENDPOINTS, PROCAPTCHA_HEADER } from "./constants.js";
+import { createPathMatcher, normalizeAuthPath } from "./path.js";
+//#region src/client.ts
+var procaptchaHeaders = (token, headerName = PROCAPTCHA_HEADER) => ({ [headerName]: token });
+var authPathOf = (url, baseURL) => {
+	const requestURL = new URL(url, "http://localhost");
+	const basePath = baseURL ? new URL(baseURL, requestURL).pathname : "";
+	return normalizeAuthPath(requestURL.pathname, basePath);
+};
+var procaptchaClient = (options = {}) => {
+	const { getToken } = options;
+	const headerName = options.headerName ?? "x-captcha-response";
+	const isProtected = createPathMatcher(options.endpoints?.length ? options.endpoints : DEFAULT_ENDPOINTS);
+	return {
+		id: "procaptcha",
+		$InferServerPlugin: {},
+		fetchPlugins: getToken ? [{
+			id: "procaptcha",
+			name: "procaptcha",
+			hooks: { onRequest: async (context) => {
+				if (context.headers.has(headerName) || !isProtected(authPathOf(context.url, context.baseURL))) return context;
+				const token = await getToken();
+				if (token) context.headers.set(headerName, token);
+				return context;
+			} }
+		}] : []
+	};
+};
+//#endregion
+export { procaptchaClient, procaptchaHeaders };

package/dist/esm/constants.js

@@ -0,0 +1,18 @@
+import { defineErrorCodes } from "better-auth";
+//#region src/constants.ts
+var PROCAPTCHA_SITEVERIFY_URL = "https://api.prosopo.io/siteverify";
+var PROCAPTCHA_HEADER = "x-captcha-response";
+var DEFAULT_ENDPOINTS = [
+	"/sign-up/email",
+	"/sign-in/email",
+	"/request-password-reset"
+];
+var DEFAULT_TIMEOUT_MS = 1e4;
+var PROCAPTCHA_ERROR_CODES = defineErrorCodes({
+	PROCAPTCHA_MISSING_RESPONSE: "Missing Procaptcha response",
+	PROCAPTCHA_VERIFICATION_FAILED: "Procaptcha verification failed",
+	PROCAPTCHA_SERVICE_UNAVAILABLE: "Procaptcha service unavailable",
+	PROCAPTCHA_UNKNOWN_ERROR: "Something went wrong"
+});
+//#endregion
+export { DEFAULT_ENDPOINTS, DEFAULT_TIMEOUT_MS, PROCAPTCHA_ERROR_CODES, PROCAPTCHA_HEADER, PROCAPTCHA_SITEVERIFY_URL };

package/dist/esm/index.js

@@ -0,0 +1,75 @@
+import "./_virtual/_rolldown/runtime.js";
+import { DEFAULT_ENDPOINTS, PROCAPTCHA_ERROR_CODES, PROCAPTCHA_HEADER, PROCAPTCHA_SITEVERIFY_URL } from "./constants.js";
+import { createPathMatcher, normalizeAuthPath } from "./path.js";
+import { verifyProcaptchaToken } from "./siteverify.js";
+import { getIP } from "better-auth/api";
+//#region src/index.ts
+var errorResponse = (code, status) => ({ response: Response.json({
+	code,
+	message: PROCAPTCHA_ERROR_CODES[code].message
+}, { status }) });
+var resolveClientIP = (request, options) => getIP(request, {
+	...options,
+	advanced: {
+		...options.advanced,
+		ipAddress: {
+			...options.advanced?.ipAddress,
+			ipv6Subnet: 128
+		}
+	}
+}) ?? void 0;
+var readEmailDomain = async (request) => {
+	if (!request.headers.get("content-type")?.includes("application/json")) return;
+	try {
+		const body = await request.clone().json();
+		if (typeof body !== "object" || body === null || !("email" in body)) return;
+		const { email } = body;
+		if (typeof email !== "string") return;
+		const domain = email.slice(email.lastIndexOf("@") + 1).trim();
+		return email.includes("@") && domain ? domain.toLowerCase() : void 0;
+	} catch {
+		return;
+	}
+};
+var procaptcha = (options) => {
+	const isProtected = createPathMatcher(options.endpoints?.length ? options.endpoints : DEFAULT_ENDPOINTS);
+	const headerName = options.headerName ?? "x-captcha-response";
+	return {
+		id: "procaptcha",
+		$ERROR_CODES: PROCAPTCHA_ERROR_CODES,
+		onRequest: async (request, ctx) => {
+			const path = normalizeAuthPath(new URL(request.url).pathname, ctx.options.basePath ?? "/api/auth");
+			if (!isProtected(path)) return;
+			if (!options.secretKey) {
+				ctx.logger.error("Procaptcha: secretKey is not configured");
+				return errorResponse("PROCAPTCHA_UNKNOWN_ERROR", 500);
+			}
+			const token = request.headers.get(headerName);
+			if (!token) return errorResponse("PROCAPTCHA_MISSING_RESPONSE", 400);
+			const ip = options.sendIP === false ? void 0 : resolveClientIP(request, ctx.options);
+			const email = options.sendEmailDomain ? await readEmailDomain(request) : void 0;
+			const result = await verifyProcaptchaToken({
+				secretKey: options.secretKey,
+				token,
+				...ip ? { ip } : {},
+				...email ? { email } : {},
+				siteVerifyURL: options.siteVerifyURL ?? "https://api.prosopo.io/siteverify",
+				timeoutMs: options.timeoutMs ?? 1e4,
+				...options.fetch ? { fetch: options.fetch } : {}
+			});
+			if (result.outcome === "error") {
+				ctx.logger.error("Procaptcha siteverify failed", {
+					status: result.status,
+					key: result.key,
+					message: result.message
+				});
+				return result.transient ? errorResponse("PROCAPTCHA_SERVICE_UNAVAILABLE", 503) : errorResponse("PROCAPTCHA_UNKNOWN_ERROR", 500);
+			}
+			if (result.outcome === "rejected") return errorResponse("PROCAPTCHA_VERIFICATION_FAILED", 403);
+			if (options.maxScore !== void 0 && result.score !== void 0 && result.score > options.maxScore) return errorResponse("PROCAPTCHA_VERIFICATION_FAILED", 403);
+		},
+		options
+	};
+};
+//#endregion
+export { DEFAULT_ENDPOINTS, PROCAPTCHA_ERROR_CODES, PROCAPTCHA_HEADER, PROCAPTCHA_SITEVERIFY_URL, procaptcha, verifyProcaptchaToken };

package/dist/esm/path.js

@@ -0,0 +1,40 @@
+//#region src/path.ts
+var normalizeAuthPath = (pathname, basePath) => {
+	const collapsed = `/${basePath && pathname.startsWith(basePath) ? pathname.slice(basePath.length) : pathname}`.replace(/\/{2,}/g, "/");
+	return collapsed.length > 1 ? collapsed.replace(/\/$/, "") : collapsed;
+};
+var matchesSegment = (pattern, segment) => {
+	const parts = pattern.split("*");
+	if (parts.length === 1) return pattern === segment;
+	const first = parts[0] ?? "";
+	const last = parts[parts.length - 1] ?? "";
+	if (segment.length < first.length + last.length || !segment.startsWith(first) || !segment.endsWith(last)) return false;
+	let cursor = first.length;
+	const end = segment.length - last.length;
+	for (const part of parts.slice(1, -1)) {
+		const found = segment.indexOf(part, cursor);
+		if (found === -1 || found + part.length > end) return false;
+		cursor = found + part.length;
+	}
+	return true;
+};
+var matchesSegments = (patterns, segments) => {
+	const [pattern, ...restPatterns] = patterns;
+	if (pattern === void 0) return segments.length === 0;
+	if (pattern === "**") {
+		for (let skip = 0; skip <= segments.length; skip++) if (matchesSegments(restPatterns, segments.slice(skip))) return true;
+		return false;
+	}
+	const [segment, ...restSegments] = segments;
+	return segment !== void 0 && matchesSegment(pattern, segment) && matchesSegments(restPatterns, restSegments);
+};
+var createPathMatcher = (endpoints) => {
+	const matchers = endpoints.map((endpoint) => {
+		if (!endpoint.includes("*")) return (path) => path === endpoint;
+		const patterns = endpoint.split("/");
+		return (path) => matchesSegments(patterns, path.split("/"));
+	});
+	return (path) => matchers.some((matches) => matches(path));
+};
+//#endregion
+export { createPathMatcher, normalizeAuthPath };