@netlify/plugin-nextjs 4.41.3 → 5.0.0-beta.1

package/dist/esm-chunks/chunk-B6QMRLBH.js

@@ -0,0 +1,255 @@
+
+      const require = await (async () => {
+        const { createRequire } = await import("node:module");
+        return createRequire(import.meta.url);
+      })();
+    
+import {
+  __commonJS,
+  __require,
+  __toESM
+} from "./chunk-RSKIKBZH.js";
+
+// node_modules/is-promise/index.js
+var require_is_promise = __commonJS({
+  "node_modules/is-promise/index.js"(exports, module) {
+    module.exports = isPromise;
+    module.exports.default = isPromise;
+    function isPromise(obj) {
+      return !!obj && (typeof obj === "object" || typeof obj === "function") && typeof obj.then === "function";
+    }
+  }
+});
+
+// node_modules/@netlify/functions/dist/lib/consts.js
+var require_consts = __commonJS({
+  "node_modules/@netlify/functions/dist/lib/consts.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.METADATA_VERSION = exports.HTTP_STATUS_OK = exports.HTTP_STATUS_METHOD_NOT_ALLOWED = exports.BUILDER_FUNCTIONS_FLAG = void 0;
+    var BUILDER_FUNCTIONS_FLAG = true;
+    exports.BUILDER_FUNCTIONS_FLAG = BUILDER_FUNCTIONS_FLAG;
+    var HTTP_STATUS_METHOD_NOT_ALLOWED = 405;
+    exports.HTTP_STATUS_METHOD_NOT_ALLOWED = HTTP_STATUS_METHOD_NOT_ALLOWED;
+    var HTTP_STATUS_OK = 200;
+    exports.HTTP_STATUS_OK = HTTP_STATUS_OK;
+    var METADATA_VERSION = 1;
+    exports.METADATA_VERSION = METADATA_VERSION;
+  }
+});
+
+// node_modules/@netlify/functions/dist/lib/builder.js
+var require_builder = __commonJS({
+  "node_modules/@netlify/functions/dist/lib/builder.js"(exports) {
+    "use strict";
+    var __importDefault = exports && exports.__importDefault || function(mod) {
+      return mod && mod.__esModule ? mod : { "default": mod };
+    };
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.builder = void 0;
+    var is_promise_1 = __importDefault(require_is_promise());
+    var consts_js_1 = require_consts();
+    var augmentResponse = (response) => {
+      if (!response) {
+        return response;
+      }
+      const metadata = { version: consts_js_1.METADATA_VERSION, builder_function: consts_js_1.BUILDER_FUNCTIONS_FLAG, ttl: response.ttl || 0 };
+      return {
+        ...response,
+        metadata
+      };
+    };
+    var wrapHandler = (handler) => (
+      // eslint-disable-next-line promise/prefer-await-to-callbacks
+      (event, context, callback) => {
+        if (event.httpMethod !== "GET" && event.httpMethod !== "HEAD") {
+          return Promise.resolve({
+            body: "Method Not Allowed",
+            statusCode: consts_js_1.HTTP_STATUS_METHOD_NOT_ALLOWED
+          });
+        }
+        const modifiedEvent = {
+          ...event,
+          multiValueQueryStringParameters: {},
+          queryStringParameters: {}
+        };
+        const wrappedCallback = (error, response) => (
+          // eslint-disable-next-line promise/prefer-await-to-callbacks
+          callback ? callback(error, augmentResponse(response)) : null
+        );
+        const execution = handler(modifiedEvent, context, wrappedCallback);
+        if ((0, is_promise_1.default)(execution)) {
+          return execution.then(augmentResponse);
+        }
+        return execution;
+      }
+    );
+    exports.builder = wrapHandler;
+  }
+});
+
+// node_modules/@netlify/functions/dist/lib/purge_cache.js
+var require_purge_cache = __commonJS({
+  "node_modules/@netlify/functions/dist/lib/purge_cache.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.purgeCache = void 0;
+    var process_1 = __require("process");
+    var purgeCache2 = async (options = {}) => {
+      if (globalThis.fetch === void 0) {
+        throw new Error("`fetch` is not available. Please ensure you're using Node.js version 18.0.0 or above. Refer to https://ntl.fyi/functions-runtime for more information.");
+      }
+      const payload = {
+        cache_tags: options.tags,
+        deploy_alias: options.deployAlias
+      };
+      const token = process_1.env.NETLIFY_PURGE_API_TOKEN || options.token;
+      if ("siteSlug" in options) {
+        payload.site_slug = options.siteSlug;
+      } else if ("domain" in options) {
+        payload.domain = options.domain;
+      } else {
+        const siteID = options.siteID || process_1.env.SITE_ID;
+        if (!siteID) {
+          throw new Error("The Netlify site ID was not found in the execution environment. Please supply it manually using the `siteID` property.");
+        }
+        payload.site_id = siteID;
+      }
+      if (!token) {
+        throw new Error("The cache purge API token was not found in the execution environment. Please supply it manually using the `token` property.");
+      }
+      const apiURL = options.apiURL || "https://api.netlify.com";
+      const response = await fetch(`${apiURL}/api/v1/purge`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json; charset=utf8",
+          Authorization: `Bearer ${token}`
+        },
+        body: JSON.stringify(payload)
+      });
+      if (!response.ok) {
+        throw new Error(`Cache purge API call returned an unexpected status code: ${response.status}`);
+      }
+    };
+    exports.purgeCache = purgeCache2;
+  }
+});
+
+// node_modules/@netlify/functions/dist/lib/schedule.js
+var require_schedule = __commonJS({
+  "node_modules/@netlify/functions/dist/lib/schedule.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.schedule = void 0;
+    var schedule = (cron, handler) => handler;
+    exports.schedule = schedule;
+  }
+});
+
+// node_modules/@netlify/functions/dist/lib/stream.js
+var require_stream = __commonJS({
+  "node_modules/@netlify/functions/dist/lib/stream.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.stream = void 0;
+    var node_stream_1 = __require("node:stream");
+    var node_util_1 = __require("node:util");
+    var pipeline = (0, node_util_1.promisify)(node_stream_1.pipeline);
+    var stream = (handler) => awslambda.streamifyResponse(async (event, responseStream, context) => {
+      const { body, ...httpResponseMetadata } = await handler(event, context);
+      const responseBody = awslambda.HttpResponseStream.from(responseStream, httpResponseMetadata);
+      if (typeof body === "undefined") {
+        responseBody.end();
+      } else if (typeof body === "string") {
+        responseBody.write(body);
+        responseBody.end();
+      } else {
+        await pipeline(body, responseBody);
+      }
+    });
+    exports.stream = stream;
+  }
+});
+
+// node_modules/@netlify/functions/dist/function/index.js
+var require_function = __commonJS({
+  "node_modules/@netlify/functions/dist/function/index.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+  }
+});
+
+// node_modules/@netlify/functions/dist/main.js
+var require_main = __commonJS({
+  "node_modules/@netlify/functions/dist/main.js"(exports) {
+    "use strict";
+    var __createBinding = exports && exports.__createBinding || (Object.create ? function(o, m, k, k2) {
+      if (k2 === void 0)
+        k2 = k;
+      var desc = Object.getOwnPropertyDescriptor(m, k);
+      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+        desc = { enumerable: true, get: function() {
+          return m[k];
+        } };
+      }
+      Object.defineProperty(o, k2, desc);
+    } : function(o, m, k, k2) {
+      if (k2 === void 0)
+        k2 = k;
+      o[k2] = m[k];
+    });
+    var __exportStar = exports && exports.__exportStar || function(m, exports2) {
+      for (var p in m)
+        if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports2, p))
+          __createBinding(exports2, m, p);
+    };
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.stream = exports.schedule = exports.purgeCache = exports.builder = void 0;
+    var builder_js_1 = require_builder();
+    Object.defineProperty(exports, "builder", { enumerable: true, get: function() {
+      return builder_js_1.builder;
+    } });
+    var purge_cache_js_1 = require_purge_cache();
+    Object.defineProperty(exports, "purgeCache", { enumerable: true, get: function() {
+      return purge_cache_js_1.purgeCache;
+    } });
+    var schedule_js_1 = require_schedule();
+    Object.defineProperty(exports, "schedule", { enumerable: true, get: function() {
+      return schedule_js_1.schedule;
+    } });
+    var stream_js_1 = require_stream();
+    Object.defineProperty(exports, "stream", { enumerable: true, get: function() {
+      return stream_js_1.stream;
+    } });
+    __exportStar(require_function(), exports);
+  }
+});
+
+// src/run/revalidate.ts
+var import_functions = __toESM(require_main(), 1);
+var nextResponseProxy = (res) => {
+  return new Proxy(res, {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    get(target, key) {
+      const originalValue = target[key];
+      if (key === "revalidate") {
+        return async function newRevalidate(...args) {
+          try {
+            console.debug("Purging cache for:", [args[0]]);
+            await (0, import_functions.purgeCache)({ tags: [`_N_T_${args[0]}`] });
+          } catch {
+            throw new Error(
+              `An internal error occurred while trying to purge cache for ${args[0]}}`
+            );
+          }
+          return originalValue?.apply(target, args);
+        };
+      }
+      return originalValue;
+    }
+  });
+};
+
+export {
+  nextResponseProxy
+};

