@vercel/fs-detectors 7.1.7 → 7.2.0

package/dist/services/runtimes/constants.d.ts

@@ -0,0 +1,19 @@
+import type { ServiceRuntime } from '@vercel/build-utils';
+export declare const RUNTIME_BUILDERS: Record<ServiceRuntime, string>;
+export declare const RUNTIME_MANIFESTS: Partial<Record<ServiceRuntime, string[]>>;
+export declare const ENTRYPOINT_EXTENSIONS: Record<string, ServiceRuntime>;
+/**
+ * Builders that produce static output (SPAs, static sites) with no runtime.
+ */
+export declare const STATIC_BUILDERS: Set<string>;
+/**
+ * Builders that produce their own full route table with handle phases
+ * (filesystem, miss, rewrite, hit, error) and should not receive synthetic
+ * catch-all routes from the caller.
+ */
+export declare const ROUTE_OWNING_BUILDERS: Set<string>;
+/**
+ * Blessed Dockerfile/Containerfile names for container services.
+ * Ordered so `.vercel` opt-in markers take precedence during auto-detection.
+ */
+export declare const CONTAINER_ENTRYPOINT_CANDIDATES: readonly ["Dockerfile.vercel", "Containerfile.vercel", "Dockerfile", "Containerfile"];

package/dist/services/runtimes/constants.js

@@ -0,0 +1,85 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var constants_exports = {};
+__export(constants_exports, {
+  CONTAINER_ENTRYPOINT_CANDIDATES: () => CONTAINER_ENTRYPOINT_CANDIDATES,
+  ENTRYPOINT_EXTENSIONS: () => ENTRYPOINT_EXTENSIONS,
+  ROUTE_OWNING_BUILDERS: () => ROUTE_OWNING_BUILDERS,
+  RUNTIME_BUILDERS: () => RUNTIME_BUILDERS,
+  RUNTIME_MANIFESTS: () => RUNTIME_MANIFESTS,
+  STATIC_BUILDERS: () => STATIC_BUILDERS
+});
+module.exports = __toCommonJS(constants_exports);
+const RUNTIME_BUILDERS = {
+  node: "@vercel/backends",
+  python: "@vercel/python",
+  go: "@vercel/go",
+  rust: "@vercel/rust",
+  ruby: "@vercel/ruby",
+  container: "@vercel/container"
+};
+const RUNTIME_MANIFESTS = {
+  node: ["package.json"],
+  python: [
+    "pyproject.toml",
+    "requirements.txt",
+    "Pipfile",
+    "pylock.yml",
+    "uv.lock",
+    "setup.py"
+  ],
+  go: ["go.mod"],
+  ruby: ["Gemfile"],
+  rust: ["Cargo.toml"]
+};
+const ENTRYPOINT_EXTENSIONS = {
+  ".ts": "node",
+  ".mts": "node",
+  ".js": "node",
+  ".mjs": "node",
+  ".cjs": "node",
+  ".py": "python",
+  ".go": "go",
+  ".rs": "rust",
+  ".rb": "ruby",
+  ".ru": "ruby"
+};
+const STATIC_BUILDERS = /* @__PURE__ */ new Set([
+  "@vercel/static-build",
+  "@vercel/static"
+]);
+const ROUTE_OWNING_BUILDERS = /* @__PURE__ */ new Set([
+  "@vercel/next",
+  "@vercel/backends"
+]);
+const CONTAINER_ENTRYPOINT_CANDIDATES = [
+  "Dockerfile.vercel",
+  "Containerfile.vercel",
+  "Dockerfile",
+  "Containerfile"
+];
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CONTAINER_ENTRYPOINT_CANDIDATES,
+  ENTRYPOINT_EXTENSIONS,
+  ROUTE_OWNING_BUILDERS,
+  RUNTIME_BUILDERS,
+  RUNTIME_MANIFESTS,
+  STATIC_BUILDERS
+});

