@revealui/core 0.0.1-pre.0

package/dist/core/processing/getters/getRevealConfig/loadFileAtConfigTime.ts

@@ -0,0 +1,181 @@
+// Files loadded at config time:
+
+export { loadConfigFile, loadImportedFile, loadValueFile }
+export type { ConfigFile, ImportedFilesLoaded }
+
+import pc from "@brillout/picocolors"
+import { getConfigFileExport } from "../../../../plugins/importUserCode/getConfigFileExport.js"
+import {
+  assert,
+  assertIsNotProductionRuntime,
+  assertUsage,
+  hasProp,
+} from "../../../../plugins/utils.js"
+import { FilePathResolved } from "../../../../types/interfaces/file.js"
+import { assertPlusFileExport } from "../../../gaurds/assertions/assertPlusFileExport.js"
+import type { InterfaceValueFile } from "./index.js"
+import { resolvePointerImport } from "./resolvePointerImport.js"
+import {
+  type PointerImportData,
+  parsePointerImportData,
+} from "./transformPointerImports.js"
+import { transpileAndExecuteFile } from "./transpileAndExecuteFile.js"
+
+assertIsNotProductionRuntime()
+
+type ImportedFilesLoaded = Record<string, Promise<Record<string, unknown>>>
+type ConfigFile = {
+  fileExports: Record<string, unknown>
+  filePath: FilePathResolved
+  extendsFilePaths: string[]
+}
+
+// Load pointer import
+async function loadImportedFile(
+  import_: FilePathResolved & { fileExportName: string },
+  userRootDir: string,
+  importedFilesLoaded: ImportedFilesLoaded
+): Promise<unknown> {
+  const f = import_.filePathAbsoluteFilesystem
+  if (!importedFilesLoaded[f]) {
+    importedFilesLoaded[f] = transpileAndExecuteFile(
+      import_,
+      userRootDir,
+      false
+    ).then((r) => r.fileExports)
+  }
+  const fileExports = await importedFilesLoaded[f]!
+  const fileExport = fileExports[import_.fileExportName]
+  return fileExport
+}
+
+// Load +{configName}.js
+async function loadValueFile(
+  interfaceValueFile: InterfaceValueFile,
+  configName: string,
+  userRootDir: string
+) {
+  const { fileExports } = await transpileAndExecuteFile(
+    interfaceValueFile.filePath,
+    userRootDir,
+    false
+  )
+  const { filePathToShowToUser } = interfaceValueFile.filePath
+  assertPlusFileExport(fileExports, filePathToShowToUser, configName)
+  Object.entries(fileExports).forEach(([exportName, configValue]) => {
+    const configName_ = exportName === "default" ? configName : exportName
+    interfaceValueFile.fileExportsByConfigName[configName_] = { configValue }
+  })
+}
+
+// Load +config.js, including all its extends pointer imports
+async function loadConfigFile(
+  configFilePath: FilePathResolved,
+  userRootDir: string,
+  visited: string[],
+  isExtensionConfig: boolean
+): Promise<{ configFile: ConfigFile; extendsConfigs: ConfigFile[] }> {
+  const { filePathAbsoluteFilesystem } = configFilePath
+  assertNoInfiniteLoop(visited, filePathAbsoluteFilesystem)
+  const { fileExports } = await transpileAndExecuteFile(
+    configFilePath,
+    userRootDir,
+    isExtensionConfig ? "is-extension-config" : true
+  )
+  const { extendsConfigs, extendsFilePaths } = await loadExtendsConfigs(
+    fileExports,
+    configFilePath,
+    userRootDir,
+    [...visited, filePathAbsoluteFilesystem]
+  )
+
+  const configFile: ConfigFile = {
+    fileExports,
+    filePath: configFilePath,
+    extendsFilePaths,
+  }
+  return { configFile, extendsConfigs }
+}
+function assertNoInfiniteLoop(
+  visited: string[],
+  filePathAbsoluteFilesystem: string
+) {
+  const idx = visited.indexOf(filePathAbsoluteFilesystem)
+  if (idx === -1) return
+  const loop = visited.slice(idx)
+  assert(loop[0] === filePathAbsoluteFilesystem)
+  assertUsage(
+    idx === -1,
+    `Infinite extends loop ${[...loop, filePathAbsoluteFilesystem].join(">")}`
+  )
+}
+async function loadExtendsConfigs(
+  configFileExports: Record<string, unknown>,
+  configFilePath: FilePathResolved,
+  userRootDir: string,
+  visited: string[]
+) {
+  const extendsPointerImportData = getExtendsPointerImportData(
+    configFileExports,
+    configFilePath
+  )
+  const extendsConfigFiles: FilePathResolved[] = []
+  extendsPointerImportData.map((pointerImportData) => {
+    const filePath = resolvePointerImport(
+      pointerImportData,
+      configFilePath,
+      userRootDir
+    )
+    assert(filePath.filePathAbsoluteFilesystem)
+    extendsConfigFiles.push(filePath)
+  })
+
+  const extendsConfigs: ConfigFile[] = []
+  await Promise.allSettled(
+    extendsConfigFiles.map(async (configFilePath) => {
+      const result = await loadConfigFile(
+        configFilePath,
+        userRootDir,
+        visited,
+        true
+      )
+      extendsConfigs.push(result.configFile)
+      extendsConfigs.push(...result.extendsConfigs)
+    })
+  )
+
+  const extendsFilePaths = extendsConfigFiles.map(
+    (f) => f.filePathAbsoluteFilesystem
+  )
+
+  return { extendsConfigs, extendsFilePaths }
+}
+function getExtendsPointerImportData(
+  configFileExports: Record<string, unknown>,
+  configFilePath: FilePathResolved
+): PointerImportData[] {
+  const { filePathToShowToUser } = configFilePath
+  const configFileExport = getConfigFileExport(
+    configFileExports,
+    filePathToShowToUser
+  )
+  const wrongUsage = `${filePathToShowToUser} sets the config ${pc.cyan(
+    "extends"
+  )} to an invalid value, see https://reveal.dev/extends`
+  let extendList: string[]
+  if (!("extends" in configFileExport)) {
+    return []
+  } else if (hasProp(configFileExport, "extends", "string")) {
+    extendList = [configFileExport.extends]
+  } else if (hasProp(configFileExport, "extends", "string[]")) {
+    extendList = configFileExport.extends
+  } else {
+    assertUsage(false, wrongUsage)
+  }
+  const extendsPointerImportData = extendList.map((importString) => {
+    const pointerImportData = parsePointerImportData(importString)
+    assertUsage(pointerImportData, wrongUsage)
+    return pointerImportData
+  })
+  return extendsPointerImportData
+}

