@farm.js/core 0.1.46 → 0.1.48

package/dist/chunk-F3N52U7S.mjs

@@ -0,0 +1,138 @@
+// src/schema-primary-key.ts
+var SUPPORTED_PRIMARY_KEY_TYPES = /* @__PURE__ */ new Set(["id", "uuid", "string", "integer"]);
+function assertSupportedPrimaryKeyField(location, field) {
+  if (!field.primaryKey || SUPPORTED_PRIMARY_KEY_TYPES.has(field.type)) {
+    return;
+  }
+  throw new Error(
+    `Schema primary-key field "${location}" uses unsupported type "${field.type}". Supported types are id, uuid, string, and integer.`
+  );
+}
+
+// src/schema-resolve.ts
+function resolveSchemaModels(ownerKey, schema) {
+  const models = Object.fromEntries(
+    Object.entries(schema.models).map(([modelKey, model]) => [modelKey, cloneSchemaModel(model)])
+  );
+  for (const [modelKey, extension] of Object.entries(schema.extend || {})) {
+    const existing = models[modelKey];
+    models[modelKey] = {
+      ...existing || { fields: {} },
+      ...extension.name ? { name: extension.name } : {},
+      ...extension.description ? { description: extension.description } : {},
+      fields: {
+        ...existing?.fields,
+        ...extension.fields
+      },
+      constraints: [...existing?.constraints || [], ...extension.constraints || []],
+      meta: {
+        ...existing?.meta,
+        ...extension.meta
+      }
+    };
+  }
+  for (const [modelKey, override] of Object.entries(schema.override || {})) {
+    const existing = models[modelKey];
+    if (!existing) {
+      throw new Error(
+        `Schema override for "${ownerKey}.${modelKey}" is invalid because that model does not exist.`
+      );
+    }
+    const fields = {
+      ...existing.fields
+    };
+    for (const [fieldKey, fieldOverride] of Object.entries(override.fields || {})) {
+      const existingField = fields[fieldKey];
+      if (!existingField && !fieldOverride.type) {
+        throw new Error(
+          `Schema override for "${ownerKey}.${modelKey}.${fieldKey}" is missing a field type.`
+        );
+      }
+      fields[fieldKey] = {
+        ...existingField,
+        ...fieldOverride
+      };
+    }
+    models[modelKey] = {
+      ...existing,
+      ...override.name ? { name: override.name } : {},
+      ...override.description ? { description: override.description } : {},
+      fields,
+      constraints: override.constraints || existing.constraints,
+      meta: {
+        ...existing.meta,
+        ...override.meta
+      }
+    };
+  }
+  const resolvedModels = {};
+  for (const [modelKey, model] of Object.entries(models)) {
+    const modelName = model.name || modelKey;
+    const fieldNames = /* @__PURE__ */ new Set();
+    const resolvedFields = {};
+    for (const [fieldKey, field] of Object.entries(model.fields)) {
+      const fieldName = field.name || fieldKey;
+      assertSupportedPrimaryKeyField(`${ownerKey}.${modelKey}.${fieldKey}`, field);
+      if (fieldNames.has(fieldName)) {
+        throw new Error(
+          `Schema model "${ownerKey}.${modelKey}" contains duplicate field name "${fieldName}".`
+        );
+      }
+      fieldNames.add(fieldName);
+      resolvedFields[fieldKey] = {
+        ...field,
+        name: fieldName
+      };
+    }
+    const primaryKeyFields = Object.entries(resolvedFields).filter(([, field]) => field.primaryKey).map(([fieldKey]) => fieldKey);
+    if (primaryKeyFields.length > 1) {
+      throw new Error(
+        `Schema model "${ownerKey}.${modelKey}" defines multiple primary-key fields: ${primaryKeyFields.map((fieldKey) => `"${fieldKey}"`).join(", ")}. Composite primary keys are not supported.`
+      );
+    }
+    for (const constraint of model.constraints || []) {
+      for (const fieldKey of constraint.fields) {
+        if (!Object.prototype.hasOwnProperty.call(resolvedFields, fieldKey)) {
+          throw new Error(
+            `Schema ${constraint.type} constraint on "${ownerKey}.${modelKey}" references missing field "${fieldKey}".`
+          );
+        }
+      }
+    }
+    resolvedModels[modelKey] = {
+      ...model,
+      name: modelName,
+      fields: resolvedFields
+    };
+  }
+  for (const [modelKey, model] of Object.entries(resolvedModels)) {
+    for (const [fieldKey, field] of Object.entries(model.fields)) {
+      const reference = field.reference;
+      if (!reference || !Object.prototype.hasOwnProperty.call(resolvedModels, reference.model)) {
+        continue;
+      }
+      const referencedModel = resolvedModels[reference.model];
+      if (!Object.prototype.hasOwnProperty.call(referencedModel.fields, reference.field)) {
+        throw new Error(
+          `Schema reference "${ownerKey}.${modelKey}.${fieldKey}" targets missing field "${ownerKey}.${reference.model}.${reference.field}".`
+        );
+      }
+    }
+  }
+  return resolvedModels;
+}
+function cloneSchemaModel(model) {
+  return {
+    ...model,
+    fields: Object.fromEntries(
+      Object.entries(model.fields).map(([fieldKey, field]) => [fieldKey, { ...field }])
+    ),
+    constraints: model.constraints ? [...model.constraints] : void 0,
+    meta: model.meta ? { ...model.meta } : void 0
+  };
+}
+
+export {
+  assertSupportedPrimaryKeyField,
+  resolveSchemaModels
+};

