@jsenv/sourcemap 1.0.10 → 1.2.0

package/src/error_stack_remap/remap_stack.js

@@ -1,8 +1,8 @@
-import { DATA_URL } from "@jsenv/urls"
+import { DATA_URL } from "@jsenv/urls";
 
-import { SOURCEMAP } from "../sourcemap_comment.js"
-import { createDetailedMessage } from "./detailed_message.js"
-import { remapCallSite } from "./remap_call_site.js"
+import { SOURCEMAP } from "../sourcemap_comment.js";
+import { createDetailedMessage } from "./detailed_message.js";
+import { remapCallSite } from "./remap_call_site.js";
 
 export const remapStack = async ({
   stack,
@@ -15,17 +15,17 @@ export const remapStack = async ({
   const urlToSourcemapConsumer = memoizeByFirstArgStringValue(
     async (stackTraceFileUrl) => {
       if (stackTraceFileUrl.startsWith("node:")) {
-        return null
+        return null;
       }
 
       try {
-        let text
+        let text;
         try {
-          const fileResponse = await fetchFile(stackTraceFileUrl)
-          const { status } = fileResponse
+          const fileResponse = await fetchFile(stackTraceFileUrl);
+          const { status } = fileResponse;
           if (status !== 200) {
             if (status === 404) {
-              onFailure(`stack trace file not found at ${stackTraceFileUrl}`)
+              onFailure(`stack trace file not found at ${stackTraceFileUrl}`);
             } else {
               onFailure(
                 createDetailedMessage(
@@ -36,46 +36,46 @@ export const remapStack = async ({
                     ["stack trace file"]: stackTraceFileUrl,
                   },
                 ),
-              )
+              );
             }
-            return null
+            return null;
           }
-          text = await fileResponse.text()
+          text = await fileResponse.text();
         } catch (e) {
           onFailure(
             createDetailedMessage(`error while fetching stack trace file.`, {
               ["fetch error stack"]: readErrorStack(e),
               ["stack trace file"]: stackTraceFileUrl,
             }),
-          )
+          );
 
-          return null
+          return null;
         }
 
         const jsSourcemapComment = SOURCEMAP.readComment({
           contentType: "text/javascript",
           content: text,
-        })
+        });
         if (!jsSourcemapComment) {
-          return null
+          return null;
         }
-        const jsSourcemapUrl = jsSourcemapComment.specifier
-        let sourcemapUrl
-        let sourcemapString
+        const jsSourcemapUrl = jsSourcemapComment.specifier;
+        let sourcemapUrl;
+        let sourcemapString;
         if (jsSourcemapUrl.startsWith("data:")) {
-          sourcemapUrl = stackTraceFileUrl
-          sourcemapString = DATA_URL.parse(jsSourcemapUrl, { as: "string" })
+          sourcemapUrl = stackTraceFileUrl;
+          sourcemapString = DATA_URL.parse(jsSourcemapUrl, { as: "string" });
         } else {
           sourcemapUrl = resolveFile(jsSourcemapUrl, stackTraceFileUrl, {
             type: "source-map",
-          })
+          });
 
           try {
-            const sourcemapResponse = await fetchFile(sourcemapUrl)
-            const { status } = sourcemapResponse
+            const sourcemapResponse = await fetchFile(sourcemapUrl);
+            const { status } = sourcemapResponse;
             if (status !== 200) {
               if (status === 404) {
-                onFailure(`sourcemap file not found at ${sourcemapUrl}`)
+                onFailure(`sourcemap file not found at ${sourcemapUrl}`);
               } else {
                 onFailure(
                   createDetailedMessage(
@@ -86,56 +86,56 @@ export const remapStack = async ({
                       ["sourcemap url"]: sourcemapUrl,
                     },
                   ),
-                )
+                );
               }
-              return null
+              return null;
             }
-            sourcemapString = await sourcemapResponse.text()
+            sourcemapString = await sourcemapResponse.text();
           } catch (e) {
             onFailure(
               createDetailedMessage(`error while fetching sourcemap.`, {
                 ["fetch error stack"]: readErrorStack(e),
                 ["sourcemap url"]: sourcemapUrl,
               }),
-            )
-            return null
+            );
+            return null;
           }
         }
 
-        let sourceMap
+        let sourceMap;
         try {
-          sourceMap = JSON.parse(sourcemapString)
+          sourceMap = JSON.parse(sourcemapString);
         } catch (e) {
           onFailure(
             createDetailedMessage(`error while parsing sourcemap.`, {
               ["parse error stack"]: readErrorStack(e),
               ["sourcemap url"]: sourcemapUrl,
             }),
-          )
-          return null
+          );
+          return null;
         }
 