package/dist/core/processing/getters/getRevealConfig/resolvePointerImport.ts

@@ -0,0 +1,240 @@
+export { clearFilesEnvMap, resolvePointerImport, resolvePointerImportOfConfig }
+
+import pc from "@brillout/picocolors"
+import path from "path"
+import {
+  assertIsNpmPackageImport,
+  assertPosixPath,
+  deepEqual,
+  isFilePathAbsolute,
+  requireResolve,
+} from "../../../../plugins/utils.js"
+import {
+  FilePath,
+  FilePathResolved,
+} from "../../../../types/interfaces/file.js"
+import {
+  ConfigEnvInternal,
+  DefinedAtFilePath,
+} from "../../../../types/interfaces/page.js"
+import { assert } from "../../../gaurds/assertions/assert/index.js"
+import { assertUsage } from "../../../gaurds/assertions/assertUsage/index.js"
+import {
+  getFilePathAbsoluteUserRootDir,
+  getFilePathResolved,
+  getFilePathUnresolved,
+} from "../getFilePath.js"
+import {
+  type PointerImportData,
+  parsePointerImportData,
+} from "./transformPointerImports.js"
+
+const filesEnvMap: Map<
+  string,
+  { configEnv: ConfigEnvInternal; configName: string }[]
+> = new Map()
+
+type PointerImportResolved = DefinedAtFilePath & { fileExportName: string }
+
+function resolvePointerImportOfConfig(
+  configValue: unknown,
+  importerFilePath: FilePathResolved,
+  userRootDir: string,
+  configEnv: ConfigEnvInternal,
+  configName: string
+): null | PointerImportResolved {
+  if (typeof configValue !== "string") return null
+  const pointerImportData = parsePointerImportData(configValue)
+  if (!pointerImportData) return null
+  const { importPath, exportName } = pointerImportData
+
+  const filePath = resolvePointerImport(
+    pointerImportData,
+    importerFilePath,
+    userRootDir
+  )
+  const fileExportPathToShowToUser =
+    exportName === "default" || exportName === configName ? [] : [exportName]
+
+  assertUsageFileEnv(
+    filePath.filePathAbsoluteFilesystem,
+    importPath,
+    configEnv,
+    configName
+  )
+
+  return {
+    ...filePath,
+    fileExportName: exportName,
+    fileExportPathToShowToUser,
+  }
+}
+
+function resolvePointerImport(
+  pointerImportData: PointerImportData,
+  importerFilePath: FilePathResolved,
+  userRootDir: string
+): FilePath {
+  // `importPath` should be one of the following:
+  // - A relative import path
+  // - A filesystem absolute path
+  // - An npm package import
+  const { importPath } = pointerImportData
+  const filePathAbsoluteFilesystem = resolveImportPathWithNode(
+    pointerImportData,
+    importerFilePath
+  )
+
+  let filePath: FilePath
+  assertPosixPath(importPath)
+  if (importPath.startsWith(".") || isFilePathAbsolute(importPath)) {
+    if (importPath.startsWith(".")) {
+      assertUsage(
+        importPath.startsWith("./") || importPath.startsWith("../"),
+        `Invalid relative import path ${pc.code(importPath)} defined by ${
+          importerFilePath.filePathToShowToUser
+        } because it should start with ${pc.code("./")} or ${pc.code("../")}, or use an npm package import instead.`
+      )
+    }
+
+    // Pointer imports are included in virtual files, thus relative imports need to be resolved. (Virtual modules cannot contain relative imports.)
+    assertUsageResolutionSuccess(
+      filePathAbsoluteFilesystem,
+      pointerImportData,
+      importerFilePath
+    )
+
+    // Pointer imports are included in virtual files, and we need filePathAbsoluteUserRootDir because we didn't find a way to have filesystem absolute import paths in virtual files: https://gist.github.com/brillout/2315231c9a8164f950c64b4b4a7bbd39
+    const errSuffix = `outside of the ${userRootDir} directory which is forbidden: make sure your import paths resolve inside the ${userRootDir} directory, or import from an npm package.`
+    const filePathAbsoluteUserRootDir = getFilePathAbsoluteUserRootDir({
+      filePathAbsoluteFilesystem,
+      userRootDir,
+    })
+    if (importPath.startsWith(".")) {
+      assertUsage(
+        filePathAbsoluteUserRootDir,
+        `The relative import ${pc.cyan(importPath)} defined by ${
+          importerFilePath.filePathToShowToUser
+        } resolves to ${filePathAbsoluteFilesystem} ${errSuffix}`
+      )
+    } else {
+      assert(isFilePathAbsolute(importPath))
+      assertUsage(
+        filePathAbsoluteUserRootDir,
+        `The import path ${importPath} defined by ${importerFilePath.filePathToShowToUser} is ${errSuffix}`
+      )
+    }
+    // Forbid node_modules/ because it's brittle: if node_modules/ lives outside of userRootDir then it crashes.
+    assertUsage(
+      !filePathAbsoluteUserRootDir.includes("/node_modules/"),
+      `The import path ${importPath} defined by ${importerFilePath.filePathToShowToUser} resolves to ${filePathAbsoluteFilesystem} inside of node_modules/ which is forbbiden: use an npm package import instead.`
+    )
+
+    filePath = getFilePathResolved({
+      filePathAbsoluteUserRootDir,
+      userRootDir,
+    })
+  } else {
+    const importPathAbsolute = importPath
+    if (filePathAbsoluteFilesystem) {
+      filePath = getFilePathResolved({
+        userRootDir,
+        filePathAbsoluteFilesystem,
+        importPathAbsolute,
+      })
+    } else {
+      filePath = getFilePathUnresolved({
+        importPathAbsolute,
+      })
+    }
+  }
+
+  return filePath
+}
+
+function resolveImportPathWithNode(
+  pointerImportData: PointerImportData,
+  importerFilePath: FilePathResolved
+): string | null {
+  const importerFilePathAbsolute = importerFilePath.filePathAbsoluteFilesystem
+  assertPosixPath(importerFilePathAbsolute)
+  const cwd = path.posix.dirname(importerFilePathAbsolute)
+  // We can't use import.meta.resolve() as of Junary 2023 (and probably for a lot longer)
+  // https://stackoverflow.com/questions/54977743/do-require-resolve-for-es-modules#comment137174954_62272600:~:text=But%20the%20argument%20parent%20(aka%20cwd)%20still%20requires%20a%20flag
+  // filePathAbsoluteFilesystem is expected to be null when pointerImportData.importPath is a Vite path alias
+  const filePathAbsoluteFilesystem = requireResolve(
+    pointerImportData.importPath,
+    cwd
+  )
+  return filePathAbsoluteFilesystem
+}
+
+function assertUsageResolutionSuccess(
+  filePathAbsoluteFilesystem: string | null,
+  pointerImportData: PointerImportData,
+  importerFilePath: FilePathResolved
+): asserts filePathAbsoluteFilesystem is string {
+  const {
+    importPath: importPath,
+    importStringWasGenerated,
+    importString,
+  } = pointerImportData
+  const { filePathToShowToUser } = importerFilePath
+
+  if (!filePathAbsoluteFilesystem) {
+    const importPathString = pc.code(`${importPath}`)
+    const errIntro = importStringWasGenerated
+      ? (`The import path ${importPathString} in ${filePathToShowToUser}` as const)
+      : (`The import ${pc.code(importString)} defined by ${filePathToShowToUser}` as const)
+    const errIntro2 =
+      `${errIntro} couldn't be resolved: does ${importPathString}` as const
+    if (importPath.startsWith(".")) {
+      assert(importPath.startsWith("./") || importPath.startsWith("../"))
+      assertUsage(false, `${errIntro2} point to an existing file?`)
+    } else {
+      assertUsage(false, `${errIntro2} exist?`)
+    }
+  }
+}
+
+function assertUsageFileEnv(
+  filePathAbsoluteFilesystem: string | null,
+  importPath: string,
+  configEnv: ConfigEnvInternal,
+  configName: string
+) {
+  let key: string
+  if (filePathAbsoluteFilesystem) {
+    key = filePathAbsoluteFilesystem
+  } else {
+    assertIsNpmPackageImport(importPath)
+    key = importPath
+  }
+  assertPosixPath(key)
+  if (!filesEnvMap.has(key)) {
+    filesEnvMap.set(key, [])
+  }
+  const fileEnv = filesEnvMap.get(key)!
+  fileEnv.push({ configEnv, configName })
+  const configDifferentEnv = fileEnv.filter(
+    (c) => !deepEqual(c.configEnv, configEnv)
+  )[0]
+  if (configDifferentEnv) {
+    assertUsage(
+      false,
+      [
+        `${key} defines the value of configs living in different environments:`,
+        ...[configDifferentEnv, { configName, configEnv }].map(
+          (c) =>
+            `  - config ${pc.code(c.configName)} which value lives in environment ${pc.code(
+              JSON.stringify(c.configEnv)
+            )}`
+        ),
+        "Defining config values in the same file is allowed only if they live in the same environment, see https://reveal.dev/config#pointer-imports",
+      ].join("\n")
+    )
+  }
+}
+function clearFilesEnvMap() {
+  filesEnvMap.clear()
+}

