diff --git a/.changeset/embedded-javascript-parse-goal.md b/.changeset/embedded-javascript-parse-goal.md
new file mode 100644
index 0000000..0d71a8e
--- /dev/null
+++ b/.changeset/embedded-javascript-parse-goal.md
@@ -0,0 +1,5 @@
+---
+"minimizer-webpack-plugin": patch
+---
+
+read `as` on an embedded JavaScript body: the built-in minimizers take `module` as their own option and minify an `event-handler` body as the function it belongs to, so neither production is read as a classic script and no engine is handed the word
diff --git a/README.md b/README.md
index 4696f07..9da943f 100644
--- a/README.md
+++ b/README.md
@@ -1020,6 +1020,21 @@ stylesheet, so a minifier claiming `css` is handed one either way and `as` says
 which it is. Ignore it at your peril: parsing a declaration list as a stylesheet
 finds no rule and returns nothing.
 
+A `<script type="module">` arrives the same way, as **`javascript` with
+`as: "module"`**: JavaScript has two productions too, and a module script is one
+wherever it sits. The built-in JavaScript minimizers read it as their own
+`module` option, so the engine is never handed the word itself; a minify
+function of your own claiming `javascript` is handed it and decides. Ignore it
+at your peril: a module script read as a classic one is a syntax error the
+moment it holds a top-level `await`.
+
+An event handler attribute — `onclick=""` — arrives as **`javascript` with
+`as: "event-handler"`**: its value is a function body, the production the
+`return` cancelling an event is written in. No JavaScript engine here parses one
+on its own, so each built-in minimizer minifies the function that body belongs
+to and answers with the body back out of it. A minify function of your own is
+handed the body as written and reads it however its engine can.
+
 The nested case needs a minifier that can hand its nested bodies out, which it
 also states for itself — webpack's `cssMinify` and `htmlMinify` do:
 
diff --git a/src/utils.js b/src/utils.js
index ab4d66f..c15dc40 100644
--- a/src/utils.js
+++ b/src/utils.js
@@ -14,6 +14,53 @@
 
 const path = require("path");
 
