@farm.js/core 0.1.16 → 0.1.18

package/dist/chunk-CXP5U3RW.cjs

@@ -0,0 +1,54 @@
+"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; }
+
+var _chunkS3JO3N4Hcjs = require('./chunk-S3JO3N4H.cjs');
+
+// src/deployment-environment.ts
+function isFarmProductionDeploymentEnvironment(env = process.env) {
+  const environment = normalizeEnvironment(env.VERCEL_ENV);
+  const targetEnvironment = normalizeEnvironment(env.VERCEL_TARGET_ENV);
+  if (environment && environment !== "production") return false;
+  if (targetEnvironment && targetEnvironment !== "production") return false;
+  if (isTrue(env.NETLIFY)) {
+    const context = normalizeEnvironment(env.CONTEXT);
+    if (context && context !== "production") return false;
+  }
+  if (isTrue(env.IS_PULL_REQUEST)) return false;
+  return true;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, isFarmProductionDeploymentEnvironment, "isFarmProductionDeploymentEnvironment");
+function isFarmPreviewDeploymentEnvironment(env) {
+  return resolveFarmPreviewDeployment(env, false);
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, isFarmPreviewDeploymentEnvironment, "isFarmPreviewDeploymentEnvironment");
+function resolveFarmPreviewDeployment(env, builtAsPreview) {
+  const explicit = _optionalChain([env, 'optionalAccess', _ => _.FARM_PREVIEW]);
+  if (isTrue(explicit)) return true;
+  if (isFalse(explicit)) return false;
+  if (builtAsPreview || !env) return builtAsPreview;
+  if (normalizeEnvironment(env.VERCEL_ENV) === "preview") return true;
+  if (isTrue(env.NETLIFY)) {
+    const context = normalizeEnvironment(env.CONTEXT);
+    if (context === "deploy-preview" || context === "branch-deploy") return true;
+  }
+  return isTrue(env.IS_PULL_REQUEST);
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, resolveFarmPreviewDeployment, "resolveFarmPreviewDeployment");
+function normalizeEnvironment(value) {
+  const normalized = _optionalChain([value, 'optionalAccess', _2 => _2.trim, 'call', _3 => _3(), 'access', _4 => _4.toLowerCase, 'call', _5 => _5()]);
+  return normalized || void 0;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, normalizeEnvironment, "normalizeEnvironment");
+function isTrue(value) {
+  return value !== void 0 && ["1", "true", "yes", "on"].includes(value.toLowerCase());
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, isTrue, "isTrue");
+function isFalse(value) {
+  return value !== void 0 && ["0", "false", "no", "off"].includes(value.toLowerCase());
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, isFalse, "isFalse");
+
+
+
+
+
+exports.isFarmProductionDeploymentEnvironment = isFarmProductionDeploymentEnvironment; exports.isFarmPreviewDeploymentEnvironment = isFarmPreviewDeploymentEnvironment; exports.resolveFarmPreviewDeployment = resolveFarmPreviewDeployment;

package/dist/chunk-D2ULAULS.cjs