package/dist/services/runtimes/entrypoint.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Parse a Python `module:attr` entrypoint (e.g. `backend.jobs.scheduled:cleanup`)
+ * into a file path and attribute name.
+ *
+ * Returns null if the string is not a valid `module:attr` reference.
+ */
+export declare function parsePyModuleAttrEntrypoint(entrypoint: string): {
+    attrName: string;
+    filePath: string;
+} | null;
+/**
+ * Returns true if the path names a blessed Dockerfile or Containerfile.
+ * Suffixed names like `Dockerfile.prod` are intentionally not matched.
+ */
+export declare function isDockerfileEntrypoint(entrypoint: string): boolean;
+/**
+ * Strip trailing slashes from a posixPath.normalize'd path.
+ * An empty result or lone "/" collapses to ".".
+ */
+export declare function stripTrailingSlash(p: string): string;

package/dist/services/runtimes/entrypoint.js

@@ -0,0 +1,58 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var entrypoint_exports = {};
+__export(entrypoint_exports, {
+  isDockerfileEntrypoint: () => isDockerfileEntrypoint,
+  parsePyModuleAttrEntrypoint: () => parsePyModuleAttrEntrypoint,
+  stripTrailingSlash: () => stripTrailingSlash
+});
+module.exports = __toCommonJS(entrypoint_exports);
+var import_path = require("path");
+var import_constants = require("./constants");
+const PYTHON_MODULE_ATTR_RE = /^([A-Za-z_][\w]*(?:\.[A-Za-z_][\w]*)*):([A-Za-z_][\w]*)$/;
+function parsePyModuleAttrEntrypoint(entrypoint) {
+  const match = PYTHON_MODULE_ATTR_RE.exec(entrypoint);
+  if (!match)
+    return null;
+  const [, modulePart, attrName] = match;
+  if (!modulePart || !attrName)
+    return null;
+  return {
+    attrName,
+    filePath: modulePart.replace(/\./g, "/") + ".py"
+  };
+}
+const CONTAINER_ENTRYPOINT_BASENAMES = new Set(
+  import_constants.CONTAINER_ENTRYPOINT_CANDIDATES.map((name) => name.toLowerCase())
+);
+function isDockerfileEntrypoint(entrypoint) {
+  return CONTAINER_ENTRYPOINT_BASENAMES.has(
+    import_path.posix.basename(entrypoint).toLowerCase()
+  );
+}
+function stripTrailingSlash(p) {
+  const stripped = p.replace(/\/+$/, "");
+  return stripped === "" ? "." : stripped;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  isDockerfileEntrypoint,
+  parsePyModuleAttrEntrypoint,
+  stripTrailingSlash
+});

package/dist/services/runtimes/framework.d.ts

@@ -0,0 +1,25 @@
+import type { ServiceRuntime } from '@vercel/build-utils';
+import type { Framework } from '@vercel/frameworks';
+/**
+ * Framework list filtered to entries eligible for auto-detection.
+ * Includes non-experimental frameworks and runtime frameworks (Python, Node, etc.)
+ * even when marked experimental.
+ */
+export declare const DETECTION_FRAMEWORKS: Framework[];
+/**
+ * Infer runtime from a framework slug.
+ *
+ * Examples:
+ * - `python`  → `python`
+ * - `fastapi` → `python`
+ * - `express` → `node`
+ */
+export declare function inferRuntimeFromFramework(framework: string | null | undefined): ServiceRuntime | undefined;
+/**
+ * Returns true if the framework is a client-only frontend (no server runtime).
+ */
+export declare function isFrontendFramework(framework: string | null | undefined): boolean;
+export declare function isBFFFramework(framework: string | null | undefined): boolean;
+export declare function filterFrameworksByRuntime<T extends {
+    slug?: string | null;
+}>(frameworks: readonly T[], runtime?: ServiceRuntime): T[];

package/dist/services/runtimes/framework.js