-        let { sourcesContent } = sourceMap
+        let { sourcesContent } = sourceMap;
 
         if (!sourcesContent) {
-          sourcesContent = []
-          sourceMap.sourcesContent = sourcesContent
+          sourcesContent = [];
+          sourceMap.sourcesContent = sourcesContent;
         }
 
-        let firstSourceMapSourceFailure = null
+        let firstSourceMapSourceFailure = null;
 
         await Promise.all(
           sourceMap.sources.map(async (source, index) => {
-            if (index in sourcesContent) return
+            if (index in sourcesContent) return;
 
             const sourcemapSourceUrl = resolveFile(source, sourcemapUrl, {
               type: "source",
-            })
+            });
             try {
-              const sourceResponse = await fetchFile(sourcemapSourceUrl)
-              const { status } = sourceResponse
+              const sourceResponse = await fetchFile(sourcemapSourceUrl);
+              const { status } = sourceResponse;
               if (status !== 200) {
-                if (firstSourceMapSourceFailure) return
+                if (firstSourceMapSourceFailure) return;
 
                 if (status === 404) {
                   firstSourceMapSourceFailure = createDetailedMessage(
@@ -144,8 +144,8 @@ export const remapStack = async ({
                       ["sourcemap source url"]: sourcemapSourceUrl,
                       ["sourcemap url"]: sourcemapUrl,
                     },
-                  )
-                  return
+                  );
+                  return;
                 }
                 firstSourceMapSourceFailure = createDetailedMessage(
                   `unexpected response for sourcemap source.`,
@@ -155,14 +155,14 @@ export const remapStack = async ({
                     ["sourcemap source url"]: sourcemapSourceUrl,
                     ["sourcemap url"]: sourcemapUrl,
                   },
-                )
-                return
+                );
+                return;
               }
 
-              const sourceString = await sourceResponse.text()
-              sourcesContent[index] = sourceString
+              const sourceString = await sourceResponse.text();
+              sourcesContent[index] = sourceString;
             } catch (e) {
-              if (firstSourceMapSourceFailure) return
+              if (firstSourceMapSourceFailure) return;
               firstSourceMapSourceFailure = createDetailedMessage(
                 `error while fetching sourcemap source.`,
                 {
@@ -170,17 +170,17 @@ export const remapStack = async ({
                   ["sourcemap source url"]: sourcemapSourceUrl,
                   ["sourcemap url"]: sourcemapUrl,
                 },
-              )
+              );
             }
           }),
-        )
+        );
 
         if (firstSourceMapSourceFailure) {
-          onFailure(firstSourceMapSourceFailure)
-          return null
+          onFailure(firstSourceMapSourceFailure);
+          return null;
         }
 
-        return new SourceMapConsumer(sourceMap)
+        return new SourceMapConsumer(sourceMap);
       } catch (e) {
         onFailure(
           createDetailedMessage(
@@ -190,11 +190,11 @@ export const remapStack = async ({
               ["stack trace file"]: stackTraceFileUrl,
             },
           ),
-        )
-        return null
+        );
+        return null;
       }
     },