package/dist/core/processing/getters/getRevealConfig/transformPointerImports.spec.ts

@@ -0,0 +1,30 @@
+import { expect, describe, it } from "vitest";
+import { transformPointerImports } from "./transformPointerImports.js";
+
+function t(code: string) {
+  return transformPointerImports(code, "/fake-file.js", "all", true);
+}
+
+describe("transformPointerImports()", () => {
+  it("basics", () => {
+    expect(t("bla")).toMatchInlineSnapshot(`null`);
+    expect(t("import { something } from './bla.js'")).toMatchInlineSnapshot(
+      `"const something = '​import:./bla.js:something';"`,
+    );
+    expect(t("import def from './bla.js'")).toMatchInlineSnapshot(
+      `"const def = '​import:./bla.js:default';"`,
+    );
+  });
+  it("removes unused imports", () => {
+    expect(t("import './style.css'")).toMatchInlineSnapshot(`""`);
+    expect(t("import './script.js'")).toMatchInlineSnapshot(`""`);
+  });
+  it("import as", () => {
+    expect(t("import { bla as blu } from './bla.js'")).toMatchInlineSnapshot(
+      `"const blu = '​import:./bla.js:bla';"`,
+    );
+    expect(t("import * as blo from './bla.js'")).toMatchInlineSnapshot(
+      `"const blo = '​import:./bla.js:*';"`,
+    );
+  });
+});