@@ -0,0 +1,166 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { newObj[key] = obj[key]; } } } newObj.default = obj; return newObj; } } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } 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; }
+
+
+
+
+var _chunkJSROZYYOcjs = require('./chunk-JSROZYYO.cjs');
+
+
+var _chunk4ZFL5GFNcjs = require('./chunk-4ZFL5GFN.cjs');
+
+
+var _chunkS3JO3N4Hcjs = require('./chunk-S3JO3N4H.cjs');
+
+// src/integration-orm.ts
+async function createIntegrationOrm(options) {
+  const [schema, client] = await Promise.all([
+    farmIntegrationSchemaToOrmSchema(options.schema),
+    resolveIntegrationOrmRuntimeClient(options)
+  ]);
+  if (!client) {
+    throw new Error(
+      "Schema-backed integration storage requires a runtime client at farm.config storage.client."
+    );
+  }
+  const { createOrmFromRuntime } = await import("@farming-labs/orm-runtime");
+  return createOrmFromRuntime({
+    schema,
+    client
+  });
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, createIntegrationOrm, "createIntegrationOrm");
+async function resolveIntegrationOrmRuntimeClient(options) {
+  if (options.client !== void 0) {
+    return typeof options.client === "function" ? await options.client() : options.client;
+  }
+  return _chunk4ZFL5GFNcjs.resolveStorageRuntimeClient.call(void 0, _nullishCoalesce(options.storage, () => ( _optionalChain([options, 'access', _ => _.config, 'optionalAccess', _2 => _2.storage]))));
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, resolveIntegrationOrmRuntimeClient, "resolveIntegrationOrmRuntimeClient");
+async function farmIntegrationSchemaToOrmSchema(schema) {
+  for (const [modelKey, modelSchema] of Object.entries(schema.models)) {
+    for (const [fieldKey, fieldSchema] of Object.entries(modelSchema.fields)) {
+      _chunkJSROZYYOcjs.assertNoSchemaListField.call(void 0, 
+        fieldSchema,
+        `${modelKey}.${fieldKey}`,
+        "the Farm integration runtime ORM"
+      );
+    }
+  }
+  const orm = await import("@farming-labs/orm");
+  const models = {};
+  const resolvedModels = _chunkJSROZYYOcjs.resolveSchemaModels.call(void 0, "integration", schema);
+  for (const [modelKey, modelSchema] of Object.entries(resolvedModels)) {
+    models[modelKey] = orm.model({
+      table: _nullishCoalesce(modelSchema.name, () => ( modelKey)),
+      fields: createOrmModelFields(orm, modelKey, modelSchema),
+      constraints: createOrmModelConstraints(modelSchema),
+      description: modelSchema.description
+    });
+  }
+  return orm.defineSchema(models);
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, farmIntegrationSchemaToOrmSchema, "farmIntegrationSchemaToOrmSchema");
+function createOrmModelFields(orm, modelKey, modelSchema) {
+  return Object.fromEntries(
+    Object.entries(modelSchema.fields).map(([fieldKey, fieldSchema]) => [
+      fieldKey,
+      createOrmField(orm, modelKey, fieldKey, fieldSchema)
+    ])
+  );
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, createOrmModelFields, "createOrmModelFields");
+function createOrmField(orm, modelKey, fieldKey, field) {
+  _chunkJSROZYYOcjs.assertSupportedPrimaryKeyField.call(void 0, `integration.${modelKey}.${fieldKey}`, field);
+  let builder = createOrmFieldBuilder(orm, fieldKey, field);
+  if (!field.primaryKey && field.unique) {
+    builder = builder.unique();
+  }
+  if (!field.primaryKey && (field.nullable || field.required === false)) {
+    builder = builder.nullable();
+  }
+  if (field.default !== void 0) {
+    builder = field.type === "datetime" && field.default === "now" ? builder.defaultNow() : builder.default(field.default);
+  }
+  if (field.reference && _chunkJSROZYYOcjs.isDatabaseEnforcedReference.call(void 0, field.reference)) {
+    builder = builder.references(`${field.reference.model}.${field.reference.field}`);
+  }
+  if (field.name && field.name !== fieldKey) {
+    builder = builder.map(field.name);
+  }
+  if (field.description) {
+    builder = builder.describe(field.description);
+  }
+  return builder;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, createOrmField, "createOrmField");
+function createOrmFieldBuilder(orm, fieldKey, field) {
+  if (field.primaryKey) {
+    if (field.type === "integer") {
+      return orm.id({ type: "integer" });
+    }
+    if (field.type === "string") {
+      return new orm.FieldBuilder({
+        kind: "id",
+        nullable: false,
+        unique: true,
+        idType: "string"
+      });
+    }
+    return orm.id();
+  }
+  switch (field.type) {
+    case "id":
+    case "uuid":
+      return orm.string();
+    case "string":
+    case "text":
+      return orm.string();
+    case "boolean":
+      return orm.boolean();
+    case "integer":
+      return orm.integer();
+    case "number":
+      return orm.decimal();
+    case "datetime":
+      return orm.datetime();
+    case "json":
+      return orm.json();
+    case "enum": {
+      if (!_optionalChain([field, 'access', _3 => _3.values, 'optionalAccess', _4 => _4.length])) {
+        throw new Error(`Integration schema enum field "${fieldKey}" must define values.`);
+      }
+      return orm.enumeration(field.values);
+    }
+    default:
+      throw new Error(
+        `Unsupported integration schema field type "${field.type}" for "${fieldKey}".`
+      );
+  }
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, createOrmFieldBuilder, "createOrmFieldBuilder");
+function createOrmModelConstraints(modelSchema) {
+  const unique = [];
+  const indexes = [];
+  for (const constraint of _nullishCoalesce(modelSchema.constraints, () => ( []))) {
+    if (!constraint.fields.length) {
+      continue;
+    }
+    const fields = constraint.fields;
+    if (constraint.type === "unique") {
+      unique.push(fields);
+    } else {
+      indexes.push(fields);
+    }
+  }
+  return {
+    unique,
+    indexes
+  };
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, createOrmModelConstraints, "createOrmModelConstraints");
+
+
+
+
+
+exports.createIntegrationOrm = createIntegrationOrm; exports.resolveIntegrationOrmRuntimeClient = resolveIntegrationOrmRuntimeClient; exports.farmIntegrationSchemaToOrmSchema = farmIntegrationSchemaToOrmSchema;

