@jsenv/sourcemap 1.4.2 → 1.4.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jsenv/sourcemap",
-  "version": "1.4.2",
+  "version": "1.4.4",
   "type": "module",
   "repository": {
     "type": "git",
@@ -13,8 +13,10 @@
     "./*": "./*"
   },
   "dependencies": {
+    "@jridgewell/gen-mapping": "0.3.13",
+    "@jridgewell/trace-mapping": "0.3.31",
     "@jsenv/urls": "2.9.10",
-    "magic-string": "1.0.0",
+    "magic-string": "1.2.3",
     "source-map-js": "1.2.1"
   },
   "publishConfig": {

package/src/magic_source.js

@@ -32,14 +32,28 @@ export const createMagicSource = (content) => {
         };
       }
       const code = magicString.toString();
-      const map = magicString.generateMap({
-        hires: true,
-        includeContent: true,
-        source,
-      });
+      // The map is generated when first read, not here: a consumer that
+      // throws sourcemaps away (a build with sourcemaps "none") never reads
+      // it, and generating a high resolution map costs as much as the edit.
+      let map;
       return {
         content: code,
-        sourcemap: map,
+        get sourcemap() {
+          if (map === undefined) {
+            // "boundary" = a mapping per word boundary. Per-character maps
+            // (hires: true) only add sub-word precision and cost ~25% of a
+            // package build in generation + composition + GC; line-level maps
+            // (hires: false) are cheaper still but collapse heavily rewritten
+            // lines (JSX) to their edit points. Word precision is what
+            // breakpoints, stack traces and devtools hovers actually consume.
+            map = magicString.generateMap({
+              hires: "boundary",
+              includeContent: true,
+              source,
+            });
+          }
+          return map;
+        },
       };
     },
   };

package/src/sourcemap_composition_v3.js

@@ -1,10 +1,25 @@
 /*
- * https://github.com/mozilla/source-map#sourcemapgenerator
+ * https://github.com/jridgewell/trace-mapping
+ * https://github.com/jridgewell/gen-mapping
+ *
+ * @jridgewell/* rather than source-map-js (still used by
+ * original_position.js): composing is the hot spot of a build with
+ * sourcemaps, and source-map-js sorts + binary searches its mappings on
+ * every lookup where trace-mapping walks them in order. On @jsenv/navi
+ * (3MB bundle, 18MB map) the build went from 11s to 4.6s for a map that is
+ * byte for byte the one source-map-js produced.
  */
 
-import { requireSourcemap } from "./require_sourcemap.js";
-
-const { SourceMapConsumer, SourceMapGenerator } = requireSourcemap();
+import {
+  addMapping,
+  GenMapping,
+  toEncodedMap,
+} from "@jridgewell/gen-mapping";
+import {
+  eachMapping,
+  originalPositionFor,
+  TraceMap,
+} from "@jridgewell/trace-mapping";
 
 // "first" maps an intermediate content back to the true original source(s);
 // "second" maps the final content back to that same intermediate content
@@ -24,10 +39,11 @@ export const composeTwoSourcemaps = (firstSourcemap, secondSourcemap) => {
   if (!secondSourcemap) {
     return firstSourcemap;
   }
-  const sourcemapGenerator = new SourceMapGenerator();
-  const firstSourcemapConsumer = new SourceMapConsumer(firstSourcemap);
-  const secondSourcemapConsumer = new SourceMapConsumer(secondSourcemap);
-  secondSourcemapConsumer.eachMapping(
+  const genMapping = new GenMapping();
+  const firstTraceMap = new TraceMap(firstSourcemap);
+  const secondTraceMap = new TraceMap(secondSourcemap);
+  eachMapping(
+    secondTraceMap,
     ({
       generatedLine,
       generatedColumn,
@@ -40,7 +56,7 @@ export const composeTwoSourcemaps = (firstSourcemap, secondSourcemap) => {
         // content) — nothing to chain through "first", leave unmapped.
         return;
       }
-      const original = firstSourcemapConsumer.originalPositionFor({
+      const original = originalPositionFor(firstTraceMap, {
         line: originalLine,
         column: originalColumn,
       });
@@ -49,7 +65,10 @@ export const composeTwoSourcemaps = (firstSourcemap, secondSourcemap) => {
         // — leave unmapped rather than guessing.
         return;
       }
-      sourcemapGenerator.addMapping({
+      // addMapping, not maybeAddMapping: the latter drops mappings it
+      // considers redundant with the previous one, which shrinks the map
+      // but loses positions (a real fidelity change, to decide on its own).
+      addMapping(genMapping, {
         generated: { line: generatedLine, column: generatedColumn },
         original: { line: original.line, column: original.column },
         source: original.source,
@@ -57,12 +76,16 @@ export const composeTwoSourcemaps = (firstSourcemap, secondSourcemap) => {
       });
     },
   );
-  const sourcemap = sourcemapGenerator.toJSON();
-  const sources = [];
+  const encodedMap = toEncodedMap(genMapping);
+  const sourcemap = {
+    version: 3,
+    sources: [...encodedMap.sources],
+    names: [...encodedMap.names],
+    mappings: encodedMap.mappings,
+  };
   const sourcesContent = [];
   const firstSourcesContent = firstSourcemap.sourcesContent;
   sourcemap.sources.forEach((source) => {
-    sources.push(source);
     if (firstSourcesContent) {
       const firstSourceIndex = firstSourcemap.sources.indexOf(source);
       if (firstSourceIndex > -1) {
@@ -72,7 +95,6 @@ export const composeTwoSourcemaps = (firstSourcemap, secondSourcemap) => {
     }
     sourcesContent.push(null);
   });
-  sourcemap.sources = sources;
   sourcemap.sourcesContent = sourcesContent;
   return sourcemap;
 };