@@ -0,0 +1,70 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var framework_exports = {};
+__export(framework_exports, {
+  DETECTION_FRAMEWORKS: () => DETECTION_FRAMEWORKS,
+  filterFrameworksByRuntime: () => filterFrameworksByRuntime,
+  inferRuntimeFromFramework: () => inferRuntimeFromFramework,
+  isBFFFramework: () => isBFFFramework,
+  isFrontendFramework: () => isFrontendFramework
+});
+module.exports = __toCommonJS(framework_exports);
+var import_build_utils = require("@vercel/build-utils");
+var import_frameworks = require("@vercel/frameworks");
+var import_constants = require("./constants");
+const DETECTION_FRAMEWORKS = import_frameworks.frameworkList.filter(
+  (framework) => !framework.experimental || framework.runtimeFramework
+);
+function inferRuntimeFromFramework(framework) {
+  if (!framework)
+    return void 0;
+  if (framework in import_constants.RUNTIME_BUILDERS)
+    return framework;
+  if ((0, import_build_utils.isPythonFramework)(framework))
+    return "python";
+  if ((0, import_build_utils.isBackendFramework)(framework))
+    return "node";
+  return void 0;
+}
+function isFrontendFramework(framework) {
+  return !!framework && !inferRuntimeFromFramework(framework);
+}
+const BFF_FRAMEWORKS = /* @__PURE__ */ new Set([
+  "nextjs",
+  "nuxtjs",
+  "sveltekit",
+  "remix",
+  "solidstart"
+]);
+function isBFFFramework(framework) {
+  return !!framework && BFF_FRAMEWORKS.has(framework);
+}
+function filterFrameworksByRuntime(frameworks, runtime) {
+  if (!runtime)
+    return [...frameworks];
+  return frameworks.filter((f) => inferRuntimeFromFramework(f.slug) === runtime);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DETECTION_FRAMEWORKS,
+  filterFrameworksByRuntime,
+  inferRuntimeFromFramework,
+  isBFFFramework,
+  isFrontendFramework
+});

package/dist/services/runtimes/runtime.d.ts

@@ -0,0 +1,18 @@
+import type { ServiceRuntime } from '@vercel/build-utils';
+export declare function getBuilderForRuntime(runtime: ServiceRuntime): string;
+/**
+ * Infer runtime from available configuration hints.
+ *
+ * Priority (highest to lowest):
+ * 1. Explicit `runtime` field
+ * 2. Runtime framework slug (ruby → ruby, go → go)
+ * 3. Framework detection (fastapi → python, express → node)
+ * 4. Builder name (@vercel/python → python)
+ * 5. Entrypoint file extension (.py → python, .ts → node)
+ */
+export declare function inferRuntime(config: {
+    runtime?: string;
+    framework?: string;
+    builder?: string;
+    entrypoint?: string;
+}): ServiceRuntime | undefined;

package/dist/services/runtimes/runtime.js

@@ -0,0 +1,61 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var runtime_exports = {};
+__export(runtime_exports, {
+  getBuilderForRuntime: () => getBuilderForRuntime,
+  inferRuntime: () => inferRuntime
+});
+module.exports = __toCommonJS(runtime_exports);
+var import_constants = require("./constants");
+var import_framework = require("./framework");
+function getBuilderForRuntime(runtime) {
+  const builder = import_constants.RUNTIME_BUILDERS[runtime];
+  if (!builder)
+    throw new Error(`Unknown runtime: ${runtime}`);
+  return builder;
+}
+function inferRuntime(config) {
+  if (config.runtime && config.runtime in import_constants.RUNTIME_BUILDERS) {
+    return config.runtime;
+  }
+  const frameworkRuntime = (0, import_framework.inferRuntimeFromFramework)(config.framework);
+  if (frameworkRuntime)
+    return frameworkRuntime;
+  if (config.builder) {
+    for (const [runtime, builderName] of Object.entries(import_constants.RUNTIME_BUILDERS)) {
+      if (config.builder === builderName)
+        return runtime;
+    }
+  }
+  if (config.entrypoint) {
+    if (config.entrypoint === "pyproject.toml" || config.entrypoint.endsWith("/pyproject.toml")) {
+      return "python";
+    }
+    for (const [ext, runtime] of Object.entries(import_constants.ENTRYPOINT_EXTENSIONS)) {
+      if (config.entrypoint.endsWith(ext))
+        return runtime;
+    }
+  }
+  return void 0;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getBuilderForRuntime,
+  inferRuntime
+});

package/dist/services/types.d.ts

