@jridgewell/trace-mapping - npm Package Compare versions

Comparing version 0.3.9 to 0.3.10

dist/trace-mapping.umd.js

@@ -111,3 +111,3 @@ (function (global, factory) {
     function upperBound(haystack, needle, index) {
-        for (let i = index + 1; i < haystack.length; i++, index++) {
+        for (let i = index + 1; i < haystack.length; index = i++) {
             if (haystack[i][COLUMN] !== needle)
@@ -119,3 +119,3 @@ break;
     function lowerBound(haystack, needle, index) {
-        for (let i = index - 1; i >= 0; i--, index--) {
+        for (let i = index - 1; i >= 0; index = i--) {
             if (haystack[i][COLUMN] !== needle)
@@ -208,11 +208,3 @@ break;
         const names = [];
-        const { sections } = parsed;
-        let i = 0;
-        for (; i < sections.length - 1; i++) {
-            const no = sections[i + 1].offset;
-            addSection(sections[i], mapUrl, mappings, sources, sourcesContent, names, no.line, no.column);
-        }
-        if (sections.length > 0) {
-            addSection(sections[i], mapUrl, mappings, sources, sourcesContent, names, Infinity, Infinity);
-        }
+        recurse(parsed, mapUrl, mappings, sources, sourcesContent, names, 0, 0, Infinity, Infinity);
         const joined = {
@@ -228,28 +220,51 @@ version: 3,
     };
-    function addSection(section, mapUrl, mappings, sources, sourcesContent, names, stopLine, stopColumn) {
-        const map = AnyMap(section.map, mapUrl);
-        const { line: lineOffset, column: columnOffset } = section.offset;
+    function recurse(input, mapUrl, mappings, sources, sourcesContent, names, lineOffset, columnOffset, stopLine, stopColumn) {
+        const { sections } = input;
+        for (let i = 0; i < sections.length; i++) {
+            const { map, offset } = sections[i];
+            let sl = stopLine;
+            let sc = stopColumn;
+            if (i + 1 < sections.length) {
+                const nextOffset = sections[i + 1].offset;
+                sl = Math.min(stopLine, lineOffset + nextOffset.line);
+                if (sl === stopLine) {
+                    sc = Math.min(stopColumn, columnOffset + nextOffset.column);
+                }
+                else if (sl < stopLine) {
+                    sc = columnOffset + nextOffset.column;
+                }
+            }
+            addSection(map, mapUrl, mappings, sources, sourcesContent, names, lineOffset + offset.line, columnOffset + offset.column, sl, sc);
+        }
+    }
+    function addSection(input, mapUrl, mappings, sources, sourcesContent, names, lineOffset, columnOffset, stopLine, stopColumn) {
+        if ('sections' in input)
+            return recurse(...arguments);
+        const map = new TraceMap(input, mapUrl);
         const sourcesOffset = sources.length;
         const namesOffset = names.length;
         const decoded = exports.decodedMappings(map);
-        const { resolvedSources } = map;
+        const { resolvedSources, sourcesContent: contents } = map;
         append(sources, resolvedSources);
-        append(sourcesContent, map.sourcesContent || fillSourcesContent(resolvedSources.length));
         append(names, map.names);
-        // If this section jumps forwards several lines, we need to add lines to the output mappings catch up.
-        for (let i = mappings.length; i <= lineOffset; i++)
-            mappings.push([]);
-        // We can only add so many lines before we step into the range that the next section's map
-        // controls. When we get to the last line, then we'll start checking the segments to see if
-        // they've crossed into the column range.
-        const stopI = stopLine - lineOffset;
-        const len = Math.min(decoded.length, stopI + 1);
-        for (let i = 0; i < len; i++) {
-            const line = decoded[i];
-            // On the 0th loop, the line will already exist due to a previous section, or the line catch up
-            // loop above.
-            const out = i === 0 ? mappings[lineOffset] : (mappings[lineOffset + i] = []);
+        if (contents)
+            append(sourcesContent, contents);
+        else
+            for (let i = 0; i < resolvedSources.length; i++)
+                sourcesContent.push(null);
+        for (let i = 0; i < decoded.length; i++) {
+            const lineI = lineOffset + i;
+            // We can only add so many lines before we step into the range that the next section's map
+            // controls. When we get to the last line, then we'll start checking the segments to see if
+            // they've crossed into the column range. But it may not have any columns that overstep, so we
+            // still need to check that we don't overstep lines, too.
+            if (lineI > stopLine)
+                return;
+            // The out line may already exist in mappings (if we're continuing the line started by a
+            // previous section). Or, we may have jumped ahead several lines to start this section.
+            const out = getLine(mappings, lineI);
             // On the 0th loop, the section's column offset shifts us forward. On all other lines (since the
             // map can be multiple lines), it doesn't.
             const cOffset = i === 0 ? columnOffset : 0;
+            const line = decoded[i];
             for (let j = 0; j < line.length; j++) {
@@ -260,4 +275,4 @@ const seg = line[j];
                 // to stop early.
-                if (i === stopI && column >= stopColumn)
-                    break;
+                if (lineI === stopLine && column >= stopColumn)
+                    return;
                 if (seg.length === 1) {
@@ -270,7 +285,5 @@ out.push([column]);
                 const sourceColumn = seg[SOURCE_COLUMN];
-                if (seg.length === 4) {
-                    out.push([column, sourcesIndex, sourceLine, sourceColumn]);
-                    continue;
-                }
-                out.push([column, sourcesIndex, sourceLine, sourceColumn, namesOffset + seg[NAMES_INDEX]]);
+                out.push(seg.length === 4
+                    ? [column, sourcesIndex, sourceLine, sourceColumn]
+                    : [column, sourcesIndex, sourceLine, sourceColumn, namesOffset + seg[NAMES_INDEX]]);
             }
@@ -283,11 +296,6 @@ }
     }
-    // Sourcemaps don't need to have sourcesContent, and if they don't, we need to create an array of
-    // equal length to the sources. This is because the sources and sourcesContent are paired arrays,
-    // where `sourcesContent[i]` is the content of the `sources[i]` file. If we didn't, then joined
-    // sourcemap would desynchronize the sources/contents.
-    function fillSourcesContent(len) {
-        const sourcesContent = [];
-        for (let i = 0; i < len; i++)
-            sourcesContent[i] = null;
-        return sourcesContent;
+    function getLine(arr, index) {
+        for (let i = arr.length; i <= index; i++)
+            arr[i] = [];
+        return arr[index];
     }
@@ -361,3 +369,3 @@
             const isString = typeof map === 'string';
-            if (!isString && map.constructor === TraceMap)
+            if (!isString && map._decodedMemo)
                 return map;
@@ -364,0 +372,0 @@ const parsed = (isString ? JSON.parse(map) : map);

package.json

 {
   "name": "@jridgewell/trace-mapping",
-  "version": "0.3.9",
+  "version": "0.3.10",
   "description": "Trace the original position through a source map",
@@ -17,2 +17,3 @@ "keywords": [
     ".": {
+      "types": "./dist/types/trace-mapping.d.ts",
       "browser": "./dist/trace-mapping.umd.js",
@@ -33,3 +34,3 @@ "require": "./dist/trace-mapping.umd.js",
     "benchmark:install": "cd benchmark && npm install",
-    "benchmark:only": "node benchmark/index.mjs",
+    "benchmark:only": "node --expose-gc benchmark/index.mjs",
     "build": "run-s -n build:*",
@@ -63,2 +64,3 @@ "build:rollup": "rollup -c rollup.config.js",
     "eslint-config-prettier": "8.3.0",
+    "eslint-plugin-no-only-tests": "2.6.0",
     "npm-run-all": "4.1.5",
@@ -65,0 +67,0 @@ "prettier": "2.5.1",

README.md

@@ -122,70 +122,120 @@ # @jridgewell/trace-mapping
 
-amp.js.map
-trace-mapping:    decoded JSON input x 183 ops/sec ±0.41% (87 runs sampled)
-trace-mapping:    encoded JSON input x 384 ops/sec ±0.89% (89 runs sampled)
-trace-mapping:    decoded Object input x 3,085 ops/sec ±0.24% (100 runs sampled)
-trace-mapping:    encoded Object input x 452 ops/sec ±0.80% (84 runs sampled)
-source-map-js:    encoded Object input x 88.82 ops/sec ±0.45% (77 runs sampled)
-source-map-0.6.1: encoded Object input x 38.39 ops/sec ±1.88% (52 runs sampled)
+amp.js.map - 45120 segments
+
+Memory Usage:
+trace-mapping decoded         562400 bytes
+trace-mapping encoded        5706544 bytes
+source-map-js               10717664 bytes
+source-map-0.6.1            17446384 bytes
+source-map-0.8.0             9701757 bytes
+Smallest memory usage is trace-mapping decoded
+
+Init speed:
+trace-mapping:    decoded JSON input x 180 ops/sec ±0.34% (85 runs sampled)
+trace-mapping:    encoded JSON input x 364 ops/sec ±1.77% (89 runs sampled)
+trace-mapping:    decoded Object input x 3,116 ops/sec ±0.50% (96 runs sampled)
+trace-mapping:    encoded Object input x 410 ops/sec ±2.62% (85 runs sampled)
+source-map-js:    encoded Object input x 84.23 ops/sec ±0.91% (73 runs sampled)
+source-map-0.6.1: encoded Object input x 37.21 ops/sec ±2.08% (51 runs sampled)
 Fastest is trace-mapping:    decoded Object input
 
-trace-mapping:    decoded originalPositionFor x 4,025,347 ops/sec ±0.15% (97 runs sampled)
-trace-mapping:    encoded originalPositionFor x 3,333,136 ops/sec ±1.26% (90 runs sampled)
-source-map-js:    encoded originalPositionFor x 824,978 ops/sec ±1.06% (94 runs sampled)
-source-map-0.6.1: encoded originalPositionFor x 741,300 ops/sec ±0.93% (92 runs sampled)
-source-map-0.8.0: encoded originalPositionFor x 2,587,603 ops/sec ±0.75% (97 runs sampled)
+Trace speed:
+trace-mapping:    decoded originalPositionFor x 3,952,212 ops/sec ±0.17% (98 runs sampled)
+trace-mapping:    encoded originalPositionFor x 3,487,468 ops/sec ±1.58% (90 runs sampled)
+source-map-js:    encoded originalPositionFor x 827,730 ops/sec ±0.78% (97 runs sampled)
+source-map-0.6.1: encoded originalPositionFor x 748,991 ops/sec ±0.53% (94 runs sampled)
+source-map-0.8.0: encoded originalPositionFor x 2,532,894 ops/sec ±0.57% (95 runs sampled)
 Fastest is trace-mapping:    decoded originalPositionFor
 
+
 ***
 
-babel.min.js.map
-trace-mapping:    decoded JSON input x 17.43 ops/sec ±8.81% (33 runs sampled)
-trace-mapping:    encoded JSON input x 34.18 ops/sec ±4.67% (50 runs sampled)
-trace-mapping:    decoded Object input x 1,010 ops/sec ±0.41% (98 runs sampled)
-trace-mapping:    encoded Object input x 39.45 ops/sec ±4.01% (52 runs sampled)
-source-map-js:    encoded Object input x 6.57 ops/sec ±3.04% (21 runs sampled)
-source-map-0.6.1: encoded Object input x 4.23 ops/sec ±2.93% (15 runs sampled)
+
+babel.min.js.map - 347793 segments
+
+Memory Usage:
+trace-mapping decoded          89832 bytes
+trace-mapping encoded       35474640 bytes
+source-map-js               51257176 bytes
+source-map-0.6.1            63515664 bytes
+source-map-0.8.0            42933752 bytes
+Smallest memory usage is trace-mapping decoded
+
+Init speed:
+trace-mapping:    decoded JSON input x 15.41 ops/sec ±8.65% (34 runs sampled)
+trace-mapping:    encoded JSON input x 28.20 ops/sec ±12.87% (42 runs sampled)
+trace-mapping:    decoded Object input x 964 ops/sec ±0.36% (99 runs sampled)
+trace-mapping:    encoded Object input x 31.77 ops/sec ±13.79% (45 runs sampled)
+source-map-js:    encoded Object input x 6.45 ops/sec ±5.16% (21 runs sampled)
+source-map-0.6.1: encoded Object input x 4.07 ops/sec ±5.24% (15 runs sampled)
 Fastest is trace-mapping:    decoded Object input
 
-trace-mapping:    decoded originalPositionFor x 7,576,265 ops/sec ±0.74% (96 runs sampled)
-trace-mapping:    encoded originalPositionFor x 5,019,743 ops/sec ±0.74% (94 runs sampled)
-source-map-js:    encoded originalPositionFor x 3,396,137 ops/sec ±42.32% (95 runs sampled)
-source-map-0.6.1: encoded originalPositionFor x 3,753,176 ops/sec ±0.72% (95 runs sampled)
-source-map-0.8.0: encoded originalPositionFor x 6,423,633 ops/sec ±0.74% (95 runs sampled)
+Trace speed:
+trace-mapping:    decoded originalPositionFor x 7,183,038 ops/sec ±0.58% (95 runs sampled)
+trace-mapping:    encoded originalPositionFor x 5,192,185 ops/sec ±0.41% (100 runs sampled)
+source-map-js:    encoded originalPositionFor x 4,259,489 ops/sec ±0.79% (94 runs sampled)
+source-map-0.6.1: encoded originalPositionFor x 3,742,629 ops/sec ±0.71% (95 runs sampled)
+source-map-0.8.0: encoded originalPositionFor x 6,270,211 ops/sec ±0.64% (94 runs sampled)
 Fastest is trace-mapping:    decoded originalPositionFor
 
+
 ***
 
-preact.js.map
-trace-mapping:    decoded JSON input x 3,499 ops/sec ±0.18% (98 runs sampled)
-trace-mapping:    encoded JSON input x 6,078 ops/sec ±0.25% (99 runs sampled)
-trace-mapping:    decoded Object input x 254,788 ops/sec ±0.13% (100 runs sampled)
-trace-mapping:    encoded Object input x 14,063 ops/sec ±0.27% (94 runs sampled)
-source-map-js:    encoded Object input x 2,465 ops/sec ±0.25% (98 runs sampled)
-source-map-0.6.1: encoded Object input x 1,174 ops/sec ±1.90% (95 runs sampled)
+
+preact.js.map - 1992 segments
+
+Memory Usage:
+trace-mapping decoded          37128 bytes
+trace-mapping encoded         247280 bytes
+source-map-js                1143536 bytes
+source-map-0.6.1             1290992 bytes
+source-map-0.8.0               96544 bytes
+Smallest memory usage is trace-mapping decoded
+
+Init speed:
+trace-mapping:    decoded JSON input x 3,483 ops/sec ±0.30% (98 runs sampled)
+trace-mapping:    encoded JSON input x 6,092 ops/sec ±0.18% (97 runs sampled)
+trace-mapping:    decoded Object input x 249,076 ops/sec ±0.24% (98 runs sampled)
+trace-mapping:    encoded Object input x 14,555 ops/sec ±0.48% (100 runs sampled)
+source-map-js:    encoded Object input x 2,447 ops/sec ±0.36% (99 runs sampled)
+source-map-0.6.1: encoded Object input x 1,201 ops/sec ±0.57% (96 runs sampled)
 Fastest is trace-mapping:    decoded Object input
 
-trace-mapping:    decoded originalPositionFor x 7,720,171 ops/sec ±0.14% (97 runs sampled)
-trace-mapping:    encoded originalPositionFor x 6,864,485 ops/sec ±0.16% (101 runs sampled)
-source-map-js:    encoded originalPositionFor x 2,387,219 ops/sec ±0.28% (98 runs sampled)
-source-map-0.6.1: encoded originalPositionFor x 1,565,339 ops/sec ±0.32% (101 runs sampled)
-source-map-0.8.0: encoded originalPositionFor x 3,819,732 ops/sec ±0.38% (98 runs sampled)
+Trace speed:
+trace-mapping:    decoded originalPositionFor x 7,620,192 ops/sec ±0.09% (99 runs sampled)
+trace-mapping:    encoded originalPositionFor x 6,872,554 ops/sec ±0.30% (97 runs sampled)
+source-map-js:    encoded originalPositionFor x 2,489,570 ops/sec ±0.35% (94 runs sampled)
+source-map-0.6.1: encoded originalPositionFor x 1,698,633 ops/sec ±0.28% (98 runs sampled)
+source-map-0.8.0: encoded originalPositionFor x 4,015,644 ops/sec ±0.22% (98 runs sampled)
 Fastest is trace-mapping:    decoded originalPositionFor
 
+
 ***
 
-react.js.map
-trace-mapping:    decoded JSON input x 1,719 ops/sec ±0.19% (99 runs sampled)
-trace-mapping:    encoded JSON input x 4,284 ops/sec ±0.51% (99 runs sampled)
-trace-mapping:    decoded Object input x 94,668 ops/sec ±0.08% (99 runs sampled)
-trace-mapping:    encoded Object input x 5,287 ops/sec ±0.24% (99 runs sampled)
-source-map-js:    encoded Object input x 814 ops/sec ±0.20% (98 runs sampled)
-source-map-0.6.1: encoded Object input x 429 ops/sec ±0.24% (94 runs sampled)
+
+react.js.map - 5726 segments
+
+Memory Usage:
+trace-mapping decoded          16176 bytes
+trace-mapping encoded         681552 bytes
+source-map-js                2418352 bytes
+source-map-0.6.1             2443672 bytes
+source-map-0.8.0              111768 bytes
+Smallest memory usage is trace-mapping decoded
+
+Init speed:
+trace-mapping:    decoded JSON input x 1,720 ops/sec ±0.34% (98 runs sampled)
+trace-mapping:    encoded JSON input x 4,406 ops/sec ±0.35% (100 runs sampled)
+trace-mapping:    decoded Object input x 92,122 ops/sec ±0.10% (99 runs sampled)
+trace-mapping:    encoded Object input x 5,385 ops/sec ±0.37% (99 runs sampled)
+source-map-js:    encoded Object input x 794 ops/sec ±0.40% (98 runs sampled)
+source-map-0.6.1: encoded Object input x 416 ops/sec ±0.54% (91 runs sampled)
 Fastest is trace-mapping:    decoded Object input
 
-trace-mapping:    decoded originalPositionFor x 28,927,989 ops/sec ±0.61% (94 runs sampled)
-trace-mapping:    encoded originalPositionFor x 27,394,475 ops/sec ±0.55% (97 runs sampled)
-source-map-js:    encoded originalPositionFor x 16,856,730 ops/sec ±0.45% (96 runs sampled)
-source-map-0.6.1: encoded originalPositionFor x 12,258,950 ops/sec ±0.41% (97 runs sampled)
-source-map-0.8.0: encoded originalPositionFor x 22,272,990 ops/sec ±0.58% (95 runs sampled)
+Trace speed:
+trace-mapping:    decoded originalPositionFor x 32,759,519 ops/sec ±0.33% (100 runs sampled)
+trace-mapping:    encoded originalPositionFor x 31,116,306 ops/sec ±0.33% (97 runs sampled)
+source-map-js:    encoded originalPositionFor x 17,458,435 ops/sec ±0.44% (97 runs sampled)
+source-map-0.6.1: encoded originalPositionFor x 12,687,097 ops/sec ±0.43% (95 runs sampled)
+source-map-0.8.0: encoded originalPositionFor x 23,538,275 ops/sec ±0.38% (95 runs sampled)
 Fastest is trace-mapping:    decoded originalPositionFor
@@ -192,0 +242,0 @@ ```

No alert changes

Improved metrics

Total package byte prevSize

94900

increased by2.84%

Lines of code

1261

increased by1.29%

Number of lines in readme file

244

increased by25.77%

Worsened metrics

Dev dependency count

15

increased by7.14%

No dependency changes