+/**
+ * Which production of a language an embedded body is written in, as `as` names
+ * it. A `style=""` is `css` with `as: "block-contents"`; JavaScript's are these
+ * three, and only the last is one no engine here parses on its own.
+ */
+const CLASSIC_SCRIPT = "script";
+const MODULE_SCRIPT = "module";
+const EVENT_HANDLER = "event-handler";
+
+/**
+ * The function a body handed out as an event handler belongs to. Named past any
+ * run of `_` the body holds, so nothing in it resolves to the function instead
+ * of what it meant; the newline ends a line comment the body may close with.
+ * @param {string} body the handler's text
+ * @returns {string} the script it is the body of
+ */
+function asFunction(body) {
+  const runs = body.match(/_+/g);
+  const longest = runs
+    ? runs.reduce((widest, run) => Math.max(widest, run.length), 0)
+    : 0;
+
+  return `function ${"_".repeat(longest + 1)}(){${body}\n}`;
+}
+
+/**
+ * The handler body inside the function a minimizer answered with. `undefined`
+ * for an answer that is not that function — one holding anything else, or one
+ * that dropped it whole as the unused declaration it is.
+ * @param {string | undefined} answered what the minimizer answered
+ * @returns {string | undefined} the body, or undefined
+ */
+function functionBody(answered) {
+  if (typeof answered !== "string") return undefined;
+
+  // Trimmed first: an engine may end what it writes with a newline, and a
+  // trailing `;` is the declaration's own rather than the body's.
+  const written = answered.trim().replace(/;$/, "");
+  const opened = written.indexOf("{");
+
+  return opened !== -1 &&
+    written.endsWith("}") &&
+    /^function\s+[^\s(]+\s*\(\s*\)\s*$/.test(written.slice(0, opened))
+    ? written.slice(opened + 1, -1).trim()
+    : undefined;
+}
+
 /**
  * The version a package reports. Read by walking up from its resolved entry
  * point rather than by requiring `<name>/package.json`, which a package whose
@@ -207,6 +254,12 @@ async function terserMinify(
   minimizerOptions,
   extractComments,
 ) {
+  // Self-require rather than the bindings above: a minify function reaches a
+  // worker as its source, where this module's own scope is gone.
+  const { EVENT_HANDLER, MODULE_SCRIPT, asFunction, functionBody } =
+    // eslint-disable-next-line import/no-self-import
+    require("./utils.js");
+
   /**
    * @param {unknown} value value
    * @returns {value is EXPECTED_OBJECT} true when value is object or function
@@ -338,13 +391,18 @@ async function terserMinify(
   };
 
   /**
-   * @param {import("terser").MinifyOptions=} terserOptions terser options
+   * @param {(import("terser").MinifyOptions & { as?: string })=} terserOptions terser options
    * @returns {import("terser").MinifyOptions & { sourceMap: import("terser").SourceMapOptions | undefined } & { compress: import("terser").CompressOptions } & ({ output: import("terser").FormatOptions & { beautify: boolean } } | { format: import("terser").FormatOptions & { beautify: boolean } })} built terser options
    */
-  const buildTerserOptions = (terserOptions = {}) =>
+  const buildTerserOptions = ({ as, ...terserOptions } = {}) =>
     // Need deep copy objects to avoid https://github.com/terser/terser/issues/366
     ({
       ...terserOptions,
+      // `as` names which production of JavaScript the source is, and is the
+      // source's own rather than the configuration's, so it overrides `module`.
+      ...(typeof as === "undefined"
+        ? undefined
+        : { module: as === MODULE_SCRIPT }),
       compress:
         typeof terserOptions.compress === "boolean"
           ? terserOptions.compress
@@ -375,6 +433,12 @@ async function terserMinify(
       // toplevel: terserOptions.toplevel
     });
 
+  // The production is the body's own, and a function body is the one terser has
+  // no goal symbol for: it is minified as the function it belongs to.
+  const handler =
+    typeof minimizerOptions !== "undefined" &&
+    minimizerOptions.as === EVENT_HANDLER;
+
   let minify;
 
   try {
@@ -423,8 +487,19 @@ async function terserMinify(
   }
 
   const [[filename, source]] = Object.entries(input);
-  const code = Buffer.isBuffer(source) ? source.toString() : source;
-  const result = await minify({ [filename]: code }, terserOptions);
+  const text = Buffer.isBuffer(source) ? source.toString() : source;
+  const result = await minify(
+    { [filename]: handler ? asFunction(text) : text },
+    terserOptions,
+  );
+
+  if (handler) {
+    const body = functionBody(result.code);
+
+    // A wrap moves every position, so the map terser wrote describes a script
+    // that is not what comes back.
+    return { code: body === undefined ? text : body, extractedComments };
+  }
 
   return {
     code: /** @type {string} * */ (result.code),
@@ -470,6 +545,12 @@ async function uglifyJsMinify(
   minimizerOptions,
   extractComments,
 ) {
+  // Self-require rather than the bindings above: a minify function reaches a
+  // worker as its source, where this module's own scope is gone.
+  const { EVENT_HANDLER, MODULE_SCRIPT, asFunction, functionBody } =
+    // eslint-disable-next-line import/no-self-import
+    require("./utils.js");
+
   /**
    * @param {unknown} value value
    * @returns {boolean} true when value is object or function
@@ -593,10 +674,14 @@ async function uglifyJsMinify(
   };
 
   /**
-   * @param {import("uglify-js").MinifyOptions & { ecma?: number | string }=} uglifyJsOptions uglify-js options
+   * @param {import("uglify-js").MinifyOptions & { ecma?: number | string, as?: string }=} uglifyJsOptions uglify-js options
    * @returns {import("uglify-js").MinifyOptions & { sourceMap: boolean | import("uglify-js").SourceMapOptions | undefined } & { output: import("uglify-js").OutputOptions & { beautify: boolean } }} uglify-js options
    */
   const buildUglifyJsOptions = (uglifyJsOptions = {}) => {
+    // `as` names which production of JavaScript the source is. An inherited
+    // `module` is the asset's rather than the source's, so it still goes.
+    const { as } = uglifyJsOptions;
+
     if (typeof uglifyJsOptions.ecma !== "undefined") {
       delete uglifyJsOptions.ecma;
     }
@@ -605,9 +690,16 @@ async function uglifyJsMinify(
       delete uglifyJsOptions.module;
     }
 
+    if (typeof as !== "undefined") {
+      delete uglifyJsOptions.as;
+    }
+
     // Need deep copy objects to avoid https://github.com/terser/terser/issues/366
     return {
       ...uglifyJsOptions,
+      ...(typeof as === "undefined"
+        ? undefined
+        : { module: as === MODULE_SCRIPT }),
       // warnings: uglifyJsOptions.warnings,
       parse: { ...uglifyJsOptions.parse },
       compress:
@@ -632,6 +724,12 @@ async function uglifyJsMinify(
     };
   };
 
+  // A function body is the production uglify-js has no goal symbol for, so the
+  // function it belongs to is what is minified.
+  const handler =
+    typeof minimizerOptions !== "undefined" &&
+    minimizerOptions.as === EVENT_HANDLER;
+
   let minify;
 
   try {
@@ -659,8 +757,24 @@ async function uglifyJsMinify(
   );
 
   const [[filename, source]] = Object.entries(input);
-  const code = Buffer.isBuffer(source) ? source.toString() : source;
-  const result = await minify({ [filename]: code }, uglifyJsOptions);
+  const text = Buffer.isBuffer(source) ? source.toString() : source;
+  const result = await minify(
+    { [filename]: handler ? asFunction(text) : text },
+    uglifyJsOptions,
+  );
+
+  if (handler) {
+    const body = functionBody(result.code);
+
+    // A wrap moves every position, so the map uglify-js wrote describes a
+    // script that is not what comes back.
+    return {
+      code: body === undefined ? text : body,
+      errors: result.error ? [result.error] : [],
+      warnings: result.warnings || [],
+      extractedComments,
+    };
+  }
 
   return {
     code: result.code,
@@ -703,6 +817,12 @@ uglifyJsMinify.filter = (name) => JS_FILE_RE.test(name);
  * @returns {Promise<MinimizedResult>} minimized result
  */
 async function swcMinify(input, sourceMap, minimizerOptions, extractComments) {
+  // Self-require rather than the bindings above: a minify function reaches a
+  // worker as its source, where this module's own scope is gone.
+  const { EVENT_HANDLER, MODULE_SCRIPT, asFunction, functionBody } =
+    // eslint-disable-next-line import/no-self-import
+    require("./utils.js");
+
   /**
    * @param {unknown} value value
    * @returns {boolean} true when value is object or function
@@ -803,13 +923,18 @@ async function swcMinify(input, sourceMap, minimizerOptions, extractComments) {
   };
 
   /**
-   * @param {import("@swc/core").JsMinifyOptions=} swcOptions swc options
+   * @param {(import("@swc/core").JsMinifyOptions & { as?: string })=} swcOptions swc options
    * @returns {import("@swc/core").JsMinifyOptions & { extractComments?: false | true | "some" | "all" | { regex: string } } & { sourceMap: undefined | boolean } & { compress: import("@swc/core").TerserCompressOptions }} built swc options
    */
-  const buildSwcOptions = (swcOptions = {}) =>
+  const buildSwcOptions = ({ as, ...swcOptions } = {}) =>
     // Need deep copy objects to avoid https://github.com/terser/terser/issues/366
     ({
       ...swcOptions,
+      // `as` names which production of JavaScript the source is, and is the
+      // source's own rather than the configuration's, so it overrides `module`.
+      ...(typeof as === "undefined"
+        ? undefined
+        : { module: as === MODULE_SCRIPT }),
       compress:
         typeof swcOptions.compress === "boolean"
           ? swcOptions.compress
@@ -834,6 +959,12 @@ async function swcMinify(input, sourceMap, minimizerOptions, extractComments) {
       sourceMap: undefined,
     });
 
+  // A function body is the production swc has no goal symbol for, so the
+  // function it belongs to is what is minified.
+  const handler =
+    typeof minimizerOptions !== "undefined" &&
+    minimizerOptions.as === EVENT_HANDLER;
+
   let swc;
 
   try {
@@ -883,10 +1014,21 @@ async function swcMinify(input, sourceMap, minimizerOptions, extractComments) {
   }
 
   const [[filename, source]] = Object.entries(input);
-  const code = Buffer.isBuffer(source) ? source.toString() : source;
+  const text = Buffer.isBuffer(source) ? source.toString() : source;
   const result =
     /** @type {import("@swc/core").Output & { extractedComments?: string[] }} */
-    (await swc.minify(code, swcOptions));
+    (await swc.minify(handler ? asFunction(text) : text, swcOptions));
+
+  if (handler) {
+    const body = functionBody(result.code);
+
+    // A wrap moves every position, so the map swc wrote describes a script that
+    // is not what comes back.
+    return {
+      code: body === undefined ? text : body,
+      extractedComments: result.extractedComments || [],
+    };
+  }
 
   let map;
 
@@ -937,13 +1079,27 @@ swcMinify.filter = (name) => JS_FILE_RE.test(name);
  * @returns {Promise<MinimizedResult>} minimized result
  */
 async function esbuildMinify(input, sourceMap, minimizerOptions) {
+  // Self-require rather than the bindings above: a minify function reaches a
+  // worker as its source, where this module's own scope is gone.
+  const { EVENT_HANDLER, MODULE_SCRIPT, asFunction, functionBody } =
+    // eslint-disable-next-line import/no-self-import
+    require("./utils.js");
+
   /**
-   * @param {import("esbuild").TransformOptions & { ecma?: string | number, module?: boolean }=} esbuildOptions esbuild options
+   * @param {import("esbuild").TransformOptions & { ecma?: string | number, module?: boolean, as?: string }=} esbuildOptions esbuild options
    * @returns {import("esbuild").TransformOptions} built esbuild options
    */
   const buildEsbuildOptions = (esbuildOptions = {}) => {
     delete esbuildOptions.ecma;
 
+    // `as` names which production of JavaScript the source is, and is the
+    // source's own rather than the configuration's, so it overrides `module`.
+    if (typeof esbuildOptions.as !== "undefined") {
+      esbuildOptions.module = esbuildOptions.as === MODULE_SCRIPT;
+
+      delete esbuildOptions.as;
+    }
+
     if (esbuildOptions.module) {
       esbuildOptions.format = "esm";
     }
@@ -959,6 +1115,12 @@ async function esbuildMinify(input, sourceMap, minimizerOptions) {
     };
   };
 
+  // A function body is the production esbuild has no goal symbol for, so the
+  // function it belongs to is what is minified.
+  const handler =
+    typeof minimizerOptions !== "undefined" &&
+    minimizerOptions.as === EVENT_HANDLER;
+
   let esbuild;
 
   try {
@@ -977,15 +1139,21 @@ async function esbuildMinify(input, sourceMap, minimizerOptions) {
   }
 
   const [[filename, source]] = Object.entries(input);
-  const code = Buffer.isBuffer(source) ? source.toString() : source;
+  const text = Buffer.isBuffer(source) ? source.toString() : source;
 
   esbuildOptions.sourcefile = filename;
 
-  const result = await esbuild.transform(code, esbuildOptions);
+  const result = await esbuild.transform(
+    handler ? asFunction(text) : text,
+    esbuildOptions,
+  );
+  const body = handler ? functionBody(result.code) : undefined;
 
   return {
-    code: result.code,
-    map: result.map ? JSON.parse(result.map) : undefined,
+    code: handler ? (body === undefined ? text : body) : result.code,
+    // A wrap moves every position, so the map esbuild wrote describes a script
+    // that is not what comes back.
+    map: handler || !result.map ? undefined : JSON.parse(result.map),
     warnings:
       result.warnings.length > 0
         ? result.warnings.map((item) => {
@@ -3388,11 +3556,16 @@ function memoize(fn) {
 }
 
 module.exports = {
+  CLASSIC_SCRIPT,
+  EVENT_HANDLER,
+  MODULE_SCRIPT,
+  asFunction,
   cleanCssMinify,
   cssnanoMinify,
   cssoMinify,
   esbuildMinify,
   esbuildMinifyCss,
+  functionBody,
   getEcmaVersion,
   getMinimizerOptionsAt,
   htmlMinifierTerser,
diff --git a/test/__snapshots__/embedded-protocol.test.js.snap b/test/__snapshots__/embedded-protocol.test.js.snap
new file mode 100644
index 0000000..532c184
--- /dev/null
+++ b/test/__snapshots__/embedded-protocol.test.js.snap
@@ -0,0 +1,12 @@
+// Jest Snapshot v1, https://jestjs.io/docs/snapshot-testing
+
+exports[`a body handed out as a classic script is read as one by \`esbuildMinify\` 1`] = `
+"var o={a:1};with(o)window.ran=a;
+"
+`;
+
+exports[`a body handed out as a classic script is read as one by \`swcMinify\` 1`] = `"var o={a:1};with(o)window.ran=a;"`;
+
+exports[`a body handed out as a classic script is read as one by \`terserMinify\` 1`] = `"var o={a:1};with(o)window.ran=a;"`;
+
+exports[`a body handed out as a classic script is read as one by \`uglifyJsMinify\` 1`] = `"var o={a:1};with(o)window.ran=a;"`;
diff --git a/test/embedded-protocol.test.js b/test/embedded-protocol.test.js
index e87c0c4..2bf53b0 100644
--- a/test/embedded-protocol.test.js
+++ b/test/embedded-protocol.test.js
@@ -1,6 +1,7 @@
 import path from "path";
 
 import MinimizerPlugin from "../src";
+import { asFunction, functionBody } from "../src/utils";
 
 import {
   compile,
@@ -24,9 +25,9 @@ const answerText = (answer) =>
 
 // Anything the renderer throws is reported rather than dropped, and the body is
 // spelled as an untapped run spells it — which is what webpack's minifiers do.
-const askRenderer = async (render, source, type) => {
+const askRenderer = async (render, source, type, as) => {
   try {
-    return await render(source, { type });
+    return await render(source, as === undefined ? { type } : { type, as });
   } catch (error) {
     return { errors: [error] };
   }
@@ -216,11 +217,153 @@ failingJsMinify.supportsWorker = () => false;
 failingJsMinify.supportsWorkerThreads = () => false;
 failingJsMinify.filter = () => false;
 
+/**
+ * A module script: `await` at the top level is a syntax error in a classic one,
+ * so which production a body is written in decides whether it can be read.
+ */
+const MODULE_BODY = "window.ran = true;\nawait Promise.resolve();\n";
+
+/**
+ * A document minifier handing out one inline `<script type=module>`: the
+ * language is JavaScript, and `as` names which of its two productions the body
+ * is written in.
+ * @param {{ [file: string]: string }} input a single `{ filename: code }` entry
+ * @param {undefined} sourceMap unused
+ * @param {{ as?: string, renderEmbeddedSource: (source: string, info: { type: string, as?: string }) => Promise<EXPECTED_ANY> }} minimizerOptions minimizer options
+ * @returns {Promise<EXPECTED_ANY>} the body as its minimizer wrote it
+ */
+async function moduleScriptMinify(input, sourceMap, minimizerOptions) {
+  const rendered = await askRenderer(
+    minimizerOptions.renderEmbeddedSource,
+    MODULE_BODY,
+    "javascript",
+    minimizerOptions.as,
+  );
+  const text = answerText(rendered);
+
+  return {
+    code: typeof text === "string" ? text : MODULE_BODY,
+    ...answerDiagnostics([rendered]),
+  };
+}
+
+/**
+ * An event handler attribute's value: a function body, where the `return`
+ * cancelling an event lives. No JavaScript engine parses one on its own.
+ */
+const HANDLER_BODY = "  return  false  ";
+
+/**
+ * A document minifier handing out one `onsubmit=""`: JavaScript again, with
+ * `as` naming the production its value is written in.
+ * @param {{ [file: string]: string }} input a single `{ filename: code }` entry
+ * @param {undefined} sourceMap unused
+ * @param {{ renderEmbeddedSource: (source: string, info: { type: string, as?: string }) => Promise<EXPECTED_ANY> }} minimizerOptions minimizer options
+ * @returns {Promise<EXPECTED_ANY>} the body as its minimizer wrote it
+ */
+async function eventHandlerMinify(input, sourceMap, minimizerOptions) {
+  const rendered = await askRenderer(
+    minimizerOptions.renderEmbeddedSource,
+    HANDLER_BODY,
+    "javascript",
+    "event-handler",
+  );
+  const text = answerText(rendered);
+
+  return {
+    code: typeof text === "string" ? text : HANDLER_BODY,
+    ...answerDiagnostics([rendered]),
+  };
+}
+
+/**
+ * A classic script: `with` is a syntax error in a module and in strict mode,
+ * so a body holding one says which production it was read as.
+ */
+const CLASSIC_BODY =
+  "var  o  =  { a : 1 } ;  with ( o ) { window.ran  =  a }\n";
+
+/**
+ * A document minifier handing out one bare `<script>`, the classic production.
+ * @param {{ [file: string]: string }} input a single `{ filename: code }` entry
+ * @param {undefined} sourceMap unused
+ * @param {{ renderEmbeddedSource: (source: string, info: { type: string, as?: string }) => Promise<EXPECTED_ANY> }} minimizerOptions minimizer options
+ * @returns {Promise<EXPECTED_ANY>} the body as its minimizer wrote it
+ */
+async function classicScriptMinify(input, sourceMap, minimizerOptions) {
+  const rendered = await askRenderer(
+    minimizerOptions.renderEmbeddedSource,
+    CLASSIC_BODY,
+    "javascript",
+    "script",
+  );
+  const text = answerText(rendered);
+
+  return {
+    code: typeof text === "string" ? text : CLASSIC_BODY,
+    ...answerDiagnostics([rendered]),
+  };
+}
+
+/**
+ * A handler body that is a syntax error inside the function too, so no
+ * minimizer can answer with the function it was handed.
+ */
+const BROKEN_HANDLER_BODY = "var = broken(";
+
+/**
+ * A document minifier handing out one `onclick=""` no JavaScript production
+ * holds. What parses is the minimizer's business, as it is for a `<script>`.
+ * @param {{ [file: string]: string }} input a single `{ filename: code }` entry
+ * @param {undefined} sourceMap unused
+ * @param {{ renderEmbeddedSource: (source: string, info: { type: string, as?: string }) => Promise<EXPECTED_ANY> }} minimizerOptions minimizer options
+ * @returns {Promise<EXPECTED_ANY>} the body as its minimizer wrote it
+ */
+async function brokenHandlerMinify(input, sourceMap, minimizerOptions) {
+  const rendered = await askRenderer(
+    minimizerOptions.renderEmbeddedSource,
+    BROKEN_HANDLER_BODY,
+    "javascript",
+    "event-handler",
+  );
+  const text = answerText(rendered);
+
+  return {
+    code: typeof text === "string" ? text : BROKEN_HANDLER_BODY,
+    ...answerDiagnostics([rendered]),
+  };
+}
+
+brokenHandlerMinify.getTypes = () => ["page"];
+brokenHandlerMinify.getEmbeddedTypes = () => ["javascript"];
+brokenHandlerMinify.supportsWorker = () => false;
+brokenHandlerMinify.supportsWorkerThreads = () => false;
+brokenHandlerMinify.filter = (name) => /\.page$/i.test(name);
+
+classicScriptMinify.getTypes = () => ["page"];
+classicScriptMinify.getEmbeddedTypes = () => ["javascript"];
+classicScriptMinify.supportsWorker = () => false;
+classicScriptMinify.supportsWorkerThreads = () => false;
+classicScriptMinify.filter = (name) => /\.page$/i.test(name);
+
+eventHandlerMinify.getTypes = () => ["page"];
+eventHandlerMinify.getEmbeddedTypes = () => ["javascript"];
+eventHandlerMinify.supportsWorker = () => false;
+eventHandlerMinify.supportsWorkerThreads = () => false;
+eventHandlerMinify.filter = (name) => /\.page$/i.test(name);
+
+moduleScriptMinify.getTypes = () => ["page"];
+moduleScriptMinify.getEmbeddedTypes = () => ["javascript"];
+moduleScriptMinify.supportsWorker = () => false;
+moduleScriptMinify.supportsWorkerThreads = () => false;
+moduleScriptMinify.filter = (name) => /\.page$/i.test(name);
+
 /**
  * @param {EXPECTED_ANY[]} minify minify functions
+ * @param {EXPECTED_ANY[]=} minimizerOptions one options object per minify function
  * @returns {import("webpack").Compiler} compiler with the document emitted as an asset
  */
-const getPageCompiler = (minify) => {
+const getPageCompiler = (minify, minimizerOptions) => {
   const compiler = getCompiler({
     entry: path.resolve(__dirname, "./fixtures/embedded/entry-page.js"),
     target: "node",
@@ -235,7 +378,7 @@ const getPageCompiler = (minify) => {
   new MinimizerPlugin({
     test: /\.page$/i,
     minify,
-    minimizerOptions: minify.map(() => ({})),
+    minimizerOptions: minimizerOptions || minify.map(() => ({})),
     parallel: false,
   }).apply(compiler);
 
@@ -492,3 +635,191 @@ describe("embedded dispatch shapes", () => {
     );
   });
 });
+
+describe("which production of JavaScript a body is written in", () => {
+  it.each([
+    [
+      "terserMinify",
+      MinimizerPlugin.terserMinify,
+      "window.ran=!0,await Promise.resolve();",
+    ],
+    [
+      "uglifyJsMinify",
+      MinimizerPlugin.uglifyJsMinify,
+      "window.ran=!0,await Promise.resolve();",
+    ],
+    [
+      "swcMinify",
+      MinimizerPlugin.swcMinify,
+      "window.ran=!0,await Promise.resolve();",
+    ],
+    [
+      "esbuildMinify",
+      MinimizerPlugin.esbuildMinify,
+      "window.ran=!0,await Promise.resolve();\n",
+    ],
+  ])(
+    "reads a body handed out as a module with `%s`",
+    async (name, minifier, expected) => {
+      const compiler = getPageCompiler(
+        [moduleScriptMinify, minifier],
+        [{ as: "module" }, {}],
+      );
+      const stats = await compile(compiler);
+
+      expect(getErrors(stats)).toEqual([]);
+      expect(getWarnings(stats)).toEqual([]);
+      expect(readAsset("host.page", compiler, stats)).toBe(expected);
+    },
+  );
+
+  it("reads one as a classic script when that is what it is handed out as", async () => {
+    const compiler = getPageCompiler(
+      [moduleScriptMinify, MinimizerPlugin.terserMinify],
+      [{ as: "script" }, {}],
+    );
+    const stats = await compile(compiler);
+
+    // The word itself never reaches the engine, which would answer
+    // "`as` is not a supported option" rather than reading the source at all.
+    expect(getErrors(stats)).toHaveLength(1);
+    expect(getErrors(stats)[0]).toMatch(/Unexpected token: name \(Promise\)/);
+    expect(stats.compilation.getAsset("host.page").source.source()).toBe(
+      MODULE_BODY,
+    );
+  });
+
+  it.each([
+    ["terserMinify", MinimizerPlugin.terserMinify],
+    ["uglifyJsMinify", MinimizerPlugin.uglifyJsMinify],
+    ["swcMinify", MinimizerPlugin.swcMinify],
+    ["esbuildMinify", MinimizerPlugin.esbuildMinify],
+  ])("never hands the word itself to `%s`", async (name, minifier) => {
+    // Each engine rejects an unknown option outright — terser and uglify-js
+    // with "`as` is not a supported option", swc and esbuild in their own words.
+    for (const handOut of [
+      [moduleScriptMinify, "script"],
+      [moduleScriptMinify, "module"],
+      [eventHandlerMinify, undefined],
+    ]) {
+      const [document, as] = handOut;
+      const compiler = getPageCompiler(
+        [document, minifier],
+        [as === undefined ? {} : { as }, {}],
+      );
+      const stats = await compile(compiler);
+
+      expect(getErrors(stats).join("\n")).not.toMatch(
+        /supported option|unknown field|Invalid option/,
+      );
+    }
+  });
+
+  it("leaves the production to the minimizer when none is named", async () => {
+    const compiler = getPageCompiler([
+      moduleScriptMinify,
+      MinimizerPlugin.terserMinify,
+    ]);
+    const stats = await compile(compiler);
+
+    // Nothing says which production this is, so it is read as the classic
+    // script `terser` defaults to — which is what an inline script is.
+    expect(getErrors(stats)).toHaveLength(1);
+    expect(getErrors(stats)[0]).toMatch(/Unexpected token: name \(Promise\)/);
+  });
+});
+
+describe("a body handed out as an event handler", () => {
+  it.each([
+    ["terserMinify", MinimizerPlugin.terserMinify],
+    ["uglifyJsMinify", MinimizerPlugin.uglifyJsMinify],
+    ["swcMinify", MinimizerPlugin.swcMinify],
+    ["esbuildMinify", MinimizerPlugin.esbuildMinify],
+  ])(
+    "is minified as the function it belongs to by `%s`",
+    async (name, minifier) => {
+      const compiler = getPageCompiler([eventHandlerMinify, minifier]);
+      const stats = await compile(compiler);
+
+      // A `return` at the top level is a syntax error in either script
+      // production, so reaching one at all is the wrap; what comes back is the
+      // body rather than the function around it.
+      expect(getErrors(stats)).toEqual([]);
+      expect(readAsset("host.page", compiler, stats)).toBe("return!1");
+    },
+  );
+});
+
+describe("a body handed out as a classic script", () => {
+  it.each([
+    ["terserMinify", MinimizerPlugin.terserMinify],
+    ["uglifyJsMinify", MinimizerPlugin.uglifyJsMinify],
+    ["swcMinify", MinimizerPlugin.swcMinify],
+    ["esbuildMinify", MinimizerPlugin.esbuildMinify],
+  ])("is read as one by `%s`", async (name, minifier) => {
+    const compiler = getPageCompiler([classicScriptMinify, minifier]);
+    const stats = await compile(compiler);
+
+    expect(getErrors(stats)).toEqual([]);
+    expect(readAsset("host.page", compiler, stats)).toMatchSnapshot();
+  });
+});
+
+describe("the function an event handler body is minified inside", () => {
+  it("makes the body a whole script an engine can read", () => {
+    expect(asFunction("return  false")).toBe("function _(){return  false\n}");
+  });
+
+  it("names the function past any run of `_` the body holds", () => {
+    // A body naming the same binding would resolve to the function around it
+    // rather than to what it meant.
+    expect(asFunction("_( __ )")).toBe("function ___(){_( __ )\n}");
+    expect(asFunction("f(_____)")).toBe("function ______(){f(_____)\n}");
+  });
+
+  it("ends a line comment the body closes with", () => {
+    // Without the newline the brace closing the function would be inside the
+    // comment, and nothing could parse what it was handed.
+    expect(asFunction("f( 1 ) // done")).toBe("function _(){f( 1 ) // done\n}");
+  });
+
+  it("reads the body back out of what a minimizer answered", () => {
+    expect(functionBody("function _(){f(1)}")).toBe("f(1)");
+    expect(functionBody("function ___ ( ) { f(1) }")).toBe("f(1)");
+    // `esbuild` writes the newline, and a declaration may be printed with the
+    // semicolon that never belonged to the body.
+    expect(functionBody("function _(){return!1}\n")).toBe("return!1");
+    expect(functionBody("function _(){return!1};")).toBe("return!1");
+  });
+
+  it("declines an answer that is not that one function", () => {
+    // Text around it, a second statement, and the empty answer a minimizer
+    // dropping an unused declaration gives.
+    expect(functionBody("f(1)")).toBeUndefined();
+    expect(functionBody("function _(){f(1)}g()")).toBeUndefined();
+    expect(functionBody("g();function _(){f(1)}")).toBeUndefined();
+    expect(functionBody("")).toBeUndefined();
+    expect(functionBody("function (){f(1)}")).toBeUndefined();
+    expect(functionBody("function _(a){f(a)}")).toBeUndefined();
+    expect(functionBody(undefined)).toBeUndefined();
+  });
+});
+
+describe("a handler body a minimizer does not answer with the function", () => {
+  it.each([
+    ["terserMinify", MinimizerPlugin.terserMinify],
+    ["uglifyJsMinify", MinimizerPlugin.uglifyJsMinify],
+    ["swcMinify", MinimizerPlugin.swcMinify],
+    ["esbuildMinify", MinimizerPlugin.esbuildMinify],
+  ])("keeps what it was written with under `%s`", async (name, minifier) => {
+    const compiler = getPageCompiler([brokenHandlerMinify, minifier]);
+    const stats = await compile(compiler);
+
+    // The body is a syntax error inside the function too, so nothing comes
+    // back to write and the attribute keeps the text it had.
+    expect(getErrors(stats)).toHaveLength(1);
+    expect(stats.compilation.getAsset("host.page").source.source()).toBe(
+      BROKEN_HANDLER_BODY,
+    );
+  });
+});
diff --git a/types/utils.d.ts b/types/utils.d.ts
index 025ee95..512241e 100644
--- a/types/utils.d.ts
+++ b/types/utils.d.ts
@@ -26,6 +26,22 @@ export type ExtractedComments = string[];
 export type QueryValues = {
   [name: string]: EXPECTED_ANY;
 };
+/**
+ * Which production of a language an embedded body is written in, as `as` names
+ * it. A `style=""` is `css` with `as: "block-contents"`; JavaScript's are these
+ * three, and only the last is one no engine here parses on its own.
+ */
+export const CLASSIC_SCRIPT: "script";
+export const EVENT_HANDLER: "event-handler";
+export const MODULE_SCRIPT: "module";
+/**
+ * The function a body handed out as an event handler belongs to. Named past any
+ * run of `_` the body holds, so nothing in it resolves to the function instead
+ * of what it meant; the newline ends a line comment the body may close with.
+ * @param {string} body the handler's text
+ * @returns {string} the script it is the body of
+ */
+export function asFunction(body: string): string;
 /**
  * Minify CSS using `clean-css`.
  * @param {Input} input input
@@ -190,6 +206,14 @@ export namespace esbuildMinifyCss {
    */
   function filter(name: string): boolean;
 }
+/**
+ * The handler body inside the function a minimizer answered with. `undefined`
+ * for an answer that is not that function — one holding anything else, or one
+ * that dropped it whole as the unused declaration it is.
+ * @param {string | undefined} answered what the minimizer answered
+ * @returns {string | undefined} the body, or undefined
+ */
+export function functionBody(answered: string | undefined): string | undefined;
 /**
  * Map a webpack `output.environment` configuration to the highest
  * ECMAScript version that the target is known to support. Returns `5`