-  )
+  );
   const originalCallsites = await Promise.all(
     stack.map((callSite) =>
       remapCallSite(callSite, {
@@ -204,17 +204,17 @@ export const remapStack = async ({
         onFailure,
       }),
     ),
-  )
-  return originalCallsites
-}
+  );
+  return originalCallsites;
+};
 
 const memoizeByFirstArgStringValue = (fn) => {
-  const stringValueCache = {}
+  const stringValueCache = {};
   return (firstArgValue) => {
     if (firstArgValue in stringValueCache)
-      return stringValueCache[firstArgValue]
-    const value = fn(firstArgValue)
-    stringValueCache[firstArgValue] = value
-    return value
-  }
-}
+      return stringValueCache[firstArgValue];
+    const value = fn(firstArgValue);
+    stringValueCache[firstArgValue] = value;
+    return value;
+  };
+};

package/src/error_stack_remap/stringify_stack.js

@@ -1,9 +1,9 @@
 export const stringifyStack = (stack, { error, indent }) => {
-  const name = error.name || "Error"
-  const message = error.message || ""
+  const name = error.name || "Error";
+  const message = error.message || "";
   const stackString = stack
     .map((callSite) => `\n${indent}at ${callSite}`)
-    .join("")
+    .join("");
 
-  return `${name}: ${message}${stackString}`
-}
+  return `${name}: ${message}${stackString}`;
+};

package/src/magic_source.js

@@ -1,52 +1,52 @@
-import MagicString from "magic-string"
+import MagicString from "magic-string";
 
 export const createMagicSource = (content) => {
   if (content === undefined) {
-    throw new Error("content missing")
+    throw new Error("content missing");
   }
-  const mutations = []
+  const mutations = [];
   return {
     prepend: (string) => {
       mutations.push((magicString) => {
-        magicString.prepend(string)
-      })
+        magicString.prepend(string);
+      });
     },
     append: (string) => {
       mutations.push((magicString) => {
-        magicString.append(string)
-      })
+        magicString.append(string);
+      });
     },
     replace: ({ start, end, replacement }) => {
       mutations.push((magicString) => {
-        magicString.overwrite(start, end, replacement)
-      })
+        magicString.overwrite(start, end, replacement);
+      });
     },
     remove: ({ start, end }) => {
       mutations.push((magicString) => {
-        magicString.remove(start, end)
-      })
+        magicString.remove(start, end);
+      });
     },
     toContentAndSourcemap: ({ source } = {}) => {
       if (mutations.length === 0) {
         return {
           content,
           sourcemap: null,
-        }
+        };
       }
-      const magicString = new MagicString(content)
+      const magicString = new MagicString(content);
       mutations.forEach((mutation) => {
-        mutation(magicString)
-      })
-      const code = magicString.toString()
+        mutation(magicString);
+      });
+      const code = magicString.toString();
       const map = magicString.generateMap({
         hires: true,
         includeContent: true,
         source,
-      })
+      });
       return {
         content: code,
         sourcemap: map,
-      }
+      };
     },
-  }
-}
+  };
+};

package/src/main.js

@@ -1,10 +1,10 @@
-export { createMagicSource } from "./magic_source.js"
-export { composeTwoSourcemaps } from "./sourcemap_composition_v3.js"
+export { createMagicSource } from "./magic_source.js";
+export { composeTwoSourcemaps } from "./sourcemap_composition_v3.js";
 
-export { getOriginalPosition } from "./original_position.js"
-export { sourcemapConverter } from "./sourcemap_converter.js"
+export { getOriginalPosition } from "./original_position.js";
+export { sourcemapConverter } from "./sourcemap_converter.js";
 export {
   generateSourcemapFileUrl,
   generateSourcemapDataUrl,
-} from "./sourcemap_url_generator.js"
-export { SOURCEMAP } from "./sourcemap_comment.js"
+} from "./sourcemap_url_generator.js";
+export { SOURCEMAP } from "./sourcemap_comment.js";

package/src/original_position.js

