@jsenv/sourcemap 1.0.0

package/package.json

@@ -0,0 +1,26 @@
+{
+  "name": "@jsenv/sourcemap",
+  "version": "1.0.0",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/jsenv/jsenv-core",
+    "directory": "packages/utils"
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org"
+  },
+  "type": "module",
+  "exports": {
+    ".": "./src/main.js"
+  },
+  "scripts": {
+    "test": "node --conditions=development ./scripts/test.mjs"
+  },
+  "dependencies": {
+    "@jsenv/urls": "1.2.5",
+    "magic-string": "0.26.2",
+    "source-map": "0.7.4"
+  }
+}

package/scripts/test.mjs

@@ -0,0 +1,15 @@
+import { executeTestPlan, nodeProcess } from "@jsenv/core"
+
+await executeTestPlan({
+  rootDirectoryUrl: new URL("../", import.meta.url),
+  testPlan: {
+    "**/*.test.mjs": {
+      node: {
+        runtime: nodeProcess,
+      },
+    },
+  },
+  failFast: process.argv.includes("--workspace"),
+  completedExecutionLogMerging: process.argv.includes("--workspace"),
+  coverage: process.argv.includes("--coverage"),
+})

package/src/bundle_sourcemap.js

@@ -0,0 +1,3 @@
+// ideally we should be able to generate bundled file sourcemap
+// as done in https://github.com/rollup/rollup/blob/05d294fdfca5d01e4e6b3f70e442136504a243b0/src/utils/collapseSourcemaps.ts#L203
+// (would be used for CSS)

package/src/error_stack_remap/detailed_message.js

@@ -0,0 +1,18 @@
+// duplicated from @jsenv/log to avoid the dependency
+export const createDetailedMessage = (message, details = {}) => {
+  let string = `${message}`
+
+  Object.keys(details).forEach((key) => {
+    const value = details[key]
+    string += `
+  --- ${key} ---
+  ${
+    Array.isArray(value)
+      ? value.join(`
+  `)
+      : value
+  }`
+  })
+
+  return string
+}

package/src/error_stack_remap/install_error_stack_remapping.js