@@ -0,0 +1,113 @@
+import type { Rewrite, Route } from '@vercel/routing-utils';
+import type { DetectEntrypointFn, EnvVar, EnvVars, ExperimentalServiceConfig, ExperimentalServiceV2Config, ExperimentalServiceGroups, ExperimentalServices, ExperimentalServicesV2, ExperimentalServiceV2Binding, ServiceBinding, ServiceConfig, Services, ExperimentalService, ExperimentalServiceV2, ServiceRuntime, ServiceType, ServiceRefEnvVar, Service, Builder } from '@vercel/build-utils';
+import type { DetectorFilesystem } from '../detectors/filesystem';
+export type { DetectEntrypointFn, EnvVar, EnvVars, ExperimentalServiceConfig, ExperimentalServiceGroups, ExperimentalServices, ExperimentalServiceV2Config, ExperimentalServicesV2, ExperimentalServiceV2Binding, ServiceBinding, ServiceConfig, Services, ExperimentalService, ExperimentalServiceV2, ServiceRuntime, ServiceType, ServiceRefEnvVar, Service, Builder, };
+/**
+ * @deprecated Use `Service` instead
+ */
+export type ResolvedService = Service;
+export interface DetectServicesOptions {
+    fs: DetectorFilesystem;
+    configuredServices?: ConfiguredServices;
+    configuredServicesType?: ConfiguredServicesType;
+    /**
+     * Working directory path (relative to fs root).
+     * If provided, vercel.json is read from this path.
+     */
+    workPath?: string;
+    /**
+     * Optional callback that, given a candidate service directory and its
+     * detected framework, returns a normalized entrypoint (file path or
+     * `module:attr` reference). Used to suggested service configs.
+     */
+    detectEntrypoint?: DetectEntrypointFn;
+}
+export interface ServicesRoutes {
+    /** Host-based rewrite routes for subdomain-mounted web services */
+    hostRewrites: Route[];
+    /** Rewrite routes for non-root web services (prefix-based) */
+    rewrites: Route[];
+    /** Default routes (catch-all for root web service) */
+    defaults: Route[];
+    /** SPA fallback routes for static web services */
+    fallbacks: Route[];
+    /**
+     * Internal routes for schedule-triggered job services.
+     * These route `/_svc/{serviceName}/crons/{entry}/{handler}` to the scheduled job function.
+     */
+    crons: Route[];
+    /**
+     * Internal routes for worker services.
+     * These route `/_svc/{serviceName}/workers/{entry}/{handler}` to the worker function.
+     */
+    workers: Route[];
+}
+export type ConfiguredServicesType = 'experimentalServices' | 'services' | 'experimentalServicesV2';
+export type ConfiguredServices = ExperimentalServices | Services;
+/**
+ * A single service entry inferred from project structure.
+ *
+ * This is an intermediate format produced by auto-detection — it carries
+ * the detection results (including `mountPath`, the inferred route mount
+ * point) before they are converted into a concrete config format (V1 or V2).
+ */
+export interface InferredServiceConfig {
+    /** Service root directory relative to the project root. */
+    root: string;
+    /** Framework slug, if detected. */
+    framework?: string;
+    /** Service entrypoint (file path or `module:attr` reference). */
+    entrypoint?: string;
+    /** Runtime identifier (e.g. "python", "node"). */
+    runtime?: string;
+    /** Service type (e.g. "web", "cron", "worker"). */
+    type?: ServiceType;
+    /** Build command override. */
+    buildCommand?: string;
+    /** Pre-deploy command override. */
+    preDeployCommand?: string;
+    /**
+     * Inferred route mount path for this service.
+     * For example, `"/"` for the root frontend, `"/_/backend"` for a backend.
+     */
+    mountPath?: string;
+}
+export type InferredServicesConfig = Record<string, InferredServiceConfig>;
+export interface ResolvedServicesResult {
+    services: Service[];
+    source: DetectServicesSource;
+    useImplicitEnvInjection: boolean;
+    routes: ServicesRoutes;
+    /** Top-level service-targeted rewrites (V2). */
+    rewrites: Rewrite[];
+    /** V2 services config for the build output, so the platform activates V2 routing. */
+    experimentalServicesV2?: Services;
+    errors: ServiceDetectionError[];
+    warnings: ServiceDetectionWarning[];
+}
+export interface InferredServicesResult {
+    source: 'layout' | 'procfile' | 'railway' | 'render';
+    config: InferredServicesConfig;
+    services: Service[];
+    warnings: ServiceDetectionWarning[];
+}
+export interface DetectServicesResult extends ResolvedServicesResult {
+    /**
+     * Source of service definitions:
+     * - `configured`: loaded from explicit project configuration (`vercel.json#experimentalServices`, `vercel.json#services`, or the deprecated `vercel.json#experimentalServicesV2` alias)
+     * - `auto-detected`: inferred from project structure
+     */
+    resolved: ResolvedServicesResult;
+    inferred: InferredServicesResult | null;
+}
+export type DetectServicesSource = 'configured' | 'auto-detected';
+export interface ServiceDetectionWarning {
+    code: string;
+    message: string;
+    serviceName?: string;
+}
+export interface ServiceDetectionError {
+    code: string;
+    message: string;
+    serviceName?: string;
+}