package/dist/chunk-F6TLUMH7.mjs

@@ -0,0 +1,172 @@
+import {
+  compileMiddlewareConfig,
+  matchesCompiledMiddlewareConfig
+} from "./chunk-EDPENAVO.mjs";
+import {
+  createFarmAPIMiddlewarePathnames,
+  resolveFarmAPIServerBasePath
+} from "./chunk-LM2YOGDK.mjs";
+import {
+  canonicalizeRequestPathSegments,
+  canonicalizeRequestPathname
+} from "./chunk-OHWM2VI4.mjs";
+import {
+  resolveFarmLocalePath
+} from "./chunk-7S7AAK2D.mjs";
+import {
+  stripFarmBasePath
+} from "./chunk-SF3JB56B.mjs";
+
+// src/integration-middleware-matcher.ts
+function isFarmIntegration(value) {
+  return !!value && typeof value === "object" && value.kind === "farm-integration";
+}
+var compiledIntegrationGuards = /* @__PURE__ */ new WeakMap();
+var noMiddlewareContext = {};
+function resolveIntegrationMiddlewareParams(entry, pathname, config) {
+  const params = resolveMatcherParams(entry.matcher, pathname);
+  if (params || !entry.matcher) return params;
+  const routePathname = resolveIntegrationRoutePathname(pathname, config);
+  const candidates = [.../* @__PURE__ */ new Set([pathname, ...getIntegrationAPIPathnames(config)(routePathname)])];
+  for (const candidate of candidates) {
+    if (candidate === pathname) continue;
+    const routeParams = resolveMatcherParams(entry.matcher, candidate);
+    if (routeParams) return routeParams;
+  }
+  let compiled = compiledIntegrationGuards.get(entry);
+  if (!compiled) {
+    compiled = compileMiddlewareConfig({
+      matcher: typeof entry.matcher === "string" ? entry.matcher : [...entry.matcher]
+    });
+    compiledIntegrationGuards.set(entry, compiled);
+  }
+  for (const candidate of candidates) {
+    const result = matchesCompiledMiddlewareConfig(candidate, compiled, noMiddlewareContext);
+    if (result.matched) return result.params ?? {};
+  }
+  return null;
+}
+function integrationMiddlewareMayHandlePath(integrations, pathname, catchAllProbe) {
+  if (!integrations) return false;
+  const covers = (entry) => resolveIntegrationMiddlewareParams(entry, pathname, void 0) !== null;
+  return Object.values(integrations).some(
+    (integration) => isFarmIntegration(integration) && (integration.middleware || []).some((entry) => {
+      if (catchAllProbe === void 0) return covers(entry);
+      if (!entry.matcher) return false;
+      const specific = (Array.isArray(entry.matcher) ? entry.matcher : [entry.matcher]).filter(
+        (matcher) => resolveIntegrationMiddlewareParams({ matcher }, catchAllProbe, void 0) === null
+      );
+      return specific.length > 0 && covers({ matcher: specific });
+    })
+  );
+}
+var FARM_INTEGRATION_API_BASE_PATH_KEY = "__farmAPIServerBasePath";
+var integrationAPIPathnames = /* @__PURE__ */ new WeakMap();
+function getIntegrationAPIPathnames(config) {
+  if (!config) return (pathname) => [pathname];
+  let toPathnames = integrationAPIPathnames.get(config);
+  if (!toPathnames) {
+    const recorded = config[FARM_INTEGRATION_API_BASE_PATH_KEY];
+    const api = config.api;
+    const serverBasePath = typeof recorded === "string" ? recorded : typeof api?.baseURL === "string" && typeof api.basePath === "string" ? resolveFarmAPIServerBasePath(api) : void 0;
+    toPathnames = createFarmAPIMiddlewarePathnames(serverBasePath);
+    integrationAPIPathnames.set(config, toPathnames);
+  }
+  return toPathnames;
+}
+function resolveIntegrationRoutePathname(pathname, config) {
+  const basePath = typeof config?.basePath === "string" ? config.basePath : void 0;
+  let routePathname = basePath ? stripFarmBasePath(pathname, basePath) : pathname;
+  const i18n = config?.i18n;
+  if (i18n && Array.isArray(i18n.locales) && i18n.locales.length > 0) {
+    routePathname = resolveFarmLocalePath(routePathname, {
+      locales: i18n.locales,
+      defaultLocale: i18n.defaultLocale,
+      routing: i18n.routing || "prefix-except-default"
+    }).pathname;
+  }
+  return routePathname;
+}
+function resolveMatcherParams(matcher, pathname) {
+  if (!matcher) {
+    return {};
+  }
+  const list = Array.isArray(matcher) ? matcher : [matcher];
+  let canonicalPathname;
+  let canonicalSegments;
+  for (const item of list) {
+    if (item === "/(.*)" || item === "*") {
+      return {};
+    }
+    if (item.endsWith("(.*)")) {
+      canonicalPathname ?? (canonicalPathname = canonicalizeRequestPathname(pathname));
+      const prefix = item.slice(0, -4);
+      if (canonicalPathname === prefix || canonicalPathname.startsWith(`${prefix}/`)) {
+        return {};
+      }
+      continue;
+    }
+    canonicalSegments ?? (canonicalSegments = canonicalizeRequestPathSegments(pathname));
+    const params = matchPathSegments(splitPath(item), canonicalSegments);
+    if (params) {
+      return params;
+    }
+  }
+  return null;
+}
+function matchPathSegments(routeSegments, pathSegments) {
+  const params = {};
+  let routeIndex = 0;
+  let pathIndex = 0;
+  while (routeIndex < routeSegments.length && pathIndex < pathSegments.length) {
+    const routeSegment = routeSegments[routeIndex];
+    const pathSegment = pathSegments[pathIndex];
+    if (isCatchAllSegment(routeSegment)) {
+      params[getSegmentParamName(routeSegment)] = pathSegments.slice(pathIndex);
+      return params;
+    }
+    if (isDynamicSegment(routeSegment)) {
+      params[getSegmentParamName(routeSegment)] = pathSegment;
+      routeIndex += 1;
+      pathIndex += 1;
+      continue;
+    }
+    if (routeSegment !== pathSegment) {
+      return null;
+    }
+    routeIndex += 1;
+    pathIndex += 1;
+  }
+  if (routeIndex === routeSegments.length && pathIndex === pathSegments.length) {
+    return params;
+  }
+  if (routeIndex === routeSegments.length - 1 && isCatchAllSegment(routeSegments[routeIndex])) {
+    params[getSegmentParamName(routeSegments[routeIndex])] = [];
+    return params;
+  }
+  return null;
+}
+function splitPath(value) {
+  return value.split("/").filter(Boolean);
+}
+function isDynamicSegment(segment) {
+  return segment.startsWith("[") && segment.endsWith("]");
+}
+function isCatchAllSegment(segment) {
+  return segment.startsWith("[...") && segment.endsWith("]");
+}
+function getSegmentParamName(segment) {
+  if (isCatchAllSegment(segment)) {
+    return segment.slice(4, -1);
+  }
+  return segment.slice(1, -1);
+}
+
+export {
+  isFarmIntegration,
+  resolveIntegrationMiddlewareParams,
+  integrationMiddlewareMayHandlePath,
+  FARM_INTEGRATION_API_BASE_PATH_KEY,
+  matchPathSegments,
+  splitPath
+};