@@ -0,0 +1,141 @@
+import { createDetailedMessage } from "./detailed_message.js"
+import { remapStack } from "./remap_stack.js"
+import { stringifyStack } from "./stringify_stack.js"
+
+export const installErrorStackRemapping = ({
+  fetchFile,
+  resolveFile,
+  SourceMapConsumer,
+  indent = "  ",
+}) => {
+  if (typeof fetchFile !== "function") {
+    throw new TypeError(`fetchFile must be a function, got ${fetchFile}`)
+  }
+  if (typeof SourceMapConsumer !== "function") {
+    throw new TypeError(
+      `sourceMapConsumer must be a function, got ${SourceMapConsumer}`,
+    )
+  }
+  if (typeof indent !== "string") {
+    throw new TypeError(`indent must be a string, got ${indent}`)
+  }
+
+  const errorRemappingCache = new WeakMap()
+  const errorRemapFailureCallbackMap = new WeakMap()
+
+  let installed = false
+  const previousPrepareStackTrace = Error.prepareStackTrace
+  const install = () => {
+    if (installed) return
+    installed = true
+    Error.prepareStackTrace = prepareStackTrace
+  }
+
+  const uninstall = () => {
+    if (!installed) return
+    installed = false
+    Error.prepareStackTrace = previousPrepareStackTrace
+  }
+
+  // ensure we do not use prepareStackTrace for thoose error
+  // otherwise we would recursively remap error stack
+  // and if the reason causing the failure is still here
+  // it would create an infinite loop
+  const readErrorStack = (error) => {
+    uninstall()
+    const stack = error.stack
+    install()
+    return stack
+  }
+
+  const prepareStackTrace = (error, stack) => {
+    const onFailure = (failureData) => {
+      const failureCallbackArray = errorRemapFailureCallbackMap.get(error)
+      if (failureCallbackArray) {
+        failureCallbackArray.forEach((callback) => callback(failureData))
+      }
+    }
+
+    const stackRemappingPromise = remapStack({
+      stack,
+      error,
+      resolveFile,
+      fetchFile: memoizeFetch(fetchFile),
+      SourceMapConsumer,
+      readErrorStack,
+      indent,
+      onFailure,
+    })
+    errorRemappingCache.set(error, stackRemappingPromise)
+
+    return stringifyStack(stack, { error, indent })
+  }
+
+  const getErrorOriginalStackString = async (
+    error,
+    {
+      onFailure = (message) => {
+        console.warn(message)
+      },
+    } = {},
+  ) => {
+    if (onFailure) {
+      const remapFailureCallbackArray = errorRemapFailureCallbackMap.get(error)
+      if (remapFailureCallbackArray) {
+        errorRemapFailureCallbackMap.set(error, [
+          ...remapFailureCallbackArray,
+          onFailure,
+        ])
+      } else {
+        errorRemapFailureCallbackMap.set(error, [onFailure])
+      }
+    }
+
+    // ensure Error.prepareStackTrace gets triggered by reading error.stack now
+    const { stack } = error
+    const promise = errorRemappingCache.get(error)
+
+    if (promise) {
+      try {
+        const originalCallsites = await promise
+        errorRemapFailureCallbackMap.get(error)
+
+        const firstCall = originalCallsites[0]
+        if (firstCall) {
+          Object.assign(error, {
+            filename: firstCall.getFileName(),
+            lineno: firstCall.getLineNumber(),
+            columnno: firstCall.getColumnNumber(),
+          })
+        }
+        return stringifyStack(originalCallsites, { error, indent })
+      } catch (e) {
+        onFailure(
+          createDetailedMessage(`error while computing original stack.`, {
+            ["stack from error while computing"]: readErrorStack(e),
+            ["stack from error to remap"]: stack,
+          }),
+        )
+        return stack
+      }
+    }
+
+    return stack
+  }
+
+  install()
+
+  return { getErrorOriginalStackString, uninstall }
+}
+
+const memoizeFetch = (fetchUrl) => {
+  const urlCache = {}
+  return async (url) => {
+    if (url in urlCache) {
+      return urlCache[url]
+    }
+    const responsePromise = fetchUrl(url)
+    urlCache[url] = responsePromise
+    return responsePromise
+  }
+}

package/src/error_stack_remap/remap_call_site.js