package/dist/esm-chunks/chunk-G3GM7JNF.js

@@ -0,0 +1,92 @@
+
+      const require = await (async () => {
+        const { createRequire } = await import("node:module");
+        return createRequire(import.meta.url);
+      })();
+    
+import {
+  require_out
+} from "./chunk-AVWFCGVE.js";
+import {
+  __toESM
+} from "./chunk-RSKIKBZH.js";
+
+// src/build/content/prerendered.ts
+var import_fast_glob = __toESM(require_out(), 1);
+import { existsSync } from "node:fs";
+import { readFile } from "node:fs/promises";
+import { join } from "node:path";
+var routeToFilePath = (path) => path.replace(/^\//, "") || "index";
+var buildPagesCacheValue = async (path) => ({
+  kind: "PAGE",
+  html: await readFile(`${path}.html`, "utf-8"),
+  pageData: JSON.parse(await readFile(`${path}.json`, "utf-8"))
+});
+var buildAppCacheValue = async (path) => ({
+  kind: "PAGE",
+  html: await readFile(`${path}.html`, "utf-8"),
+  pageData: await readFile(`${path}.rsc`, "utf-8"),
+  ...JSON.parse(await readFile(`${path}.meta`, "utf-8"))
+});
+var buildRouteCacheValue = async (path) => ({
+  kind: "ROUTE",
+  body: await readFile(`${path}.body`, "utf-8"),
+  ...JSON.parse(await readFile(`${path}.meta`, "utf-8"))
+});
+var buildFetchCacheValue = async (path) => ({
+  kind: "FETCH",
+  ...JSON.parse(await readFile(path, "utf-8"))
+});
+var copyPrerenderedContent = async (ctx) => {
+  try {
+    const manifest = await ctx.getPrerenderManifest();
+    await Promise.all(
+      Object.entries(manifest.routes).map(async ([route, meta]) => {
+        const key = routeToFilePath(route);
+        let value;
+        switch (true) {
+          case meta.dataRoute?.endsWith(".json"):
+            value = await buildPagesCacheValue(join(ctx.publishDir, "server/pages", key));
+            break;
+          case meta.dataRoute?.endsWith(".rsc"):
+            value = await buildAppCacheValue(join(ctx.publishDir, "server/app", key));
+            break;
+          case meta.dataRoute === null:
+            value = await buildRouteCacheValue(join(ctx.publishDir, "server/app", key));
+            break;
+          default:
+            throw new Error(`Unrecognized content: ${route}`);
+        }
+        await ctx.writeCacheEntry(key, value);
+      })
+    );
+    if (existsSync(join(ctx.publishDir, `server/app/_not-found.html`))) {
+      const key = "404";
+      const value = await buildAppCacheValue(join(ctx.publishDir, "server/app/_not-found"));
+      await ctx.writeCacheEntry(key, value);
+    }
+  } catch (error) {
+    ctx.failBuild("Failed assembling prerendered content for upload", error);
+  }
+};
+var copyFetchContent = async (ctx) => {
+  try {
+    const paths = await (0, import_fast_glob.default)(["!(*.*)"], {
+      cwd: join(ctx.publishDir, "cache/fetch-cache"),
+      extglob: true
+    });
+    await Promise.all(
+      paths.map(async (key) => {
+        const value = await buildFetchCacheValue(join(ctx.publishDir, "cache/fetch-cache", key));
+        await ctx.writeCacheEntry(key, value);
+      })
+    );
+  } catch (error) {
+    ctx.failBuild("Failed assembling fetch content for upload", error);
+  }
+};
+
+export {
+  copyPrerenderedContent,
+  copyFetchContent
+};

package/dist/esm-chunks/chunk-GGHAQM5D.js

@@ -0,0 +1,28 @@
+
+      const require = await (async () => {
+        const { createRequire } = await import("node:module");
+        return createRequire(import.meta.url);
+      })();
+    
+
+// src/build/cache.ts
+import { join } from "node:path";
+var saveBuildCache = async (ctx) => {
+  if (await ctx.utils.cache.save(join(ctx.publishDir, "cache"))) {
+    console.log("Next.js cache saved.");
+  } else {
+    console.log("No Next.js cache to save.");
+  }
+};
+var restoreBuildCache = async (ctx) => {
+  if (await ctx.utils.cache.restore(join(ctx.publishDir, "cache"))) {
+    console.log("Next.js cache restored.");
+  } else {
+    console.log("No Next.js cache to restore.");
+  }
+};
+
+export {
+  saveBuildCache,
+  restoreBuildCache
+};

package/dist/esm-chunks/chunk-NOX2JUQZ.js

@@ -0,0 +1,89 @@
+
+      const require = await (async () => {
+        const { createRequire } = await import("node:module");
+        return createRequire(import.meta.url);
+      })();
+    
+import {
+  copyNextDependencies,
+  copyNextServerCode,
+  writeTagsManifest
+} from "./chunk-A22224GM.js";
+import {
+  require_out
+} from "./chunk-AVWFCGVE.js";
+import {
+  SERVER_HANDLER_NAME
+} from "./chunk-VP3PT3VV.js";
+import {
+  __toESM
+} from "./chunk-RSKIKBZH.js";
+
+// src/build/functions/server.ts
+var import_fast_glob = __toESM(require_out(), 1);
+import { cp, mkdir, rm, writeFile } from "fs/promises";
+import { join } from "node:path";
+var copyHandlerDependencies = async (ctx) => {
+  const fileList = await (0, import_fast_glob.glob)("dist/**/*", { cwd: ctx.pluginDir });
+  await Promise.all(
+    [...fileList].map(
+      (path) => cp(join(ctx.pluginDir, path), join(ctx.serverHandlerDir, path), { recursive: true })
+    )
+  );
+};
+var writeHandlerManifest = async (ctx) => {
+  await writeFile(
+    join(ctx.serverHandlerDir, `${SERVER_HANDLER_NAME}.json`),
+    JSON.stringify({
+      config: {
+        name: "Next.js Server Handler",
+        generator: `${ctx.pluginName}@${ctx.pluginVersion}`,
+        nodeBundler: "none",
+        includedFiles: [
+          `${SERVER_HANDLER_NAME}*`,
+          "package.json",
+          "dist/**",
+          ".next/**",
+          ".netlify/**",
+          "node_modules/**"
+        ],
+        includedFilesBasePath: ctx.serverHandlerDir
+      },
+      version: 1
+    }),
+    "utf-8"
+  );
+};
+var writePackageMetadata = async (ctx) => {
+  await writeFile(join(ctx.serverHandlerDir, "package.json"), JSON.stringify({ type: "module" }));
+};
+var writeHandlerFile = async (ctx) => {
+  await writeFile(
+    join(ctx.serverHandlerDir, `${SERVER_HANDLER_NAME}.js`),
+    `
+    import handler from './dist/run/handlers/server.js';
+    export default handler;
+    export const config = {
+      path: '/*',
+      preferStatic: true
+    };
+    `
+  );
+};
+var createServerHandler = async (ctx) => {
+  await rm(ctx.serverFunctionsDir, { recursive: true, force: true });
+  await mkdir(join(ctx.serverHandlerDir, ".netlify"), { recursive: true });
+  await Promise.all([
+    copyNextServerCode(ctx),
+    copyNextDependencies(ctx),
+    writeTagsManifest(ctx),
+    copyHandlerDependencies(ctx),
+    writeHandlerManifest(ctx),
+    writePackageMetadata(ctx),
+    writeHandlerFile(ctx)
+  ]);
+};
+
+export {
+  createServerHandler
+};

package/dist/esm-chunks/chunk-R4NHZWGU.js

@@ -0,0 +1,32 @@
+
+      const require = await (async () => {
+        const { createRequire } = await import("node:module");
+        return createRequire(import.meta.url);
+      })();
+    
+import {
+  PLUGIN_DIR
+} from "./chunk-4AJYXTWN.js";
+
+// src/run/config.ts
+import { readFile } from "node:fs/promises";
+import { resolve } from "node:path";
+var getRunConfig = async () => {
+  return JSON.parse(await readFile(resolve(".next/required-server-files.json"), "utf-8")).config;
+};
+var setRunConfig = (config) => {
+  config.experimental = {
+    ...config.experimental,
+    incrementalCacheHandlerPath: `${PLUGIN_DIR}/dist/run/handlers/cache.cjs`
+  };
+  process.env.__NEXT_PRIVATE_STANDALONE_CONFIG = JSON.stringify(config);
+};
+var getTagsManifest = async () => {
+  return JSON.parse(await readFile(resolve(".netlify/tags-manifest.json"), "utf-8"));
+};
+
+export {
+  getRunConfig,
+  setRunConfig,
+  getTagsManifest
+};

package/dist/esm-chunks/chunk-RSKIKBZH.js

@@ -0,0 +1,44 @@
+
+      const require = await (async () => {
+        const { createRequire } = await import("node:module");
+        return createRequire(import.meta.url);
+      })();
+    
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined")
+    return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var __commonJS = (cb, mod) => function __require2() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+export {
+  __require,
+  __commonJS,
+  __toESM
+};

package/dist/esm-chunks/chunk-UXLNY5XK.js

@@ -0,0 +1,86 @@
+
+      const require = await (async () => {
+        const { createRequire } = await import("node:module");
+        return createRequire(import.meta.url);
+      })();
+    
+import {
+  EDGE_HANDLER_NAME
+} from "./chunk-VP3PT3VV.js";
+
+// src/build/functions/edge.ts
+import { cp, mkdir, readFile, rm, writeFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+var writeEdgeManifest = async (ctx, manifest) => {
+  await mkdir(ctx.edgeFunctionsDir, { recursive: true });
+  await writeFile(join(ctx.edgeFunctionsDir, "manifest.json"), JSON.stringify(manifest, null, 2));
+};
+var writeHandlerFile = async (ctx, { matchers, name }) => {
+  const handlerName = getHandlerName({ name });
+  const handlerDirectory = join(ctx.edgeFunctionsDir, handlerName);
+  const handlerRuntimeDirectory = join(handlerDirectory, "edge-runtime");
+  await cp(join(ctx.pluginDir, "edge-runtime"), handlerRuntimeDirectory, {
+    recursive: true
+  });
+  await writeFile(join(handlerRuntimeDirectory, "matchers.json"), JSON.stringify(matchers));
+  await writeFile(
+    join(handlerDirectory, `${handlerName}.js`),
+    `
+    import {handleMiddleware} from './edge-runtime/middleware.ts';
+    import handler from './server/${name}.js';
+    export default (req, context) => handleMiddleware(req, context, handler);
+    `
+  );
+};
+var copyHandlerDependencies = async (ctx, { name, files }) => {
+  const edgeRuntimePath = join(ctx.pluginDir, "edge-runtime");
+  const srcDir = ctx.resolve(".next/standalone/.next");
+  const shimPath = join(edgeRuntimePath, "shim/index.js");
+  const shim = await readFile(shimPath, "utf8");
+  const imports = `import './edge-runtime-webpack.js';`;
+  const exports = `export default _ENTRIES["middleware_${name}"].default;`;
+  await Promise.all(
+    files.map(async (file) => {
+      const destDir = join(ctx.edgeFunctionsDir, getHandlerName({ name }));
+      if (file === `server/${name}.js`) {
+        const entrypoint = await readFile(join(srcDir, file), "utf8");
+        const parts = [shim, imports, entrypoint, exports];
+        await mkdir(dirname(join(destDir, file)), { recursive: true });
+        await writeFile(join(destDir, file), parts.join("\n;"));
+        return;
+      }
+      await cp(join(srcDir, file), join(destDir, file));
+    })
+  );
+};
+var createEdgeHandler = async (ctx, definition) => {
+  await copyHandlerDependencies(ctx, definition);
+  await writeHandlerFile(ctx, definition);
+};
+var getHandlerName = ({ name }) => `${EDGE_HANDLER_NAME}-${name.replace(/\W/g, "-")}`;
+var buildHandlerDefinition = (ctx, { name, matchers, page }) => ({
+  function: getHandlerName({ name }),
+  name: name === "middleware" ? "Next.js Middleware Handler" : `Next.js Edge Handler: ${page}`,
+  pattern: matchers[0].regexp,
+  cache: name === "middleware" ? void 0 : "manual",
+  generator: `${ctx.pluginName}@${ctx.pluginVersion}`
+});
+var createEdgeHandlers = async (ctx) => {
+  await rm(ctx.edgeFunctionsDir, { recursive: true, force: true });
+  const nextManifest = await ctx.getMiddlewareManifest();
+  const nextDefinitions = [
+    ...Object.values(nextManifest.middleware)
+    // ...Object.values(nextManifest.functions)
+  ];
+  await Promise.all(nextDefinitions.map((def) => createEdgeHandler(ctx, def)));
+  const netlifyDefinitions = nextDefinitions.map((def) => buildHandlerDefinition(ctx, def));
+  const netlifyManifest = {
+    version: 1,
+    functions: netlifyDefinitions
+  };
+  await writeEdgeManifest(ctx, netlifyManifest);
+};
+
+export {
+  createEdgeHandlers
+};