@revealui/core 0.0.1-pre.1 → 0.0.1-pre.2

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

@@ -1,181 +0,0 @@
-// 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

@@ -1,240 +0,0 @@
-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

@@ -1,30 +0,0 @@
-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

@@ -1,244 +0,0 @@
-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")
-}