package/dist/chunk-FBEBSAVI.cjs

@@ -0,0 +1,225 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } }
+
+var _chunkHXNLKCWHcjs = require('./chunk-HXNLKCWH.cjs');
+
+
+
+
+
+var _chunk6XQSPIN6cjs = require('./chunk-6XQSPIN6.cjs');
+
+
+var _chunk7JUIK547cjs = require('./chunk-7JUIK547.cjs');
+
+
+var _chunkHNAISJFDcjs = require('./chunk-HNAISJFD.cjs');
+
+// src/plugins/redirects.ts
+function createRedirectsPlugin(redirects, {
+  beforeRequest: overrideBeforeRequest,
+  afterResponse: overrideAfterResponse,
+  i18n
+} = {}) {
+  for (const redirect of redirects) {
+    if (redirect.statusCode !== void 0 && !_chunk7JUIK547cjs.isFarmRedirectStatus.call(void 0, redirect.statusCode)) {
+      throw new RangeError(
+        `Redirect "${redirect.source}" statusCode must be one of 301, 302, 303, 307, or 308.`
+      );
+    }
+  }
+  const compiledRedirects = redirects.map((redirect) => ({
+    redirect,
+    pattern: _chunk6XQSPIN6cjs.compileConfigRoutePattern.call(void 0, redirect.source)
+  }));
+  return {
+    name: "farm:redirects",
+    enforce: "pre",
+    async beforeRequest(req, res, context) {
+      if (overrideBeforeRequest) {
+        await overrideBeforeRequest(req, res, context);
+      }
+      const url = _chunkHNAISJFDcjs.resolveFarmRequestURL.call(void 0, req);
+      const routePath = _chunk6XQSPIN6cjs.resolveConfigRoutePathname.call(void 0, url.pathname, i18n);
+      const pathname = routePath.pathname;
+      for (const { redirect, pattern } of compiledRedirects) {
+        const match = pathname.match(pattern.regex);
+        if (match) {
+          const localizedDestination = _chunk6XQSPIN6cjs.localizeConfigRouteDestination.call(void 0, 
+            _chunk6XQSPIN6cjs.interpolateConfigRouteDestination.call(void 0, redirect.destination, match, pattern.tokens),
+            routePath.locale,
+            i18n
+          );
+          const destination = _chunkHXNLKCWHcjs.appendFarmRedirectQuery.call(void 0, localizedDestination, url.search);
+          const statusCode = _nullishCoalesce(redirect.statusCode, () => ( (redirect.permanent ? 308 : 307)));
+          res.writeHead(statusCode, {
+            Location: destination
+          });
+          res.end();
+          return;
+        }
+      }
+    },
+    async afterResponse(req, res, context) {
+      if (overrideAfterResponse) {
+        await overrideAfterResponse(req, res, context);
+      }
+    }
+  };
+}
+
+// src/plugins/headers.ts
+var FARM_CONFIG_HEADERS_FINALIZER = /* @__PURE__ */ Symbol.for("farm.configHeadersFinalizer");
+function appendConfiguredLinkHeader(res, value) {
+  const current = res.getHeader("Link");
+  if (current === void 0) {
+    res.setHeader("Link", value);
+    return;
+  }
+  const currentValue = Array.isArray(current) ? current.join(", ") : String(current);
+  if (currentValue !== value && !currentValue.endsWith(`, ${value}`)) {
+    res.setHeader("Link", `${currentValue}, ${value}`);
+  }
+}
+function appendConfiguredSetCookieHeader(res, value) {
+  const current = res.getHeader("Set-Cookie");
+  if (current === void 0) {
+    res.setHeader("Set-Cookie", value);
+    return;
+  }
+  const values = (Array.isArray(current) ? current : [current]).map(String);
+  if (!values.includes(value)) {
+    res.setHeader("Set-Cookie", [...values, value]);
+  }
+}
+function applyResponseHeaders(res, matchedHeaders) {
+  for (const headers of matchedHeaders) {
+    for (const header of headers) {
+      const key = header.key.toLowerCase();
+      if (key === "link") {
+        appendConfiguredLinkHeader(res, header.value);
+      } else if (key === "set-cookie") {
+        appendConfiguredSetCookieHeader(res, header.value);
+      } else {
+        res.setHeader(header.key, header.value);
+      }
+    }
+  }
+}
+function applyWriteHeadHeaders(res, headers) {
+  if (Array.isArray(headers)) {
+    let setCookieWritten = false;
+    for (let index = 0; index + 1 < headers.length; index += 2) {
+      const key = String(headers[index]);
+      const value = headers[index + 1];
+      if (key.toLowerCase() === "set-cookie" && setCookieWritten) {
+        const current = res.getHeader("Set-Cookie");
+        const values = (Array.isArray(current) ? current : [current]).filter(
+          (entry) => entry !== void 0
+        );
+        res.setHeader("Set-Cookie", [...values, ...Array.isArray(value) ? value : [value]]);
+      } else {
+        res.setHeader(key, value);
+        if (key.toLowerCase() === "set-cookie") setCookieWritten = true;
+      }
+    }
+    return;
+  }
+  if (!headers || typeof headers !== "object") return;
+  for (const [key, value] of Object.entries(headers)) {
+    if (value !== void 0) res.setHeader(key, value);
+  }
+}
+function createHeadersPlugin(headers, {
+  beforeRequest: overrideBeforeRequest,
+  afterResponse: overrideAfterResponse,
+  i18n
+} = {}) {
+  const compiledHeaders = headers.map((config) => ({
+    config,
+    pattern: _chunk6XQSPIN6cjs.compileConfigRoutePattern.call(void 0, config.source)
+  }));
+  return {
+    name: "farm:headers",
+    enforce: "pre",
+    async beforeRequest(req, res, context) {
+      if (overrideBeforeRequest) {
+        await overrideBeforeRequest(req, res, context);
+      }
+      const url = _chunkHNAISJFDcjs.resolveFarmRequestURL.call(void 0, req);
+      const pathname = _chunk6XQSPIN6cjs.resolveConfigRoutePathname.call(void 0, url.pathname, i18n).pathname;
+      const matchedHeaders = compiledHeaders.filter(({ pattern }) => pattern.regex.test(pathname)).map(({ config }) => config.headers);
+      applyResponseHeaders(res, matchedHeaders);
+      const responseWithFinalizer = res;
+      if (matchedHeaders.length === 0 || responseWithFinalizer[FARM_CONFIG_HEADERS_FINALIZER]) {
+        return;
+      }
+      responseWithFinalizer[FARM_CONFIG_HEADERS_FINALIZER] = true;
+      const writeHead = res.writeHead;
+      res.writeHead = ((statusCode, ...args) => {
+        const statusMessage = typeof args[0] === "string" ? args.shift() : void 0;
+        applyWriteHeadHeaders(res, args[0]);
+        applyResponseHeaders(res, matchedHeaders);
+        return statusMessage === void 0 ? writeHead.call(res, statusCode) : writeHead.call(res, statusCode, statusMessage);
+      });
+    },
+    async afterResponse(req, res, context) {
+      if (overrideAfterResponse) {
+        await overrideAfterResponse(req, res, context);
+      }
+    }
+  };
+}
+
+// src/plugins/env.ts
+function createEnvPlugin(env, {
+  beforeRequest: overrideBeforeRequest,
+  afterResponse: overrideAfterResponse
+} = {}) {
+  return {
+    name: "farm:env",
+    configResolved(config, context) {
+      for (const [key, value] of Object.entries(env)) {
+        process.env[key] = value;
+      }
+    },
+    async beforeRequest(req, res, context) {
+      if (overrideBeforeRequest) {
+        await overrideBeforeRequest(req, res, context);
+      }
+    },
+    async afterResponse(req, res, context) {
+      if (overrideAfterResponse) {
+        await overrideAfterResponse(req, res, context);
+      }
+    }
+  };
+}
+
+// src/plugins/logger.ts
+function createLoggerPlugin({
+  beforeRequest,
+  afterResponse
+} = {}) {
+  const plugin = {
+    name: "farm:logger",
+    enforce: "post"
+  };
+  if (beforeRequest) {
+    plugin.beforeRequest = async (req, res, context) => {
+      await beforeRequest(req, res, context);
+    };
+  }
+  if (afterResponse) {
+    plugin.afterResponse = async (req, res, context) => {
+      await afterResponse(req, res, context);
+    };
+  }
+  return plugin;
+}
+
+
+
+
+
+
+exports.createRedirectsPlugin = createRedirectsPlugin; exports.createHeadersPlugin = createHeadersPlugin; exports.createEnvPlugin = createEnvPlugin; exports.createLoggerPlugin = createLoggerPlugin;