@@ -1,14 +1,14 @@
-import { requireSourcemap } from "./require_sourcemap.js"
+import { requireSourcemap } from "./require_sourcemap.js";
 
 // https://github.com/mozilla/source-map#sourcemapconsumerprototypeoriginalpositionforgeneratedposition
 export const getOriginalPosition = ({ sourcemap, line, column, bias }) => {
-  const { SourceMapConsumer } = requireSourcemap()
+  const { SourceMapConsumer } = requireSourcemap();
 
-  const sourceMapConsumer = new SourceMapConsumer(sourcemap)
+  const sourceMapConsumer = new SourceMapConsumer(sourcemap);
   const originalPosition = sourceMapConsumer.originalPositionFor({
     line,
     column,
     bias,
-  })
-  return originalPosition
-}
+  });
+  return originalPosition;
+};

package/src/require_sourcemap.js

@@ -1,9 +1,9 @@
-import { createRequire } from "node:module"
+import { createRequire } from "node:module";
 
-const require = createRequire(import.meta.url)
+const require = createRequire(import.meta.url);
 // consider using https://github.com/7rulnik/source-map-js
 
 export const requireSourcemap = () => {
-  const namespace = require("source-map-js")
-  return namespace
-}
+  const namespace = require("source-map-js");
+  return namespace;
+};

package/src/sourcemap_comment.js

@@ -1,36 +1,40 @@
 export const SOURCEMAP = {
   enabledOnContentType: (contentType) => {
-    return ["text/javascript", "text/css"].includes(contentType)
+    return ["text/javascript", "text/css"].includes(contentType);
   },
 
   readComment: ({ contentType, content }) => {
     const read = {
       "text/javascript": parseJavaScriptSourcemapComment,
       "text/css": parseCssSourcemapComment,
-    }[contentType]
-    return read ? read(content) : null
+    }[contentType];
+    return read ? read(content) : null;
+  },
+
+  removeComment: ({ contentType, content }) => {
+    return SOURCEMAP.writeComment({ contentType, content, specifier: "" });
   },
 
   writeComment: ({ contentType, content, specifier }) => {
     const write = {
       "text/javascript": setJavaScriptSourceMappingUrl,
       "text/css": setCssSourceMappingUrl,
-    }[contentType]
-    return write ? write(content, specifier) : content
+    }[contentType];
+    return write ? write(content, specifier) : content;
   },
-}
+};
 
 const parseJavaScriptSourcemapComment = (javaScriptSource) => {
-  let sourceMappingUrl
+  let sourceMappingUrl;
   replaceSourceMappingUrl(
     javaScriptSource,
     javascriptSourceMappingUrlCommentRegexp,
     (value) => {
-      sourceMappingUrl = value
+      sourceMappingUrl = value;
     },
-  )
+  );
   if (!sourceMappingUrl) {
-    return null
+    return null;
   }
   return {
     type: "sourcemap_comment",
@@ -40,46 +44,46 @@ const parseJavaScriptSourcemapComment = (javaScriptSource) => {
     // ${"//#"} is to avoid static analysis to think there is a sourceMappingUrl for this file
     column: `${"//#"} sourceMappingURL=`.length + 1,
     specifier: sourceMappingUrl,
-  }
-}
+  };
+};
 
 const setJavaScriptSourceMappingUrl = (
   javaScriptSource,
   sourceMappingFileUrl,
 ) => {
-  let replaced
+  let replaced;
   const sourceAfterReplace = replaceSourceMappingUrl(
     javaScriptSource,
     javascriptSourceMappingUrlCommentRegexp,
     () => {
-      replaced = true
+      replaced = true;
       return sourceMappingFileUrl
         ? writeJavaScriptSourceMappingURL(sourceMappingFileUrl)
-        : ""
+        : "";
     },
-  )
+  );
   if (replaced) {
-    return sourceAfterReplace
+    return sourceAfterReplace;
   }
 
   return sourceMappingFileUrl
     ? `${javaScriptSource}
 ${writeJavaScriptSourceMappingURL(sourceMappingFileUrl)}
 `