@@ -0,0 +1,312 @@
+import { startsWithWindowsDriveLetter, windowsFilePathToUrl } from "@jsenv/urls"
+
+import { createDetailedMessage } from "./detailed_message.js"
+
+export const remapCallSite = async (
+  callSite,
+  { urlToSourcemapConsumer, resolveFile, readErrorStack, onFailure },
+) => {
+  if (callSite.isNative()) {
+    return callSite
+  }
+
+  // Most call sites will return the source file from getFileName(), but code
+  // passed to eval() ending in "//# sourceURL=..." will return the source file
+  // from getScriptNameOrSourceURL() instead
+  const source = callSite.getFileName() || callSite.getScriptNameOrSourceURL()
+  if (source) {
+    const line = callSite.getLineNumber()
+    const column = callSite.getColumnNumber() - 1
+    const originalPosition = await remapSourcePosition({
+      source,
+      line,
+      column,
+      resolveFile,
+      urlToSourcemapConsumer,
+      readErrorStack,
+      onFailure,
+    })
+
+    const callSiteClone = cloneCallSite(callSite)
+
+    callSiteClone.getFunctionName = () =>
+      originalPosition.name || callSite.getFunctionName()
+    callSiteClone.getFileName = () => originalPosition.source
+    callSiteClone.getLineNumber = () => originalPosition.line
+    callSiteClone.getColumnNumber = () => originalPosition.column + 1
+    callSiteClone.getScriptNameOrSourceURL = () => originalPosition.source
+
+    return callSiteClone
+  }
+
+  // Code called using eval() needs special handling
+  if (callSite.isEval()) {
+    const origin = callSite.getEvalOrigin()
+    if (origin) {
+      const callSiteClone = cloneCallSite(callSite)
+      const originalEvalOrigin = await remapEvalOrigin(origin, {
+        resolveFile,
+        urlToSourcemapConsumer,
+        readErrorStack,
+        onFailure,
+      })
+      callSiteClone.getEvalOrigin = () => originalEvalOrigin
+      return callSiteClone
+    }
+    return callSite
+  }
+
+  // If we get here then we were unable to change the source position
+  return callSite
+}
+
+const cloneCallSite = (callSite) => {
+  const callSiteClone = {}
+  methods.forEach((name) => {
+    callSiteClone[name] = () => callSite[name]()
+  })
+  callSiteClone.toString = () => callSiteToFunctionCall(callSiteClone)
+
+  return callSiteClone
+}
+
+const methods = [
+  "getColumnNumber",
+  "getEvalOrigin",
+  "getFileName",
+  "getFunction",
+  "getFunctionName",
+  "getLineNumber",
+  "getMethodName",
+  "getPosition",
+  "getScriptNameOrSourceURL",
+  "getThis",
+  "getTypeName",
+  "isConstructor",
+  "isEval",
+  "isNative",
+  "isToplevel",
+  "toString",
+]
+
+const callSiteToFunctionCall = (callSite) => {
+  const fileLocation = callSiteToFileLocation(callSite)
+  const isConstructor = callSite.isConstructor()
+  const isMethodCall = !callSite.isToplevel() && !isConstructor
+
+  if (isMethodCall) {
+    return `${callSiteToMethodCall(callSite)} (${fileLocation})`
+  }
+
+  const functionName = callSite.getFunctionName()
+  if (isConstructor) {
+    return `new ${functionName || "<anonymous>"} (${fileLocation})`
+  }
+
+  if (functionName) {
+    return `${functionName} (${fileLocation})`
+  }
+
+  return `${fileLocation}`
+}
+
+const callSiteToMethodCall = (callSite) => {
+  const functionName = callSite.getFunctionName()
+  const typeName = callSiteToType(callSite)
+
+  if (!functionName) {
+    return `${typeName}.<anonymous>`
+  }
+
+  const methodName = callSite.getMethodName()
+  const as = generateAs({ methodName, functionName })
+
+  if (typeName && !functionName.startsWith(typeName)) {
+    return `${typeName}.${functionName}${as}`
+  }
+
+  return `${functionName}${as}`
+}
+
+const generateAs = ({ methodName, functionName }) => {
+  if (!methodName) return ""
+  if (
+    functionName.indexOf(`.${methodName}`) ===
+    functionName.length - methodName.length - 1
+  )
+    return ""
+  return ` [as ${methodName}]`
+}
+
+const callSiteToType = (callSite) => {
+  const typeName = callSite.getTypeName()
+  // Fixes shim to be backward compatible with Node v0 to v4
+  if (typeName === "[object Object]") {
+    return "null"
+  }
+  return typeName
+}
+
+const callSiteToFileLocation = (callSite) => {
+  if (callSite.isNative()) return "native"
+
+  const sourceFile = callSiteToSourceFile(callSite)
+  const lineNumber = callSite.getLineNumber()
+  if (lineNumber === null) {
+    return sourceFile
+  }
+
+  const columnNumber = callSite.getColumnNumber()
+  if (!columnNumber) {
+    return `${sourceFile}:${lineNumber}`
+  }
+
+  return `${sourceFile}:${lineNumber}:${columnNumber}`
+}
+
+const callSiteToSourceFile = (callSite) => {
+  const fileName = callSite.getScriptNameOrSourceURL()
+
+  if (fileName) {
+    return fileName
+  }
+
+  // Source code does not originate from a file and is not native, but we
+  // can still get the source position inside the source string, e.g. in
+  // an eval string.
+  if (callSite.isEval()) {
+    return `${callSite.getEvalOrigin()}, <anonymous>`
+  }
+
+  return "<anonymous>"
+}
+
+// Parses code generated by FormatEvalOrigin(), a function inside V8:
+// https://code.google.com/p/v8/source/browse/trunk/src/messages.js
+const remapEvalOrigin = async (
+  origin,
+  { resolveFile, urlToSourcemapConsumer, onFailure },
+) => {
+  // Most eval() calls are in this format
+  const topLevelEvalMatch = /^eval at ([^(]+) \((.+):(\d+):(\d+)\)$/.exec(
+    origin,
+  )
+  if (topLevelEvalMatch) {
+    const source = topLevelEvalMatch[2]
+    const line = Number(topLevelEvalMatch[3])
+    const column = topLevelEvalMatch[4] - 1
+    const originalPosition = await remapSourcePosition({
+      source,
+      line,
+      column,
+      resolveFile,
+      urlToSourcemapConsumer,
+      onFailure,
+    })
+    return `eval at ${topLevelEvalMatch[1]} (${originalPosition.source}:${
+      originalPosition.line
+    }:${originalPosition.column + 1})`
+  }
+
+  // Parse nested eval() calls using recursion
+  const nestedEvalMatch = /^eval at ([^(]+) \((.+)\)$/.exec(origin)
+  if (nestedEvalMatch) {
+    const originalEvalOrigin = await remapEvalOrigin(nestedEvalMatch[2], {
+      resolveFile,
+      urlToSourcemapConsumer,
+      onFailure,
+    })
+    return `eval at ${nestedEvalMatch[1]} (${originalEvalOrigin})`
+  }
+
+  // Make sure we still return useful information if we didn't find anything
+  return origin
+}
+
+const remapSourcePosition = async ({
+  source,
+  line,
+  column,
+  resolveFile,
+  urlToSourcemapConsumer,
+  readErrorStack,
+  onFailure,
+}) => {
+  const position = { source, line, column }
+
+  const url = sourceToUrl(source, { resolveFile })
+  if (!url) return position
+
+  const sourceMapConsumer = await urlToSourcemapConsumer(url)
+
+  if (!sourceMapConsumer) return position
+
+  try {
+    const originalPosition = sourceMapConsumer.originalPositionFor(position)
+
+    // Only return the original position if a matching line was found. If no
+    // matching line is found then we return position instead, which will cause
+    // the stack trace to print the path and line for the compiled file. It is
+    // better to give a precise location in the compiled file than a vague
+    // location in the original file.
+    const originalSource = originalPosition.source
+
+    if (originalSource === null) return position
+    originalPosition.source = resolveFile(originalSource, url, {
+      type: "file-original",
+    })
+
+    return originalPosition
+  } catch (e) {
+    onFailure(
+      createDetailedMessage(`error while remapping position.`, {
+        ["error stack"]: readErrorStack(e),
+        ["source"]: source,
+        ["line"]: line,
+        ["column"]: column,
+      }),
+    )
+    return position
+  }
+}
+
+const sourceToUrl = (source, { resolveFile }) => {
+  if (startsWithScheme(source)) {
+    return source
+  }
+
+  // linux filesystem path
+  if (source[0] === "/") {
+    return resolveFile(source)
+  }
+
+  // be careful, due to babel or something like that we might receive paths like
+  // C:/directory/file.js (without backslashes we would expect on windows)
+  // In that case we consider C: is the signe we are on windows
+  // And I avoid to rely on process.platform === "win32" because this file might be executed in chrome
+  if (startsWithWindowsDriveLetter(source)) {
+    return windowsFilePathToUrl(source)
+  }
+
+  // I don't think we will ever encounter relative file in the stack trace
+  // but if it ever happens we are safe :)
+  if (source.slice(0, 2) === "./" || source.slice(0, 3) === "../") {
+    return resolveFile(source)
+  }
+
+  // we have received a "bare specifier" for the source
+  // it happens for internal/process/task_queues.js for instance
+  // if we do return resolveFile(source) it will be converted to
+  // file:///C:/project-directory/internal/process/task_queues.js in node
+  // and
+  // http://domain.com/internal/process/task_queues.js
+  // but the file will certainly be a 404
+  // and if not it won't be the right file anyway
+  // for now we assume "bare specifier" in the stack trace
+  // are internal files that are pointless to try to remap
+  return null
+}
+
+const startsWithScheme = (string) => {
+  return /^[a-zA-Z]{2,}:/.test(string)
+}

package/src/error_stack_remap/remap_stack.js

@@ -0,0 +1,220 @@
+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"
+
+export const remapStack = async ({
+  stack,
+  resolveFile,
+  fetchFile,
+  SourceMapConsumer,
+  readErrorStack,
+  onFailure,
+}) => {
+  const urlToSourcemapConsumer = memoizeByFirstArgStringValue(
+    async (stackTraceFileUrl) => {
+      if (stackTraceFileUrl.startsWith("node:")) {
+        return null
+      }
+
+      try {
+        let text
+        try {
+          const fileResponse = await fetchFile(stackTraceFileUrl)
+          const { status } = fileResponse
+          if (status !== 200) {
+            if (status === 404) {
+              onFailure(`stack trace file not found at ${stackTraceFileUrl}`)
+            } else {
+              onFailure(
+                createDetailedMessage(
+                  `unexpected response fetching stack trace file.`,
+                  {
+                    ["response status"]: status,
+                    ["response text"]: fileResponse.body,
+                    ["stack trace file"]: stackTraceFileUrl,
+                  },
+                ),
+              )
+            }
+            return null
+          }
+          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
+        }
+
+        const jsSourcemapComment = SOURCEMAP.readComment({
+          contentType: "text/javascript",
+          content: text,
+        })
+        if (!jsSourcemapComment) {
+          return null
+        }
+        const jsSourcemapUrl = jsSourcemapComment.specifier
+        let sourcemapUrl
+        let sourcemapString
+        if (jsSourcemapUrl.startsWith("data:")) {
+          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
+            if (status !== 200) {
+              if (status === 404) {
+                onFailure(`sourcemap file not found at ${sourcemapUrl}`)
+              } else {
+                onFailure(
+                  createDetailedMessage(
+                    `unexpected response for sourcemap file.`,
+                    {
+                      ["response status"]: status,
+                      ["response text"]: await sourcemapResponse.text(),
+                      ["sourcemap url"]: sourcemapUrl,
+                    },
+                  ),
+                )
+              }
+              return null
+            }
+            sourcemapString = await sourcemapResponse.text()
+          } catch (e) {
+            onFailure(
+              createDetailedMessage(`error while fetching sourcemap.`, {
+                ["fetch error stack"]: readErrorStack(e),
+                ["sourcemap url"]: sourcemapUrl,
+              }),
+            )
+            return null
+          }
+        }
+
+        let sourceMap
+        try {
+          sourceMap = JSON.parse(sourcemapString)
+        } catch (e) {
+          onFailure(
+            createDetailedMessage(`error while parsing sourcemap.`, {
+              ["parse error stack"]: readErrorStack(e),
+              ["sourcemap url"]: sourcemapUrl,
+            }),
+          )
+          return null
+        }
+
+        let { sourcesContent } = sourceMap
+
+        if (!sourcesContent) {
+          sourcesContent = []
+          sourceMap.sourcesContent = sourcesContent
+        }
+
+        let firstSourceMapSourceFailure = null
+
+        await Promise.all(
+          sourceMap.sources.map(async (source, index) => {
+            if (index in sourcesContent) return
+
+            const sourcemapSourceUrl = resolveFile(source, sourcemapUrl, {
+              type: "source",
+            })
+            try {
+              const sourceResponse = await fetchFile(sourcemapSourceUrl)
+              const { status } = sourceResponse
+              if (status !== 200) {
+                if (firstSourceMapSourceFailure) return
+
+                if (status === 404) {
+                  firstSourceMapSourceFailure = createDetailedMessage(
+                    `sourcemap source not found.`,
+                    {
+                      ["sourcemap source url"]: sourcemapSourceUrl,
+                      ["sourcemap url"]: sourcemapUrl,
+                    },
+                  )
+                  return
+                }
+                firstSourceMapSourceFailure = createDetailedMessage(
+                  `unexpected response for sourcemap source.`,
+                  {
+                    ["response status"]: status,
+                    ["response text"]: await sourceResponse.text(),
+                    ["sourcemap source url"]: sourcemapSourceUrl,
+                    ["sourcemap url"]: sourcemapUrl,
+                  },
+                )
+                return
+              }
+
+              const sourceString = await sourceResponse.text()
+              sourcesContent[index] = sourceString
+            } catch (e) {
+              if (firstSourceMapSourceFailure) return
+              firstSourceMapSourceFailure = createDetailedMessage(
+                `error while fetching sourcemap source.`,
+                {
+                  ["fetch error stack"]: readErrorStack(e),
+                  ["sourcemap source url"]: sourcemapSourceUrl,
+                  ["sourcemap url"]: sourcemapUrl,
+                },
+              )
+            }
+          }),
+        )
+
+        if (firstSourceMapSourceFailure) {
+          onFailure(firstSourceMapSourceFailure)
+          return null
+        }
+
+        return new SourceMapConsumer(sourceMap)
+      } catch (e) {
+        onFailure(
+          createDetailedMessage(
+            `error while preparing a sourceMap consumer for a stack trace file.`,
+            {
+              ["error stack"]: readErrorStack(e),
+              ["stack trace file"]: stackTraceFileUrl,
+            },
+          ),
+        )
+        return null
+      }
+    },
+  )
+  const originalCallsites = await Promise.all(
+    stack.map((callSite) =>
+      remapCallSite(callSite, {
+        resolveFile,
+        urlToSourcemapConsumer,
+        readErrorStack,
+        onFailure,
+      }),
+    ),
+  )
+  return originalCallsites
+}
+
+const memoizeByFirstArgStringValue = (fn) => {
+  const stringValueCache = {}
+  return (firstArgValue) => {
+    if (firstArgValue in stringValueCache)
+      return stringValueCache[firstArgValue]
+    const value = fn(firstArgValue)
+    stringValueCache[firstArgValue] = value
+    return value
+  }
+}

package/src/error_stack_remap/stringify_stack.js

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

package/src/magic_source.js

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

package/src/main.js

@@ -0,0 +1,10 @@
+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 {
+  generateSourcemapFileUrl,
+  generateSourcemapDataUrl,
+} from "./sourcemap_url_generator.js"
+export { SOURCEMAP } from "./sourcemap_comment.js"

package/src/original_position.js

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

package/src/require_sourcemap.js

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

package/src/sourcemap_comment.js

@@ -0,0 +1,143 @@
+export const SOURCEMAP = {
+  enabledOnContentType: (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
+  },
+
+  writeComment: ({ contentType, content, specifier }) => {
+    const write = {
+      "text/javascript": setJavaScriptSourceMappingUrl,
+      "text/css": setCssSourceMappingUrl,
+    }[contentType]
+    return write ? write(content, specifier) : content
+  },
+}
+
+const parseJavaScriptSourcemapComment = (javaScriptSource) => {
+  let sourceMappingUrl
+  replaceSourceMappingUrl(
+    javaScriptSource,
+    javascriptSourceMappingUrlCommentRegexp,
+    (value) => {
+      sourceMappingUrl = value
+    },
+  )
+  if (!sourceMappingUrl) {
+    return null
+  }
+  return {
+    type: "sourcemap_comment",
+    subtype: "js",
+    // we assume it's on last line
+    line: javaScriptSource.split(/\r?\n/).length,
+    // ${"//#"} 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
+  const sourceAfterReplace = replaceSourceMappingUrl(
+    javaScriptSource,
+    javascriptSourceMappingUrlCommentRegexp,
+    () => {
+      replaced = true
+      return sourceMappingFileUrl
+        ? writeJavaScriptSourceMappingURL(sourceMappingFileUrl)
+        : ""
+    },
+  )
+  if (replaced) {
+    return sourceAfterReplace
+  }
+
+  return sourceMappingFileUrl
+    ? `${javaScriptSource}
+${writeJavaScriptSourceMappingURL(sourceMappingFileUrl)}
+`
+    : javaScriptSource
+}
+
+const parseCssSourcemapComment = (cssSource) => {
+  let sourceMappingUrl
+  replaceSourceMappingUrl(
+    cssSource,
+    cssSourceMappingUrlCommentRegExp,
+    (value) => {
+      sourceMappingUrl = value
+    },
+  )
+  if (!sourceMappingUrl) {
+    return null
+  }
+  return {
+    type: "sourcemap_comment",
+    subtype: "css",
+    // we assume it's on last line
+    line: cssSource.split(/\r?\n/).length - 1,
+    // ${"//*#"} 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
+  const sourceAfterReplace = replaceSourceMappingUrl(
+    cssSource,
+    cssSourceMappingUrlCommentRegExp,
+    () => {
+      replaced = true
+      return sourceMappingFileUrl
+        ? writeCssSourceMappingUrl(sourceMappingFileUrl)
+        : ""
+    },
+  )
+  if (replaced) {
+    return sourceAfterReplace
+  }
+  return sourceMappingFileUrl
+    ? `${cssSource}
+${writeCssSourceMappingUrl(sourceMappingFileUrl)}
+`
+    : cssSource
+}
+
+const javascriptSourceMappingUrlCommentRegexp =
+  /\/\/ ?# ?sourceMappingURL=([^\s'"]+)/g
+const cssSourceMappingUrlCommentRegExp =
+  /\/\*# ?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 replaceSourceMappingUrl = (source, regexp, callback) => {
+  let lastSourceMappingUrl
+  let matchSourceMappingUrl
+  while ((matchSourceMappingUrl = regexp.exec(source))) {
+    lastSourceMappingUrl = matchSourceMappingUrl
+  }
+  if (lastSourceMappingUrl) {
+    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 source
+}

package/src/sourcemap_composition_v3.js

@@ -0,0 +1,87 @@
+/*
+ * https://github.com/mozilla/source-map#sourcemapgenerator
+ */
+
+import { requireSourcemap } from "./require_sourcemap.js"
+
+const { SourceMapConsumer, SourceMapGenerator } = requireSourcemap()
+
+export const composeTwoSourcemaps = async (firstSourcemap, secondSourcemap) => {
+  if (!firstSourcemap && !secondSourcemap) {
+    return null
+  }
+  if (!firstSourcemap) {
+    return secondSourcemap
+  }
+  if (!secondSourcemap) {
+    return firstSourcemap
+  }
+  const sourcemapGenerator = new SourceMapGenerator()
+  const firstSourcemapConsumer = await new SourceMapConsumer(firstSourcemap)
+  const secondSourcemapConsumer = await new SourceMapConsumer(secondSourcemap)
+  const firstMappings = readMappings(firstSourcemapConsumer)
+  firstMappings.forEach((mapping) => {
+    sourcemapGenerator.addMapping(mapping)
+  })
+  const secondMappings = readMappings(secondSourcemapConsumer)
+  secondMappings.forEach((mapping) => {
+    sourcemapGenerator.addMapping(mapping)
+  })
+  const sourcemap = sourcemapGenerator.toJSON()
+  const sources = []
+  const sourcesContent = []
+  const firstSourcesContent = firstSourcemap.sourcesContent
+  const secondSourcesContent = secondSourcemap.sourcesContent
+  sourcemap.sources.forEach((source) => {
+    sources.push(source)
+    if (secondSourcesContent) {
+      const secondSourceIndex = secondSourcemap.sources.indexOf(source)
+      if (secondSourceIndex > -1) {
+        sourcesContent.push(secondSourcesContent[secondSourceIndex])
+        return
+      }
+    }
+    if (firstSourcesContent) {
+      const firstSourceIndex = firstSourcemap.sources.indexOf(source)
+      if (firstSourceIndex > -1) {
+        sourcesContent.push(firstSourcesContent[firstSourceIndex])
+        return
+      }
+    }
+    sourcesContent.push(null)
+  })
+  sourcemap.sources = sources
+  sourcemap.sourcesContent = sourcesContent
+  return sourcemap
+}
+
+const readMappings = (consumer) => {
+  const mappings = []
+  consumer.eachMapping(
+    ({
+      originalColumn,
+      originalLine,
+      generatedColumn,
+      generatedLine,
+      source,
+      name,
+    }) => {
+      mappings.push({
+        original:
+          typeof originalColumn === "number"
+            ? {
+                column: originalColumn,
+                line: originalLine,
+              }
+            : undefined,
+        generated: {
+          column: generatedColumn,
+          line: generatedLine,
+        },
+        source: typeof originalColumn === "number" ? source : undefined,
+        name,
+      })
+    },
+  )
+  return mappings
+}

package/src/sourcemap_converter.js

@@ -0,0 +1,24 @@
+import {
+  isFileSystemPath,
+  fileSystemPathToUrl,
+  urlToFileSystemPath,
+} from "@jsenv/urls"
+
+export const sourcemapConverter = {
+  toFileUrls: (sourcemap) => {
+    return {
+      ...sourcemap,
+      sources: sourcemap.sources.map((source) => {
+        return isFileSystemPath(source) ? fileSystemPathToUrl(source) : source
+      }),
+    }
+  },
+  toFilePaths: (sourcemap) => {
+    return {
+      ...sourcemap,
+      sources: sourcemap.sources.map((source) => {
+        return urlToFileSystemPath(source)
+      }),
+    }
+  },
+}

package/src/sourcemap_url_generator.js

@@ -0,0 +1,15 @@
+export const generateSourcemapFileUrl = (url) => {
+  const urlObject = new URL(url)
+  let { origin, pathname, search, hash } = urlObject
+  // origin is "null" for "file://" urls with Node.js
+  if (origin === "null" && urlObject.href.startsWith("file:")) {
+    origin = "file://"
+  }
+  const sourcemapUrl = `${origin}${pathname}.map${search}${hash}`
+  return sourcemapUrl
+}
+
+export const generateSourcemapDataUrl = (sourcemap) => {
+  const asBase64 = Buffer.from(JSON.stringify(sourcemap)).toString("base64")
+  return `data:application/json;charset=utf-8;base64,${asBase64}`
+}

package/test/magic_source.test.js

@@ -0,0 +1,13 @@
+import { createMagicSource } from "@jsenv/sourcemap"
+
+const content = `import { inferContextFrom, createUrlContext } from "../url_context.js";
+// toto
+`
+const magic = createMagicSource(content)
+magic.replace({
+  start: 51,
+  end: 70,
+  replacement: `"/@fs/Users/d.maillard/dev/jsenv/jsenv-core/src/internal/url_context.js"`,
+})
+const ret = magic.toContentAndSourcemap()
+console.log(ret)