package/dist/chunk-FEFCISOX.cjs

@@ -0,0 +1,102 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }// src/request-origin.ts
+function getRequestSourceOrigin(request) {
+  const origin = _optionalChain([request, 'access', _ => _.headers, 'access', _2 => _2.get, 'call', _3 => _3("origin"), 'optionalAccess', _4 => _4.trim, 'call', _5 => _5()]);
+  if (origin) {
+    return parseSourceOrigin(origin);
+  }
+  const referer = _optionalChain([request, 'access', _6 => _6.headers, 'access', _7 => _7.get, 'call', _8 => _8("referer"), 'optionalAccess', _9 => _9.trim, 'call', _10 => _10()]);
+  if (referer) {
+    return parseSourceOrigin(referer);
+  }
+  return { ok: true, origin: null };
+}
+function parseSourceOrigin(value) {
+  if (value === "null") {
+    return { ok: false, reason: "opaque-origin" };
+  }
+  try {
+    const parsed = new URL(value);
+    if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
+      return { ok: false, reason: "invalid-origin" };
+    }
+    return { ok: true, origin: parsed.origin };
+  } catch (e) {
+    return { ok: false, reason: "invalid-origin" };
+  }
+}
+function matchesHostHeader(sourceOrigin, request) {
+  const host = _optionalChain([request, 'access', _11 => _11.headers, 'access', _12 => _12.get, 'call', _13 => _13("host"), 'optionalAccess', _14 => _14.trim, 'call', _15 => _15(), 'access', _16 => _16.toLowerCase, 'call', _17 => _17()]);
+  if (!host) return false;
+  try {
+    const source = new URL(sourceOrigin);
+    const target = new URL(request.url);
+    return source.protocol === target.protocol && source.host.toLowerCase() === host;
+  } catch (e2) {
+    return false;
+  }
+}
+function matchesAllowedOrigin(sourceOrigin, pattern) {
+  const source = new URL(sourceOrigin);
+  if (!pattern.includes("*")) {
+    return pattern.includes("://") ? source.origin === pattern : source.host === pattern;
+  }
+  const schemeEnd = pattern.indexOf("://");
+  const scheme = schemeEnd === -1 ? null : pattern.slice(0, schemeEnd + 1);
+  const hostPattern = pattern.slice(schemeEnd === -1 ? 0 : schemeEnd + 3);
+  const [wildcardHost, port] = splitHostAndPort(hostPattern);
+  const baseHost = wildcardHost.slice(2);
+  if (scheme && source.protocol !== scheme) return false;
+  if (port && getEffectivePort(source) !== port) return false;
+  if (!port && source.port) return false;
+  return source.hostname.endsWith(`.${baseHost}`) && source.hostname !== baseHost;
+}
+function normalizeAllowedOriginPattern(value, label) {
+  const pattern = value.trim().toLowerCase();
+  if (!pattern) {
+    throw new TypeError(`${label} cannot contain empty values`);
+  }
+  if (pattern.includes("*")) {
+    if (!/^(?:https?:\/\/)?\*\.[a-z0-9.-]+(?::\d+)?$/.test(pattern)) {
+      throw new TypeError(`Invalid ${label} pattern: ${JSON.stringify(value)}`);
+    }
+    return pattern;
+  }
+  if (pattern.includes("://")) {
+    let parsed;
+    try {
+      parsed = new URL(pattern);
+    } catch (e3) {
+      throw new TypeError(`Invalid ${label} value: ${JSON.stringify(value)}`);
+    }
+    if (parsed.protocol !== "http:" && parsed.protocol !== "https:" || parsed.username || parsed.password || parsed.pathname !== "/" || parsed.search || parsed.hash) {
+      throw new TypeError(`${label} must contain origins without paths: ${JSON.stringify(value)}`);
+    }
+    return parsed.origin;
+  }
+  if (/[/@?#]/.test(pattern)) {
+    throw new TypeError(`${label} must contain origins or hosts: ${JSON.stringify(value)}`);
+  }
+  try {
+    return new URL(`http://${pattern}`).host;
+  } catch (e4) {
+    throw new TypeError(`Invalid ${label} value: ${JSON.stringify(value)}`);
+  }
+}
+function splitHostAndPort(value) {
+  const separator = value.lastIndexOf(":");
+  if (separator === -1) return [value, null];
+  return [value.slice(0, separator), value.slice(separator + 1)];
+}
+function getEffectivePort(url) {
+  if (url.port) return url.port;
+  if (url.protocol === "https:") return "443";
+  if (url.protocol === "http:") return "80";
+  return "";
+}
+
+
+
+
+
+
+exports.getRequestSourceOrigin = getRequestSourceOrigin; exports.matchesHostHeader = matchesHostHeader; exports.matchesAllowedOrigin = matchesAllowedOrigin; exports.normalizeAllowedOriginPattern = normalizeAllowedOriginPattern;