Tagged articles
ESM
44 articles · Page 1 of 1
Node.js 26 becomes Active LTS while Node.js 22 nears end-of-life; key upgrades include a configuration file for CLI flags, synchronous require() loading of most ESM modules, and built-in util.throttle and util.debounce utilities reducing third-party dependencies.
ESMLTSNode.js
0 likes · 4 min read

At Vue Fes Japan 2026, Evan You confirmed Vue 4 will avoid large breaking changes, drop CommonJS for ESM-only distribution, and leave major features like Vapor Mode undecided, while emphasizing a toolchain shift toward AI-agent-friendly outputs via Rust-based tools like Rolldown and Oxc.
AI agentsESMOxc
0 likes · 5 min read

NestJS 12 releases core packages as ESM while preserving CommonJS compatibility via Node.js's require(esm), introduces Vitest and oxlint as defaults for new ESM projects, adopts Rspack for monorepos, adds Standard Schema support for validation and serialization, and includes an official observability SDK with distributed tracing.
CommonJSESMNestJS
0 likes · 11 min read


21CTOAug 13, 2026 · Frontend Development
Evan You announced the formation of a new company and the official release of Pinia 4, highlighting a shift to pure ESM modules, a 77% bundle‑size reduction, a modern nostics‑based error‑diagnostics system, the adoption of ES2022 Object.hasOwn, and the debut of Pinia Colada 1.0 with deep Vue‑Router integration, while also outlining the strategic governance behind Vue’s sustainable development.
ESMError DiagnosticsJavaScript
0 likes · 8 min read

Rspack 2.0 launches with up to 10 × build speed gains over version 1.0, refined default APIs, pure‑ESM packages, enhanced tree‑shaking, React Server Components support, simplified target configuration, hash‑based module IDs and improved code‑splitting, while maintaining webpack compatibility and expanding ecosystem integrations.
ESMReact Server ComponentsRspack
0 likes · 24 min read

The paper reveals that multi‑task models suffer performance drops because tasks compete for the same internal subspace, and introduces Essential Subspace Merging (ESM) which separates critical directions and uses Polarized Scaling to keep multiple abilities stable, achieving significantly lower degradation than traditional baselines.
ESDESMessential subspace
0 likes · 16 min read

A French team at the Pasteur Institute built three complementary deep‑learning models—ALBERT_DF, ESM_DF, and GeneCLR_DF—to predict anti‑phage proteins at genome scale, achieving 99% precision and 92% recall, and uncovered roughly 2.39 million candidate proteins and 23 000 novel operon families, dramatically expanding the known bacterial antiviral repertoire.
ALBERTESMGeneCLR
0 likes · 16 min read

Node.js now supports Single Executable Applications (SEA) with ESM entry points, allowing developers to bundle code and the runtime into a single binary, and benchmarks by Evan You demonstrate that the resulting executable launches faster than Bun's compiled mode.
BackendESMNode.js
0 likes · 9 min read

The article examines NestJS v12’s upcoming major changes—including a full migration to ESM, replacing Jest with Vitest, and native Zod schema support—explains the technical reasons behind them, outlines migration timelines, and evaluates how both new and existing projects can adopt the updates with minimal disruption.
ESMNestJSNode.js
0 likes · 10 min read

Node.js now marks require(esm) as stable in LTS releases, allowing CommonJS files to require synchronous ESM modules without extra flags, simplifying package.json configuration, eliminating the need for dual packages, and resolving the long‑standing CJS‑ESM split for the vast majority of projects.
CommonJSESMLTS
0 likes · 8 min read

This article explains why the ECharts library must be imported with the namespace syntax (import * as echarts) by examining ES Module and CommonJS differences, compatibility strategies, historical reasons, and practical guidelines for choosing the correct import style in frontend development.
CommonJSEChartsESM
0 likes · 7 min read

This article dissects Vite’s fast development workflow by detailing how it rewrites bare module imports, resolves dependencies from node_modules, parses Vue single‑file components into template, script, and style sections, compiles them, and dynamically injects the resulting code for seamless browser execution.
ESMFrontend DevelopmentVite
0 likes · 12 min read

This article traces the history and reasons behind JavaScript’s module formats—from early AMD and UMD to Node’s CommonJS and the modern ECMAScript modules—explains migration challenges, tooling, testing nuances, and best practices for managing dual builds in contemporary projects.
CommonJSESMJavaScript
0 likes · 22 min read

This article explains why sharing a single .d.ts file between ESM and CJS can cause FalseEsm and FalseCjs type errors, shows how recent Node and TypeScript updates mitigate the issue, and provides practical solutions such as generating separate .d.cts files or using TS 5.8 with "module": "nodenext".
CJSESMFalseEsm
0 likes · 7 min read