package/dist/chunk-D7JTOLFK.cjs

@@ -0,0 +1,285 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } 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; }
+
+
+
+var _chunkLTNGXMQ6cjs = require('./chunk-LTNGXMQ6.cjs');
+
+
+var _chunkS3JO3N4Hcjs = require('./chunk-S3JO3N4H.cjs');
+
+// src/server-fn-client.ts
+
+
+
+
+
+
+var _react = require('react');
+
+// src/mutation-retry.ts
+var TRANSIENT_STATUSES = /* @__PURE__ */ new Set([408, 425, 429]);
+function isTransientMutationFailure(context) {
+  if (context.status === void 0) return true;
+  return context.status >= 500 || TRANSIENT_STATUSES.has(context.status);
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, isTransientMutationFailure, "isTransientMutationFailure");
+function readErrorStatus(error) {
+  const status = _optionalChain([error, 'optionalAccess', _ => _.status]);
+  return typeof status === "number" ? status : void 0;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, readErrorStatus, "readErrorStatus");
+async function invokeMutationWithRetry(invoke, retry, shouldContinue) {
+  const maxRetries = _chunkLTNGXMQ6cjs.resolveClientRetryCount.call(void 0, _optionalChain([retry, 'optionalAccess', _2 => _2.count]));
+  if (typeof _optionalChain([retry, 'optionalAccess', _3 => _3.delay]) !== "function") _chunkLTNGXMQ6cjs.resolveClientRetryDelay.call(void 0, _optionalChain([retry, 'optionalAccess', _4 => _4.delay]));
+  const shouldRetryFailure = _nullishCoalesce(_optionalChain([retry, 'optionalAccess', _5 => _5.shouldRetry]), () => ( isTransientMutationFailure));
+  let attempt = 0;
+  while (true) {
+    try {
+      return await invoke();
+    } catch (error) {
+      const failure = error instanceof Error ? error : new Error(String(error));
+      if (attempt >= maxRetries || !shouldContinue() || !shouldRetryFailure({
+        attempt,
+        method: "POST",
+        status: readErrorStatus(error),
+        error: failure
+      })) {
+        throw error;
+      }
+      attempt += 1;
+      const delay = _chunkLTNGXMQ6cjs.resolveClientRetryDelay.call(void 0, 
+        typeof _optionalChain([retry, 'optionalAccess', _6 => _6.delay]) === "function" ? retry.delay(attempt) : _optionalChain([retry, 'optionalAccess', _7 => _7.delay])
+      );
+      if (delay > 0) {
+        await new Promise((resolve) => setTimeout(resolve, delay));
+        if (!shouldContinue()) throw error;
+      }
+    }
+  }
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, invokeMutationWithRetry, "invokeMutationWithRetry");
+
+// src/server-fn-client.ts
+function useServerFn(serverFn, options = {}) {
+  const { initialResult = null, resetOnSubmit = true } = options;
+  const callbacksRef = _react.useRef.call(void 0, {});
+  const requestIdRef = _react.useRef.call(void 0, 0);
+  const lastResetIdRef = _react.useRef.call(void 0, 0);
+  const initialState = {
+    pendingCount: 0,
+    status: "idle",
+    result: initialResult,
+    error: null
+  };
+  const stateRef = _react.useRef.call(void 0, initialState);
+  const [state, setState] = _react.useState.call(void 0, initialState);
+  const setActionState = _react.useCallback.call(void 0, 
+    (value) => {
+      const next = typeof value === "function" ? value(stateRef.current) : value;
+      stateRef.current = next;
+      setState(next);
+    },
+    []
+  );
+  callbacksRef.current = {
+    onError: options.onError,
+    onSettled: options.onSettled,
+    onSuccess: options.onSuccess,
+    throwOnFormError: options.throwOnFormError
+  };
+  const submit = _react.useCallback.call(void 0, 
+    async (input) => {
+      const requestId = ++requestIdRef.current;
+      const formData = isFormData(input) ? input : void 0;
+      const previousResult = stateRef.current.result;
+      const optimisticResult = _optionalChain([options, 'access', _8 => _8.optimistic, 'optionalCall', _9 => _9({
+        input,
+        formData,
+        current: previousResult
+      })]);
+      const hasOptimisticResult = optimisticResult !== void 0;
+      setActionState((current) => {
+        if (requestId < lastResetIdRef.current) return current;
+        const pendingCount = current.pendingCount + 1;
+        if (requestId !== requestIdRef.current) return { ...current, pendingCount };
+        return {
+          pendingCount,
+          status: "pending",
+          result: hasOptimisticResult ? optimisticResult : resetOnSubmit ? null : current.result,
+          error: null
+        };
+      });
+      try {
+        const result = await invokeMutationWithRetry(
+          () => serverFn(input),
+          options.retry,
+          // A reset disowns this submission; stop scheduling retries then.
+          () => requestId >= lastResetIdRef.current
+        );
+        const isLatestRequest = requestId === requestIdRef.current;
+        setActionState((current) => {
+          if (requestId < lastResetIdRef.current) return current;
+          const pendingCount = Math.max(0, current.pendingCount - 1);
+          if (!isLatestRequest) {
+            return {
+              ...current,
+              pendingCount
+            };
+          }
+          return {
+            pendingCount,
+            status: "success",
+            result,
+            error: null
+          };
+        });
+        if (isLatestRequest) {
+          _chunkLTNGXMQ6cjs.notifyClientObserver.call(void 0, callbacksRef.current.onSuccess, [result], "Action onSuccess");
+          if (requestId === requestIdRef.current) {
+            _chunkLTNGXMQ6cjs.notifyClientObserver.call(void 0, 
+              callbacksRef.current.onSettled,
+              [result, null],
+              "Action onSettled"
+            );
+          }
+        }
+        return result;
+      } catch (cause) {
+        const error = normalizeServerFnError(cause);
+        const isLatestRequest = requestId === requestIdRef.current;
+        setActionState((current) => {
+          if (requestId < lastResetIdRef.current) return current;
+          const pendingCount = Math.max(0, current.pendingCount - 1);
+          if (!isLatestRequest) {
+            return {
+              ...current,
+              pendingCount
+            };
+          }
+          return {
+            pendingCount,
+            status: "error",
+            result: hasOptimisticResult && options.rollbackOnError ? previousResult : resetOnSubmit ? null : current.result,
+            error
+          };
+        });
+        if (isLatestRequest) {
+          _chunkLTNGXMQ6cjs.notifyClientObserver.call(void 0, callbacksRef.current.onError, [error], "Action onError");
+          if (requestId === requestIdRef.current) {
+            _chunkLTNGXMQ6cjs.notifyClientObserver.call(void 0, callbacksRef.current.onSettled, [null, error], "Action onSettled");
+          }
+        }
+        throw error;
+      }
+    },
+    [
+      options.optimistic,
+      options.retry,
+      options.rollbackOnError,
+      resetOnSubmit,
+      serverFn,
+      setActionState
+    ]
+  );
+  const formAction = _react.useCallback.call(void 0, 
+    async (formData) => {
+      try {
+        await submit(formData);
+      } catch (error) {
+        if (callbacksRef.current.throwOnFormError) {
+          throw error;
+        }
+      }
+    },
+    [submit]
+  );
+  const reset = _react.useCallback.call(void 0, () => {
+    lastResetIdRef.current = ++requestIdRef.current;
+    setActionState({
+      pendingCount: 0,
+      status: "idle",
+      result: initialResult,
+      error: null
+    });
+  }, [initialResult, setActionState]);
+  return _react.useMemo.call(void 0, 
+    () => ({
+      pending: state.pendingCount > 0,
+      status: state.status,
+      result: state.result,
+      error: state.error,
+      submit,
+      formAction,
+      reset
+    }),
+    [formAction, reset, state.error, state.pendingCount, state.result, state.status, submit]
+  );
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, useServerFn, "useServerFn");
+function useAction(target, options = {}) {
+  const serverFn = resolveServerFnTarget(target);
+  const action = useServerFn(serverFn, options);
+  const formActionRef = _react.useRef.call(void 0, action.formAction);
+  formActionRef.current = action.formAction;
+  const Form = _react.useMemo.call(void 0, () => {
+    const submitForm = /* @__PURE__ */ _chunkS3JO3N4Hcjs.__name.call(void 0, (formData) => formActionRef.current(formData), "submitForm");
+    const ActionForm = /* @__PURE__ */ _chunkS3JO3N4Hcjs.__name.call(void 0, (props) => _react.createElement.call(void 0, "form", {
+      ...props,
+      action: submitForm
+    }), "ActionForm");
+    ActionForm.displayName = "FarmActionForm";
+    return ActionForm;
+  }, []);
+  return _react.useMemo.call(void 0, () => {
+    const call = /* @__PURE__ */ _chunkS3JO3N4Hcjs.__name.call(void 0, ((input) => action.submit(input)), "call");
+    return Object.assign(call, {
+      pending: action.pending,
+      status: action.status,
+      data: action.result,
+      result: action.result,
+      error: action.error,
+      formAction: action.formAction,
+      Form,
+      reset: action.reset
+    });
+  }, [
+    Form,
+    action.error,
+    action.formAction,
+    action.pending,
+    action.reset,
+    action.result,
+    action.status,
+    action.submit
+  ]);
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, useAction, "useAction");
+function resolveServerFnTarget(target) {
+  if (typeof target === "function") return target;
+  if (target && typeof target.action === "function") return target.action;
+  throw new TypeError(
+    "useAction requires a server function or a route with at least one declared action"
+  );
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, resolveServerFnTarget, "resolveServerFnTarget");
+function normalizeServerFnError(error) {
+  if (error instanceof Error) return error;
+  const normalized = new Error(typeof error === "string" ? error : "Server function failed");
+  normalized.cause = error;
+  return normalized;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, normalizeServerFnError, "normalizeServerFnError");
+function isFormData(value) {
+  if (!value || typeof value !== "object") return false;
+  if (typeof FormData !== "undefined" && value instanceof FormData) {
+    return true;
+  }
+  return Object.prototype.toString.call(value) === "[object FormData]" && typeof value.entries === "function";
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, isFormData, "isFormData");
+
+
+
+
+
+exports.invokeMutationWithRetry = invokeMutationWithRetry; exports.useServerFn = useServerFn; exports.useAction = useAction;