-    : javaScriptSource
-}
+    : javaScriptSource;
+};
 
 const parseCssSourcemapComment = (cssSource) => {
-  let sourceMappingUrl
+  let sourceMappingUrl;
   replaceSourceMappingUrl(
     cssSource,
     cssSourceMappingUrlCommentRegExp,
     (value) => {
-      sourceMappingUrl = value
+      sourceMappingUrl = value;
     },
-  )
+  );
   if (!sourceMappingUrl) {
-    return null
+    return null;
   }
   return {
     type: "sourcemap_comment",
@@ -89,55 +93,58 @@ const parseCssSourcemapComment = (cssSource) => {
     // ${"//*#"} is to avoid static analysis to think there is a sourceMappingUrl for this file
     column: `${"//*#"} sourceMappingURL=`.length + 1,
     specifier: sourceMappingUrl,
-  }
-}
+  };
+};
 
 const setCssSourceMappingUrl = (cssSource, sourceMappingFileUrl) => {
-  let replaced
+  let replaced;
   const sourceAfterReplace = replaceSourceMappingUrl(
     cssSource,
     cssSourceMappingUrlCommentRegExp,
     () => {
-      replaced = true
+      replaced = true;
       return sourceMappingFileUrl
         ? writeCssSourceMappingUrl(sourceMappingFileUrl)
-        : ""
+        : "";
     },
-  )
+  );
   if (replaced) {
-    return sourceAfterReplace
+    return sourceAfterReplace;
   }
   return sourceMappingFileUrl
     ? `${cssSource}
 ${writeCssSourceMappingUrl(sourceMappingFileUrl)}
 `
-    : cssSource
-}
+    : cssSource;
+};
 
 const javascriptSourceMappingUrlCommentRegexp =
-  /\/\/ ?# ?sourceMappingURL=([^\s'"]+)/g
+  /\/\/ ?# ?sourceMappingURL=([^\s'"]+)/g;
 const cssSourceMappingUrlCommentRegExp =
-  /\/\*# ?sourceMappingURL=([^\s'"]+) \*\//g
+  /\/\*# ?sourceMappingURL=([^\s'"]+) \*\//g;
 
 // ${"//#"} is to avoid a parser thinking there is a sourceMappingUrl for this file
-const writeJavaScriptSourceMappingURL = (value) =>
-  `${"//#"} sourceMappingURL=${value}`
-const writeCssSourceMappingUrl = (value) => `/*# sourceMappingURL=${value} */`
+const writeJavaScriptSourceMappingURL = (value) => {
+  return `${"//#"} sourceMappingURL=${value}`;
+};
+const writeCssSourceMappingUrl = (value) => {
+  return `/*# sourceMappingURL=${value} */`;
+};
 
 const replaceSourceMappingUrl = (source, regexp, callback) => {
-  let lastSourceMappingUrl
-  let matchSourceMappingUrl
+  let lastSourceMappingUrl;
+  let matchSourceMappingUrl;
   while ((matchSourceMappingUrl = regexp.exec(source))) {
-    lastSourceMappingUrl = matchSourceMappingUrl
+    lastSourceMappingUrl = matchSourceMappingUrl;
   }
   if (lastSourceMappingUrl) {
-    const index = lastSourceMappingUrl.index
-    const before = source.slice(0, index)
-    const after = source.slice(index)
+    const index = lastSourceMappingUrl.index;
+    const before = source.slice(0, index);
+    const after = source.slice(index);
     const mappedAfter = after.replace(regexp, (match, firstGroup) => {
-      return callback(firstGroup)
-    })
-    return `${before}${mappedAfter}`
+      return callback(firstGroup);
+    });
+    return `${before}${mappedAfter}`;
   }
-  return source
-}
+  return source;
+};