Vite 7.0 introduces major performance upgrades, a Rust‑based bundler called Rolldown, updated Node.js and browser targets, experimental Environment API hooks, and a new DevTools suite, marking a shift from a simple build tool to a full‑stack frontend platform.
DevToolsESMFrontend Build Tools
0 likes · 5 min read


大转转FEFeb 24, 2025 · Industry Insights
This newsletter curates five must‑read frontend articles covering AI‑driven development trends, Kuaishou's Vision platform for motion asset quality, common misconceptions about Electron, the rapid rise of pure ESM modules, and React's first native animation support, offering concise insights and data for developers.
AIESMElectron
0 likes · 4 min read


21CTOSep 7, 2024 · Frontend Development
The VS Code 1.93 release brings a major shift to ESM modules, fixes SQL language highlighting, adds configuration file UI improvements, introduces Django test support, and enhances IntelliSense and experimental network inspection for JavaScript and Node.js developers.
DjangoESMIntelliSense
0 likes · 6 min read

This article dissects the massive 5‑万‑line checker.ts file in the TypeScript compiler, explaining why the team packed the entire type‑system logic into a single file, how low‑level decisions like named‑parameter comments, heavy use of const enum, ESM/CJS export patterns, var usage, and lack of try‑catch affect V8 performance, and what these choices reveal about TypeScript’s evolution.
CompilerESMTypeScript
0 likes · 13 min read

jQuery 4.0.0‑beta.2 introduces a major rewrite of its testing infrastructure, drops legacy IE support, adds full CommonJS and ESM compatibility with proper export handling, removes special Boolean attribute logic, fixes element position calculations in tables, and offers a slimmer build that omits ajax and deferred modules.
BetaBoolean AttributesCommonJS
0 likes · 9 min read

This article traces the evolution of JavaScript module systems—from the early script tags and manual dependency ordering, through CommonJS, AMD, and UMD, to the modern ECMAScript modules—explaining their origins, challenges, and how bundlers and package fields enable seamless usage across browsers and Node.js environments.
AMDCommonJSESM
0 likes · 13 min read

This article explains how Vite speeds up frontend development by serving unbundled ES modules, using a plugin‑based transform pipeline, performing on‑the‑fly compilation, pre‑bundling dependencies with esbuild, and finally leveraging Rollup for production builds while maintaining consistent behavior across dev and prod environments.
Build ToolsESMFrontend Development
0 likes · 9 min read

This guide provides clear, practical recommendations for packaging JavaScript libraries—including outputting ESM, CJS and UMD formats, handling multi‑file builds, code compression, sourcemaps, TypeScript typings, external frameworks, modern browser support, and essential package.json fields—so developers can create robust, tree‑shakable, and well‑documented npm packages.
CJSESMJavaScript
0 likes · 20 min read


21CTOMar 20, 2023 · Frontend Development
TypeScript 5.0 arrives with over 50 new features—including decorators, enhanced ESM support, and expanded JSDoc—while optimizing memory, performance, and bundle size, making the language smaller, simpler, and faster for most developers.
ESMFrontend DevelopmentJSDoc
0 likes · 3 min read

This article explores Vite’s evolution and core architecture, detailing how it improves development server startup time, performs dependency pre‑bundling with esbuild, creates the dev server, handles HTML injection, and implements fast hot‑module replacement through WebSocket communication.
ESMFrontend DevelopmentHot Module Replacement
0 likes · 12 min read

This article explains how third‑party library authors can configure package.json fields such as main, type, exports, and module to provide dynamic entry points for both CommonJS and ESModule consumers, while also covering TypeScript's resolution strategy and practical code examples.
CommonJSESMExports
0 likes · 12 min read


政采云技术Aug 2, 2022 · Frontend Development
This article examines low‑code development platforms and presents three remote component loading strategies—global‑object, AMD (require.js), and ESModule—detailing their packaging, CDN deployment, loading logic, advantages, drawbacks, and a final recommendation for ESModule‑based loading in modern front‑end development.
AMDESMVue
0 likes · 18 min read

Library authors can configure package.json using main, type, exports, and module fields to provide separate CommonJS and ES module entry points, enabling runtime selection based on import or require, improving tree‑shaking, bundler compatibility, and TypeScript type resolution while restricting undefined sub‑paths.
CommonJSESMExports
0 likes · 11 min read

This article explains why, despite years of ESM usage, Node 18 and TypeScript 4.7 still encounter import errors, explores the differences between CommonJS and ESM module resolution, and shows how to configure tsconfig and package.json to make Node correctly run ESM code.
CommonJSESMNode.js
0 likes · 10 min read