package/dist/chunk-DVM4FKZL.cjs

@@ -0,0 +1,169 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } 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; }
+
+var _chunkUS2QVW3Ecjs = require('./chunk-US2QVW3E.cjs');
+
+
+
+var _chunkBIDYX3SLcjs = require('./chunk-BIDYX3SL.cjs');
+
+
+var _chunkNO3WWW3Ncjs = require('./chunk-NO3WWW3N.cjs');
+
+
+var _chunkS3JO3N4Hcjs = require('./chunk-S3JO3N4H.cjs');
+
+// src/plugins/route-pattern.ts
+function validateConfigRouteSource(source, field = "Config route source") {
+  if (typeof source !== "string" || source.length === 0) {
+    throw new TypeError(`${field} must be a non-empty pathname pattern.`);
+  }
+  if (source.trim() !== source) {
+    throw new Error(`${field} cannot contain leading or trailing whitespace.`);
+  }
+  if (!source.startsWith("/")) {
+    throw new Error(`${field} must start with "/".`);
+  }
+  if (source.includes("?") || source.includes("#")) {
+    throw new Error(`${field} must be a pathname without a query string or hash.`);
+  }
+  if (source.includes("\\") || Array.from(source).some((character) => {
+    const code = character.charCodeAt(0);
+    return code <= 31 || code >= 127 && code <= 159;
+  })) {
+    throw new Error(`${field} cannot contain backslashes or control characters.`);
+  }
+  _chunkNO3WWW3Ncjs.assertBrowserStableRoutePath.call(void 0, source);
+  return source;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, validateConfigRouteSource, "validateConfigRouteSource");
+function resolveConfigRoutePathname(pathname, i18n) {
+  const localizedPathname = _optionalChain([i18n, 'optionalAccess', _ => _.enabled]) ? _chunkBIDYX3SLcjs.resolveFarmLocalePath.call(void 0, pathname, i18n) : { pathname };
+  return {
+    pathname: normalizeConfigRoutePathname(_chunkUS2QVW3Ecjs.canonicalizeRequestPathname.call(void 0, localizedPathname.pathname)),
+    ..._optionalChain([i18n, 'optionalAccess', _2 => _2.enabled]) && "locale" in localizedPathname ? { locale: localizedPathname.locale } : {}
+  };
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, resolveConfigRoutePathname, "resolveConfigRoutePathname");
+function normalizeConfigRoutePathname(pathname) {
+  if (!pathname || pathname === "/") return "/";
+  return pathname.endsWith("/") ? pathname.replace(/\/+$/, "") || "/" : pathname;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, normalizeConfigRoutePathname, "normalizeConfigRoutePathname");
+function localizeConfigRouteDestination(destination, locale, i18n) {
+  return locale && _optionalChain([i18n, 'optionalAccess', _3 => _3.enabled]) ? _chunkBIDYX3SLcjs.localizeFarmHref.call(void 0, destination, locale, i18n) : destination;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, localizeConfigRouteDestination, "localizeConfigRouteDestination");
+function appendCatchAll(pattern) {
+  return pattern.endsWith("/") ? `${pattern.slice(0, -1)}(?:/(.*))?` : `${pattern}(.*)`;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, appendCatchAll, "appendCatchAll");
+function escapeRegexCharacter(character) {
+  return /[\\^$.*+?()[\]{}|]/.test(character) ? `\\${character}` : character;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, escapeRegexCharacter, "escapeRegexCharacter");
+function compileConfigRoutePattern(source) {
+  validateConfigRouteSource(source);
+  const tokens = [];
+  let pattern = "";
+  let captureIndex = 1;
+  for (let index = 0; index < source.length; ) {
+    const rest = source.slice(index);
+    const parameter = rest.match(/^:([A-Za-z0-9_]+)(\*)?/);
+    if (parameter) {
+      tokens.push({
+        kind: "param",
+        name: parameter[1],
+        captureIndex,
+        catchAll: parameter[2] === "*"
+      });
+      pattern = parameter[2] ? appendCatchAll(pattern) : `${pattern}([^/]+)`;
+      captureIndex += 1;
+      index += parameter[0].length;
+      continue;
+    }
+    if (source[index] === "*") {
+      tokens.push({ kind: "wildcard", captureIndex });
+      pattern = appendCatchAll(pattern);
+      captureIndex += 1;
+      index += 1;
+      continue;
+    }
+    pattern += escapeRegexCharacter(source[index]);
+    index += 1;
+  }
+  return { regex: new RegExp(`^${pattern}$`), tokens };
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, compileConfigRoutePattern, "compileConfigRoutePattern");
+function interpolateConfigRouteDestination(destination, match, tokens) {
+  const namedCaptures = /* @__PURE__ */ new Map();
+  const wildcardCaptures = [];
+  const captures = /* @__PURE__ */ new Map();
+  for (const token of tokens) {
+    const value = normalizeConfigRouteCapture(
+      match[token.captureIndex] || "",
+      token.kind === "wildcard" || token.catchAll
+    );
+    captures.set(token.captureIndex, value);
+    if (token.kind === "param") {
+      namedCaptures.set(token.name, value);
+    } else {
+      wildcardCaptures.push(value);
+    }
+  }
+  let result = "";
+  let wildcardIndex = 0;
+  for (let index = 0; index < destination.length; ) {
+    const rest = destination.slice(index);
+    const parameter = rest.match(/^:([A-Za-z0-9_]+)(\*)?/);
+    if (parameter) {
+      const value = namedCaptures.get(parameter[1]);
+      result += value === void 0 ? parameter[0] : value;
+      index += parameter[0].length;
+      continue;
+    }
+    const capture = rest.match(/^\$(\d+)/);
+    if (capture) {
+      result += _nullishCoalesce(captures.get(Number(capture[1])), () => ( ""));
+      index += capture[0].length;
+      continue;
+    }
+    if (destination[index] === "*") {
+      result += wildcardCaptures[wildcardIndex] || "";
+      wildcardIndex += 1;
+      index += 1;
+      continue;
+    }
+    result += destination[index];
+    index += 1;
+  }
+  return result;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, interpolateConfigRouteDestination, "interpolateConfigRouteDestination");
+function normalizeConfigRouteCapture(value, catchAll) {
+  const segments = catchAll ? value.split("/").filter(Boolean) : [value];
+  return segments.map((segment) => encodeConfigRouteSegment(decodeConfigRouteSegment(segment))).join("/");
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, normalizeConfigRouteCapture, "normalizeConfigRouteCapture");
+function decodeConfigRouteSegment(segment) {
+  try {
+    return decodeURIComponent(segment);
+  } catch (e) {
+    return segment;
+  }
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, decodeConfigRouteSegment, "decodeConfigRouteSegment");
+function encodeConfigRouteSegment(segment) {
+  return encodeURIComponent(segment).replace(
+    /[!'()*]/g,
+    (character) => `%${character.charCodeAt(0).toString(16).toUpperCase()}`
+  );
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, encodeConfigRouteSegment, "encodeConfigRouteSegment");
+
+
+
+
+
+
+
+exports.validateConfigRouteSource = validateConfigRouteSource; exports.resolveConfigRoutePathname = resolveConfigRoutePathname; exports.localizeConfigRouteDestination = localizeConfigRouteDestination; exports.compileConfigRoutePattern = compileConfigRoutePattern; exports.interpolateConfigRouteDestination = interpolateConfigRouteDestination;