Latest Results
feat: support inline `<script>` tags in HTML modules
Route the body of each `<script>` tag through webpack's JavaScript
pipeline as a `data:text/javascript,...` virtual module so the body is
never reparsed as HTML. Adds rawtext handling for `<script>` (including
`<script src>` whose body is browser-ignored but must not break HTML
parsing) and handles `webpackIgnore` for `<script>`. Non-JS `type`
values (e.g. `application/ld+json`, `importmap`) pass through unchanged.
refactor: route inline `<script>` bodies through the entry pipeline
Bundle each inline `<script>` body as its own webpack entry — the same
pipeline that already processes `<script src>` — and rewrite the tag to
`<script src="…">` with the body cleared. `<script type="module">` is
bundled as an ESM entry; classic inline `<script>` is bundled as
CommonJS (and gets `type="module"` auto-inserted when `output.module`
is on, matching the existing `<script src>` behavior).
Drops the previous code-generation-result approach: inline JS that used
`new URL(...)`/`import.meta.url` produced `__webpack_require__(...)`
calls that couldn't run standalone in the browser. The entry-chunk
output is self-contained and executes the same way an external script
src chunk does.
test: cover inline <script type=module> and output.module on/off
- Extend inline-script (output.module: true) with an inline
<script type="module"> body and verify the module-typed chunk emits as
an ES module (no IIFE bootstrap, no module.exports).
- Add inline-script-classic (output.module: false): classic inline
<script> stays without a type attribute (no auto type=module upgrade)
and inline <script type="module"> keeps its type attribute, while both
emit IIFE-wrapped chunks.
test: add mixed inline-<script> coverage for both output.module modes
Strengthen the inline-script and inline-script-classic tests to
explicitly verify chunk formats for mixed inline `<script>` /
`<script type="module">` bodies in the same HTML file:
- output.module: true — every chunk is ES-module formatted, regardless
of whether the original tag was classic or module-typed.
- output.module: false — every chunk is classic-formatted (IIFE leader
or webpackChunk push follower), with no top-level ES-module
import/export syntax.
feat: drop type=module from inline <script> when output.module is off
When `output.module` is disabled webpack emits classic IIFE chunks; if
the original inline tag was `<script type="module">` the rewritten tag
would load the classic chunk under ES-module semantics, which is wrong.
Drop the `type="module"` attribute (consuming one leading whitespace
char so the remaining attributes don't end up double-spaced) so the
browser loads the chunk as a classic script.
This is the symmetric counterpart to the existing `output.module: true`
behavior that auto-inserts `type="module"` on classic inline `<script>`.
Updates the inline-script-classic test to assert the removal and
refreshes the `basic` test snapshot (its fixture has inline
`<script type="module">` with no `output.module`).
feat: drop type=module from <script src> too when output.module is off
Mirror the symmetric type-attribute reconciliation across the two
`<script>` paths so the rewritten tag always reflects the emitted
chunk's actual format:
- output.module: true → add `type="module"` on classic scripts
(existing behavior, both inline and src)
- output.module: false → drop `type="module"` on module-typed scripts
(new for `<script src>`, already in place for inline)
Updates the script-src-classic test: it now asserts that
`type="module"` is removed from the rewritten tag, and it finds the
module-origin chunk by source content (`"module entry"`) instead of
by `type="module"` shape.claude/add-inline-script-support-MDz2F feat: support inline `<script>` tags in HTML modules
Route the body of each `<script>` tag through webpack's JavaScript
pipeline as a `data:text/javascript,...` virtual module so the body is
never reparsed as HTML. Adds rawtext handling for `<script>` (including
`<script src>` whose body is browser-ignored but must not break HTML
parsing) and handles `webpackIgnore` for `<script>`. Non-JS `type`
values (e.g. `application/ld+json`, `importmap`) pass through unchanged.
refactor: route inline `<script>` bodies through the entry pipeline
Bundle each inline `<script>` body as its own webpack entry — the same
pipeline that already processes `<script src>` — and rewrite the tag to
`<script src="…">` with the body cleared. `<script type="module">` is
bundled as an ESM entry; classic inline `<script>` is bundled as
CommonJS (and gets `type="module"` auto-inserted when `output.module`
is on, matching the existing `<script src>` behavior).
Drops the previous code-generation-result approach: inline JS that used
`new URL(...)`/`import.meta.url` produced `__webpack_require__(...)`
calls that couldn't run standalone in the browser. The entry-chunk
output is self-contained and executes the same way an external script
src chunk does.
test: cover inline <script type=module> and output.module on/off
- Extend inline-script (output.module: true) with an inline
<script type="module"> body and verify the module-typed chunk emits as
an ES module (no IIFE bootstrap, no module.exports).
- Add inline-script-classic (output.module: false): classic inline
<script> stays without a type attribute (no auto type=module upgrade)
and inline <script type="module"> keeps its type attribute, while both
emit IIFE-wrapped chunks.
test: add mixed inline-<script> coverage for both output.module modes
Strengthen the inline-script and inline-script-classic tests to
explicitly verify chunk formats for mixed inline `<script>` /
`<script type="module">` bodies in the same HTML file:
- output.module: true — every chunk is ES-module formatted, regardless
of whether the original tag was classic or module-typed.
- output.module: false — every chunk is classic-formatted (IIFE leader
or webpackChunk push follower), with no top-level ES-module
import/export syntax.
feat: drop type=module from inline <script> when output.module is off
When `output.module` is disabled webpack emits classic IIFE chunks; if
the original inline tag was `<script type="module">` the rewritten tag
would load the classic chunk under ES-module semantics, which is wrong.
Drop the `type="module"` attribute (consuming one leading whitespace
char so the remaining attributes don't end up double-spaced) so the
browser loads the chunk as a classic script.
This is the symmetric counterpart to the existing `output.module: true`
behavior that auto-inserts `type="module"` on classic inline `<script>`.
Updates the inline-script-classic test to assert the removal and
refreshes the `basic` test snapshot (its fixture has inline
`<script type="module">` with no `output.module`).
feat: drop type=module from <script src> too when output.module is off
Mirror the symmetric type-attribute reconciliation across the two
`<script>` paths so the rewritten tag always reflects the emitted
chunk's actual format:
- output.module: true → add `type="module"` on classic scripts
(existing behavior, both inline and src)
- output.module: false → drop `type="module"` on module-typed scripts
(new for `<script src>`, already in place for inline)
Updates the script-src-classic test: it now asserts that
`type="module"` is removed from the rewritten tag, and it finds the
module-origin chunk by source content (`"module entry"`) instead of
by `type="module"` shape.claude/add-inline-script-support-MDz2F feat: support inline `<script>` tags in HTML modules
Route the body of each `<script>` tag through webpack's JavaScript
pipeline as a `data:text/javascript,...` virtual module so the body is
never reparsed as HTML. Adds rawtext handling for `<script>` (including
`<script src>` whose body is browser-ignored but must not break HTML
parsing) and handles `webpackIgnore` for `<script>`. Non-JS `type`
values (e.g. `application/ld+json`, `importmap`) pass through unchanged.
refactor: route inline `<script>` bodies through the entry pipeline
Bundle each inline `<script>` body as its own webpack entry — the same
pipeline that already processes `<script src>` — and rewrite the tag to
`<script src="…">` with the body cleared. `<script type="module">` is
bundled as an ESM entry; classic inline `<script>` is bundled as
CommonJS (and gets `type="module"` auto-inserted when `output.module`
is on, matching the existing `<script src>` behavior).
Drops the previous code-generation-result approach: inline JS that used
`new URL(...)`/`import.meta.url` produced `__webpack_require__(...)`
calls that couldn't run standalone in the browser. The entry-chunk
output is self-contained and executes the same way an external script
src chunk does.
test: cover inline <script type=module> and output.module on/off
- Extend inline-script (output.module: true) with an inline
<script type="module"> body and verify the module-typed chunk emits as
an ES module (no IIFE bootstrap, no module.exports).
- Add inline-script-classic (output.module: false): classic inline
<script> stays without a type attribute (no auto type=module upgrade)
and inline <script type="module"> keeps its type attribute, while both
emit IIFE-wrapped chunks.
test: add mixed inline-<script> coverage for both output.module modes
Strengthen the inline-script and inline-script-classic tests to
explicitly verify chunk formats for mixed inline `<script>` /
`<script type="module">` bodies in the same HTML file:
- output.module: true — every chunk is ES-module formatted, regardless
of whether the original tag was classic or module-typed.
- output.module: false — every chunk is classic-formatted (IIFE leader
or webpackChunk push follower), with no top-level ES-module
import/export syntax.
feat: drop type=module from inline <script> when output.module is off
When `output.module` is disabled webpack emits classic IIFE chunks; if
the original inline tag was `<script type="module">` the rewritten tag
would load the classic chunk under ES-module semantics, which is wrong.
Drop the `type="module"` attribute (consuming one leading whitespace
char so the remaining attributes don't end up double-spaced) so the
browser loads the chunk as a classic script.
This is the symmetric counterpart to the existing `output.module: true`
behavior that auto-inserts `type="module"` on classic inline `<script>`.
Updates the inline-script-classic test to assert the removal and
refreshes the `basic` test snapshot (its fixture has inline
`<script type="module">` with no `output.module`).
feat: drop type=module from <script src> too when output.module is off
Mirror the symmetric type-attribute reconciliation across the two
`<script>` paths so the rewritten tag always reflects the emitted
chunk's actual format:
- output.module: true → add `type="module"` on classic scripts
(existing behavior, both inline and src)
- output.module: false → drop `type="module"` on module-typed scripts
(new for `<script src>`, already in place for inline)
Updates the script-src-classic test: it now asserts that
`type="module"` is removed from the rewritten tag, and it finds the
module-origin chunk by source content (`"module entry"`) instead of
by `type="module"` shape.claude/add-inline-script-support-MDz2F Latest Branches
-33%
test-different-caching-system -24%
-36%
claude/review-typescript-support-Iq6Sj © 2026 CodSpeed Technology