Node.js 18 introduces built‑in fetch and test modules, modernizes the standard library, adds a native test runner, upgrades the V8 engine, and outlines future roadmap items such as modern HTTP, improved type support, and enhanced ESM capabilities, all while offering quick installation via version managers.
ESMFetch APINode.js
0 likes · 10 min read

This article examines the limitations of bundle‑based tools like Webpack, introduces Vite’s ESM‑based approach, and provides a detailed analysis of Vite’s architecture, hot‑module‑replacement, module transformation, dependency graph, and plugin system, illustrating how it improves development speed and efficiency.
Build ToolsESMFrontend Development
0 likes · 13 min read

This article provides a comprehensive overview of Vite, covering its definition, advantages over traditional bundlers like Webpack and Snowpack, the underlying ESM‑based development server, hot‑module replacement mechanisms, esbuild pre‑bundling, Rollup integration, plugin architecture, and a balanced summary of its strengths and limitations.
ESMHMRRollup
0 likes · 19 min read

San CLI 4.0 introduces a re‑architected command system, decoupled configuration, Webpack 5 support, TypeScript and ESM build options, and a series of performance tweaks that together improve flexibility, reduce bundle size, and speed up both development and production builds.
ESMPlugin ArchitectureSan CLI
0 likes · 17 min read

This article explains how TypeScript 4.5 adds native support for Node.js ES modules, details the evolution of Node's module system from "main" to "exports", shows the required tsconfig and package.json settings, and provides practical solutions for common import‑export pitfalls.
ESMNode.jsTS4.5
0 likes · 12 min read

This article explains the need for JavaScript modularization, compares major module standards such as CommonJS, AMD, CMD, UMD and ES Modules, and traces their historical evolution, highlighting benefits, drawbacks, and practical usage examples for modern front‑end development.
AMDCommonJSESM
0 likes · 11 min read

This article explains the evolution of JavaScript module standards—from early CommonJS and AMD/UMD approaches to the native ES modules (ESM)—and shows how bundlers, browsers, and tooling work together to manage dependencies, improve code organization, and enable modern web development.
ESMJavaScriptModules
0 likes · 13 min read


ByteFEAug 31, 2021 · Frontend Development
This article explains the concept of Tree Shaking as a dead‑code elimination technique based on ES Modules, details how to enable it in Webpack, describes the underlying implementation steps, and provides practical tips for writing tree‑shakable code while avoiding common pitfalls.
ESMFrontend Developmentdead code elimination
0 likes · 14 min read

This article explains how ESM package distribution services convert npm packages to ESModule format, why such distribution is needed for modern browsers, the technical challenges involved, proposed solutions, and how these services can be combined with next‑generation unbundled development tools like Vite and Snowpack to dramatically speed up dependency installation and development server startup.
CDNESMJavaScript
0 likes · 14 min read

This article explores how various export syntaxes in ES modules affect the binding behavior of imported values in Node.js, demonstrating differences between named exports, default exports, destructuring, and circular dependencies with clear code examples.
ESMExportNode.js
0 likes · 7 min read

This article explains the latest Node.js package module specifications, covering how the "type", "exports", and "imports" fields in package.json determine ESM or CommonJS loading, the history of version changes, subpath mappings, conditional exports, and best practices for dual-module packages.
CommonJSESMExports
0 likes · 27 min read

iMove, a reusable, function‑oriented JavaScript library, adds right‑click online code execution to its visual workflow, eliminating installation, simplifying testing with mock inputs, handling ES module imports via native browser support, CDN transforms, dynamic imports, and custom events to deliver instant, visual results.
CDNESMJavaScript
0 likes · 13 min read

This article explains how Vite improves development experience over traditional bundlers by leveraging native ESM support for a fast dev server, efficient hot‑module replacement, pre‑bundling of Node modules, and seamless integration with Rollup plugins for production builds and SSR.
ESMFrontend DevelopmentHMR
0 likes · 12 min read

With the rise of ESM‑based build tools such as Snowpack and Vite, developers can bypass traditional bundling, achieving faster compilation and leveraging native browser module loading, while Webpack adapts through physical caching and Module Federation, offering flexible module sharing and performance optimizations for modern frontend projects.
ESMVitemodule-federation
0 likes · 13 min read

From revisiting Deno’s impact on package management to introducing the imove visual workflow library, this article examines HTTP‑based module imports, ESM loaders, CDN services like esm.run, and the challenges of replacing Node’s npm ecosystem, highlighting practical code examples and future directions for JavaScript runtimes.
DenoESMHTTP import
0 likes · 8 min read

An in‑depth look at the ongoing debate between CommonJS and ECMAScript Modules in Node.js, drawing on the latest TC39 discussions to explain their implementation differences, practical impacts, and why reconciling them has long puzzled the Node.js community.
CommonJSESMModules
0 likes · 2 min read