package/dist/services/types.js

@@ -0,0 +1,16 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var types_exports = {};
+module.exports = __toCommonJS(types_exports);

package/dist/services/utils.d.ts

@@ -0,0 +1,48 @@
+import { INTERNAL_SERVICE_PREFIX, getInternalServiceFunctionPath, getInternalServiceCronPathPrefix, getInternalServiceCronPath, getInternalServiceWorkerPathPrefix, getInternalServiceWorkerPath } from '@vercel/build-utils';
+import type { DetectorFilesystem } from '../detectors/filesystem';
+import type { ExperimentalServices, ExperimentalServicesV2, InferredServicesConfig, Services, ServiceDetectionError, ServiceDetectionWarning, ResolvedService } from './types';
+export { INTERNAL_SERVICE_PREFIX, getInternalServiceFunctionPath, getInternalServiceCronPathPrefix, getInternalServiceCronPath, getInternalServiceWorkerPathPrefix, getInternalServiceWorkerPath, };
+export declare function hasFile(fs: DetectorFilesystem, filePath: string): Promise<boolean>;
+/**
+ * Reserved internal namespace used by the dev queue proxy.
+ */
+export declare const INTERNAL_QUEUES_PREFIX = "/_svc/_queues";
+export declare function isStaticBuild(service: ResolvedService): boolean;
+/**
+ * Determines if a service uses a "route-owning" builder.
+ *
+ * Route-owning builders (e.g., `@vercel/next`, `@vercel/backends`) produce
+ * their own full route table with handle phases (filesystem, miss, rewrite,
+ * hit, error). The services system should NOT generate synthetic catch-all
+ * rewrites for them — instead, we rely on the builder's own `routes[]`.
+ */
+export declare function isRouteOwningBuilder(service: ResolvedService): boolean;
+export interface ReadVercelConfigResult {
+    config: {
+        experimentalServices?: ExperimentalServices;
+        services?: Services;
+        experimentalServicesV2?: ExperimentalServicesV2;
+    } | null;
+    error: ServiceDetectionError | null;
+}
+/**
+ * Read and parse vercel.json or vercel.toml from filesystem.
+ * Returns the parsed config or an error if the file exists but is invalid.
+ */
+export declare function readVercelConfig(fs: DetectorFilesystem): Promise<ReadVercelConfigResult>;
+/**
+ * Assign mount paths to inferred services.
+ *
+ * A frontend service gets `/`, backend services get `/api/...`:
+ * - If the frontend is a BFF (e.g. Next.js, has its own API routes):
+ *   backends get `/api/{name}/(.*)` to avoid shadowing the frontend's API routes.
+ * - If the frontend is client-only (e.g. Vite):
+ *   backends get `/api/(.*)`.
+ *
+ * A single non-frontend service gets `/`.
+ * If no frontend service found, multiple services get `/api/{name}`.
+ *
+ * Priority for `/`: single service or frontend > name "frontend" or "web" > alphabetical.
+ */
+export declare function assignMountPaths(services: InferredServicesConfig): ServiceDetectionWarning[];
+export declare function combineBuildCommand(buildCommand: string | undefined, preDeployCommand: string | string[] | undefined): string | undefined;