package/dist/core/processing/getters/getRevealConfig/transformPointerImports.ts

@@ -0,0 +1,244 @@
+export { isPointerImportData, parsePointerImportData, transformPointerImports }
+export type { PointerImportData }
+
+// Playground: https://github.com/brillout/acorn-playground
+
+// Notes about `with { type: 'pointer' }`
+// - It works well with TypeScript: it doesn't complain upon `with { type: 'unknown-to-typescript' }` and go-to-definition & types are preserved: https://www.typescriptlang.org/docs/handbook/release-notes/typescript-5-3.html#import-attributes
+// - Acorn support for import attributes: https://github.com/acornjs/acorn/issues/983
+//   - Acorn plugin: https://github.com/acornjs/acorn/issues/983
+//   - Isn't stage 4 yet: https://github.com/tc39/proposal-import-attributes
+// - Using a import path suffix such as `import { Layout } from './Layout?real` breaks TypeScript, and TypeScript isn't working on supporting query params: https://github.com/microsoft/TypeScript/issues/10988#issuecomment-867135453
+// - Node.js >=21 supports import attribtues: https://nodejs.org/api/esm.html#import-attributes
+// - Esbuid supports
+//   - Blocker: https://github.com/evanw/esbuild/issues/3646
+//     - Ugly hack to make it work: https://github.com/brillout/esbuild-playground/tree/experiment/import-attribute
+//   - Discussion with esbuild maintainer: https://github.com/evanw/esbuild/issues/3384
+// - Using a magic comment `// @reveal-real-import` is probably a bad idea:
+//   - Esbuild removes comments: https://github.com/evanw/esbuild/issues/1439#issuecomment-877656182
+//   - Using source maps to track these magic comments is brittle (source maps can easily break)
+
+import pc from "@brillout/picocolors"
+import { parse } from "acorn"
+import type { Identifier, ImportDeclaration, Program } from "estree"
+import {
+  assert,
+  assertUsage,
+  assertWarning,
+  styleFileRE,
+} from "../../../../plugins/utils.js"
+
+function transformPointerImports(
+  code: string,
+  filePathToShowToUser2: string,
+  pointerImports:
+    | Record<string, boolean>
+    // Used by ./transformPointerImports.spec.ts
+    | "all",
+  // For ./transformPointerImports.spec.ts
+  skipWarnings?: true
+): string | null {
+  const spliceOperations: SpliceOperation[] = []
+
+  // Performance trick
+  if (!code.includes("import")) return null
+
+  const imports = getImports(code)
+  if (imports.length === 0) return null
+
+  imports.forEach((node) => {
+    if (node.type !== "ImportDeclaration") return
+
+    const importPath = node.source.value
+    assert(typeof importPath === "string")
+
+    if (pointerImports !== "all") {
+      assert(importPath in pointerImports)
+      const isPointerImport = pointerImports[importPath]
+      assert(isPointerImport === true || isPointerImport === false)
+      if (!isPointerImport) return
+    }
+
+    const { start, end } = node
+    const importStatementCode = code.slice(start, end)
+
+    /* Pointer import without importing any value => doesn't make sense and doesn't have any effect.
+    ```js
+    // Useless
+    import './some.css'
+    // Useless
+    import './Layout.jsx'
+    ``` */
+    if (node.specifiers.length === 0) {
+      const isWarning = !styleFileRE.test(importPath)
+      let quote = indent(importStatementCode)
+      if (isWarning) {
+        quote = pc.cyan(quote)
+      } else {
+        quote = pc.bold(pc.red(quote))
+      }
+      const errMsg = [
+        `The following import in ${filePathToShowToUser2} has no effect:`,
+        quote,
+        "See https://reveal.dev/config#pointer-imports",
+      ].join("\n")
+      if (!skipWarnings) {
+        if (!isWarning) {
+          assertUsage(false, errMsg)
+        }
+        assertWarning(false, errMsg, { onlyOnce: true })
+      }
+    }
+
+    let replacement = ""
+    node.specifiers.forEach((specifier) => {
+      assert(
+        specifier.type === "ImportSpecifier" ||
+          specifier.type === "ImportDefaultSpecifier" ||
+          specifier.type === "ImportNamespaceSpecifier"
+      )
+      const importLocalName = specifier.local.name
+      const exportName = (() => {
+        if (specifier.type === "ImportDefaultSpecifier") return "default"
+        if (specifier.type === "ImportNamespaceSpecifier") return "*"
+        {
+          const imported = (specifier as any).imported as Identifier | undefined
+          if (imported) return imported.name
+        }
+        return importLocalName
+      })()
+      const importString = serializePointerImportData({
+        importPath,
+        exportName,
+        importStringWasGenerated: true,
+      })
+      replacement += `const ${importLocalName} = '${importString}';`
+    })
+
+    spliceOperations.push({
+      start,
+      end,
+      replacement,
+    })
+  })
+
+  const codeMod = spliceMany(code, spliceOperations)
+  return codeMod
+}
+function getImports(code: string): ImportDeclaration[] {
+  const { body } = parse(code, {
+    ecmaVersion: "latest",
+    sourceType: "module",
+    // https://github.com/acornjs/acorn/issues/1136
+  }) as any as Program
+  const imports: ImportDeclaration[] = []
+  body.forEach((node) => {
+    if (node.type === "ImportDeclaration") imports.push(node)
+  })
+  return imports
+}
+
+const import_ = "import"
+const SEP = ":"
+const zeroWidthSpace = "\u200b"
+/**
+ * Data Structure for [pointer imports](https://reveal.dev/config#pointer-imports):
+ *   `import { someExport as someImport } from './some-file'`
+ * <=>
+ *   `pointerImportData === {`
+ *      `importPath: './some-file',`
+ *      `exportName: 'someExport',`
+ *      `importString: 'import:./some-file:someExport',`
+ *      `importStringWasGenerated: true,`
+ *    `}`
+ * We discard the import name `someImport` because we don't need it.
+ */
+type PointerImportData = {
+  importPath: string
+  exportName: string
+  importString: string
+  importStringWasGenerated: boolean
+}
+function serializePointerImportData({
+  importPath,
+  exportName,
+  importStringWasGenerated,
+}: Omit<PointerImportData, "importString">): string {
+  const tag = importStringWasGenerated ? zeroWidthSpace : ""
+  ;`import:${importPath}:${importPath}`
+  return `${tag}${import_}${SEP}${importPath}${SEP}${exportName}`
+}
+function isPointerImportData(str: string): boolean {
+  return (
+    str.startsWith(import_ + SEP) ||
+    str.startsWith(zeroWidthSpace + import_ + SEP)
+  )
+}
+function parsePointerImportData(
+  importString: string
+): null | PointerImportData {
+  if (!isPointerImportData(importString)) {
+    return null
+  }
+
+  let importStringWasGenerated = false
+  if (importString.startsWith(zeroWidthSpace)) {
+    importStringWasGenerated = true
+    assert(zeroWidthSpace.length === 1)
+    importString = importString.slice(1)
+  }
+
+  const parts = importString.split(SEP).slice(1)
+  if (!importStringWasGenerated && parts.length === 1) {
+    const exportName = "default"
+    const importPath = parts[0]!
+    return { importPath, exportName, importStringWasGenerated, importString }
+  }
+  assert(parts.length >= 2)
+  const exportName = parts[parts.length - 1]!
+  const importPath = parts.slice(0, -1).join(SEP)
+  return { importPath, exportName, importStringWasGenerated, importString }
+}
+
+// https://github.com/acornjs/acorn/issues/1136#issuecomment-1203671368
+declare module "estree" {
+  interface BaseNodeWithoutComments {
+    start: number
+    end: number
+  }
+}
+
+type SpliceOperation = {
+  start: number
+  end: number
+  replacement: string
+}
+function spliceMany(str: string, operations: SpliceOperation[]): string {
+  let strMod = ""
+  let endPrev: number | undefined
+  operations.forEach(({ start, end, replacement }) => {
+    if (endPrev !== undefined) {
+      assert(endPrev < start)
+    } else {
+      endPrev = 0
+    }
+    const replaced = str.slice(start, end)
+    strMod +=
+      str.slice(endPrev, start) +
+      replacement +
+      // Preserve number of lines for source map
+      Array(replaced.split("\n").length - replacement.split("\n").length)
+        .fill("\n")
+        .join("")
+    endPrev = end
+  })
+  strMod += str.slice(endPrev, str.length)
+  return strMod
+}
+
+function indent(str: string) {
+  return str
+    .split("\n")
+    .map((s) => `  ${s}`)
+    .join("\n")
+}