duto 0.260915.0 → 0.261001.0

package/src/pages/compiler/types.ts

@@ -8,17 +8,6 @@ export type PluginOptions = {
   pagesDir?: string,
 }
 
-export type DepMetadata = {
-  path: string,
-  ref: string,
-}
-
-export type FileMetadata = {
-  path: string,
-  content: string,
-  deps: Map<string, DepMetadata>,
-}
-
 export type I18nMetadata = {
   fallbackLocale: string,
   locales: string[],
@@ -52,15 +41,12 @@ export type Metadata = {
   minify: boolean,
 
   aliases: Record<string, string>,
-  map: Map<string, FileMetadata>,
-  violations: Map<string, DepMetadata[]>,
   layouts: Map<string, IRoute>, // all layouts
   nf: Map<string, IRoute>, // all 404
   pages: Map<string, IRoute>, // all
   spages: Set<string>, // ssg pages
   routes: Routes, // client-side
   // routes: Map<string, IRoute>, // client-side
-  assets: string[],
   i18n: I18nMetadata,
   string: string,
   summary: Map<string, SummaryMetadata>,
@@ -69,8 +55,7 @@ export type Metadata = {
 export type Page<P = {}> = FunctionComponent<VNode<P>>
 // A page module as imported by Bun/Vite
 export type PageModule<P = {}> = {
-  default: Page<P>,
-  // default: ComponentType<VNode<any>>,
+  default: Page<P>, // ComponentType<VNode<any>>,
   getStaticProps?: GetStaticProps,
   getProps?: GetProps,
 }
@@ -86,12 +71,6 @@ export type GetStaticProps =
   | (() => StaticProps[] | Promise<StaticProps[]>)
 export type StaticProps = Record<string, unknown>
 
-/** browser-only */
-// export type $duto = {
-//   sroutes: Set<string>,
-//   navigate: {},
-//   route: { pattern: string, params: RouteParams, path: string },
-// }
 export type GetProps = (params: RouteParams) => StaticProps | Promise<StaticProps>
 export type RouteParams = Record<string, string | string[] | undefined>
 
@@ -99,14 +78,9 @@ export type Routes = IRoute[]
 export type IRoute = {
   content: string,
   mod: PageModule,
-  /** True if the page exports getStaticProps */
   hasGetStaticProps: boolean,
-  /** True if the page exports getProps */
   hasGetProps: boolean,
   isClientOnly: boolean,
-  islands: ImportUsage[], // TODO mover para cá
-  // islands: IslandMeta[],
-  // safeFilePath: string,
   layouts: IRoute[],
   importName: string,
 
@@ -143,77 +117,3 @@ export type RouteParam = {
   catchAll: boolean,
   value?: string | string[],
 }
-
-
-
-export interface Usage {
-  type: 'jsx' | 'call' | 'reference'
-  source: string,
-  imported: string,
-  local: string,
-  start: number,
-  end: number,
-  text: string,
-  node: unknown,
-  parent: unknown,
-}
-
-export interface ImportUsage {
-  source: string,
-  imported: string,
-  local: string,
-  importStart: number,
-  importEnd: number,
-  importText: string,
-  usages: Usage[],
-}
-
-export interface IslandMeta {
-  /** Identificador curto e único (base64url de 7 chars) */
-  id: string
-  /** URL pública do asset JS do componente */
-  url: string
-  /** Nome do export usado */
-  export: string
-  /** Props serializadas como JSON (HTML-encoded) */
-  props: string
-  /** HTML do SSR do componente */
-  ssrHtml: string
-}
-
-// export interface ReplaceIslandsOptions {
-//   /**
-//    * Função que resolve o nome do componente para a URL pública do asset JS.
-//    * Ex: 'Counter' → '/assets/Counter.BQxoyJbC.js'
-//    */
-//   resolveUrl: (exportName: string) => string
-//   /**
-//    * Função que carrega o módulo do componente para fazer SSR.
-//    * Recebe o source da importação (ex: '@/components/counter2') e o nome do export.
-//    */
-//   loadComponent: (source: string, exportName: string) => Promise<unknown>
-// }
-
-
-// export type Island = {
-//   /** Unique id — written as data-island on the placeholder div */
-//   id: string,
-//   /** Component display name — used by the client to look up the component */
-//   name: string,
-//   /** Props serialised into the placeholder for client hydration */
-//   props: Record<string, unknown>,
-// }
-
-// export type RenderResult = {
-//   html: string,
-//   islands: Island[],
-//   /** true if any islands were found (= client JS needed) */
-//   hasIslands: boolean,
-// }
-
-// export type IslandMeta = {
-//   id: string,
-//   name: string,
-//   props: Record<string, unknown>,
-// }
-

package/src/pages/compiler/vite-plugin.ts

@@ -6,17 +6,17 @@ import { defineConfig } from 'vite'
 
 import preact from '@preact/preset-vite'
 import tailwind from '@tailwindcss/vite'
+import { JSJSON } from 't0n'
 
 import { EXT_RE } from './constants'
-import { setAsset, setChunk, setEntry } from './assets'
+import { getChunk, setAsset, setChunk, setEntry } from './assets'
 import { renderPage } from '.'
 import { removeExports, resolveImport } from './ast'
 import { getMetadata } from './meta'
 
 import type {
-  // Plugin,
   UserConfig, ConfigEnv, ResolvedConfig,
-  PreviewServer,
+  // PreviewServer,
   // ViteDevServer,
   EnvironmentOptions,
   PluginOption,
@@ -42,6 +42,7 @@ export const config = (opts: UserConfig & PluginOptions) => { // @ts-ignore
   return defineConfig(opts)
 }
 
+// TODO: remover..
 export default config
 
 let metadata: Metadata
@@ -50,13 +51,11 @@ export function meta() {
 }
 
 export function plugin(options: PluginOptions = {}): PluginOption[] {
-  // let server: ViteDevServer
   let config: ResolvedConfig
   const {
-    root = _root, // process.env.npm_config_local_prefix || process.env.PWD || process.cwd() || __dirname,
+    root = _root,
     pagesDir = 'pages',
   } = options
-  // let metadata: Metadata
 
   const PAGES_RE = new RegExp(`\/${pagesDir}\/.*\.(tsx?|jsx?)$`, 'i')
   const stripTarget = new Set(['getStaticProps'])
@@ -105,18 +104,9 @@ export function plugin(options: PluginOptions = {}): PluginOption[] {
       name: 'duto:scan',
       enforce: 'pre',
 
-      // configureServer(_server) {
-      //   server = _server
-      //   // servers.push(server)
-      // },
-
       async config(conf: UserConfig, env: ConfigEnv) {
         metadata = await getMetadata(root as string, pagesDir)
 
-        // console.log(metadata.map)
-        // console.log(metadata.violations)
-        // console.log(Array.from(metadata.violations).filter(file => EXT_RE.test(file)))
-
         if (conf.build) {
           // conf.build.emptyOutDir = false
           conf.build.copyPublicDir = false
@@ -129,10 +119,11 @@ export function plugin(options: PluginOptions = {}): PluginOption[] {
           conf.build.rolldownOptions = conf.build.rolldownOptions || {}
           conf.build.rolldownOptions.preserveEntrySignatures = 'exports-only' ///
           conf.build.rolldownOptions.input = [
+            ...metadata.routes.map(r => r.is404 ? '' : r.fullFilePath).filter(Boolean),
             ':duto/client/app.tsx',
             // ':duto/not-found.tsx',
-            ...Object.keys(metadata.pages),
-            ...metadata.assets,
+            // ...Object.keys(metadata.pages),
+            // ...metadata.assets,
           ]
 
           const filePrefix = metadata.minify ? '' : '[name].'
@@ -141,11 +132,6 @@ export function plugin(options: PluginOptions = {}): PluginOption[] {
             hoistTransitiveImports: false,
             format: 'esm',
             minifyInternalExports: metadata.minify,
-
-            // manualChunks: {
-            //   vendor: ['preact', '@preact/signals', 'wouter-preact'],
-            // },
-            // preserveModules: true,
             preserveModulesRoot: '/',
             assetFileNames: filePrefix +'[hash][extname]',
             entryFileNames: filePrefix +'[hash].js',
@@ -155,14 +141,19 @@ export function plugin(options: PluginOptions = {}): PluginOption[] {
             // entryFileNames: 'assets/[name].js',
             // chunkFileNames: 'assets/chunks/[name]-[hash].js',
             // assetFileNames: 'assets/[name][extname]',
+
+            // manualChunks: {
+            //   vendor: ['preact', '@preact/signals', 'wouter-preact'],
+            // },
+            // preserveModules: true,
           }
         }
 
         return conf
       },
 
-      async configResolved(conf) {
-        config = conf
+      async configResolved(c) {
+        config = c
       },
 
       resolveId(id) {
@@ -217,15 +208,18 @@ export function plugin(options: PluginOptions = {}): PluginOption[] {
         // for (const id of moduleIds)
         // console.error(id)
 
+        // TODO: rever isso...
         for (const key in bundle) {
           const file = bundle[key]
+
           if (file.type === 'chunk' && file.isEntry) {
             setChunk(file.facadeModuleId, '/'+ file.fileName)
             continue
           }
 
           if (file.type === 'asset' && file?.originalFileName?.endsWith('duto/pages/client/app.tsx'))
-            file.source += 'd-b,d-p,i-d,i-s,i-i{display:contents}'
+            file.source += 'i-i{display:contents}'
+            // file.source += 'd-b,d-p,i-d,i-s,i-i{display:contents}'
 
           if (file.type === 'asset' && file.fileName.endsWith('.css')) {
             setAsset(resolveImport(file.originalFileName as string, metadata.root, metadata.aliases), '/'+ file.fileName)
@@ -241,6 +235,35 @@ export function plugin(options: PluginOptions = {}): PluginOption[] {
 
     },
 
+    // {
+    //   name: 'duto:routes-inject',
+    //   enforce: 'post',
+    //   generateBundle(_, bundle) {
+    //     // monta o mapa a partir dos inputs de metadata.routes
+    //     const routeMap: Record<string, string> = {}
+    //     for (const r of metadata.routes) {
+    //       if (r.is404) continue
+    //       // encontra o chunk cujo facadeModuleId bate com r.fullFilePath
+    //       for (const [fileName, chunk] of Object.entries(bundle)) {
+    //         if (chunk.type === 'chunk' && chunk.facadeModuleId === r.fullFilePath) {
+    //           routeMap[r.path] = fileName
+    //           break
+    //         }
+    //       }
+    //     }
+
+    //     // injeta no chunk do app
+    //     for (const chunk of Object.values(bundle)) {
+    //       if (chunk.type !== 'chunk') continue
+    //       if (chunk.facadeModuleId?.includes('app.tsx') || chunk.code.includes('__DUTO_ROUTES__')) {
+    //         chunk.code = chunk.code.replace(
+    //           '__DUTO_ROUTES__',
+    //           JSON.stringify(routeMap)
+    //         )
+    //       }
+    //     }
+    //   }
+    // },
     {
       name: 'duto:build',
       enforce: 'pre',
@@ -275,13 +298,36 @@ export function plugin(options: PluginOptions = {}): PluginOption[] {
       },
 
       async closeBundle() {
-        for (const [_filePath, page] of metadata.pages) // {
+        for (const [_filePath, page] of metadata.pages)
           await renderPage(metadata, config, page)
           // const mod = await server.ssrLoadModule(_filePath)
-        // }
 
         rmSync(join(metadata.root, 'tmp'), {recursive: true, force: true})
         // await server.close()
+
+        const outPath = join(config.root, config.build.outDir)
+        const entry = Bun.file(join(outPath, getChunk(':duto/client/app.tsx')))
+        let entryContent = await entry.text()
+
+        for (const r of metadata.routes.filter(r => !r.is404))
+          entryContent = entryContent.replace(r.fullFilePath, getChunk(r.fullFilePath.replace(config.root, '')))
+
+        await entry.write(entryContent)
+
+        // i18n
+        for (const locale of metadata.i18n.locales) {
+          const intlPath = join(metadata.root, 'i18n', locale + '.ts')
+          if (existsSync(intlPath)) {
+            const intlMod = await import(intlPath)
+            await Bun.write(
+              join(outPath, locale +'.js'),
+              `var a=${JSJSON({
+                routes: intlMod.routes ?? intlMod.default?.routes,
+                messages: intlMod.messages ?? intlMod.default?.messages,
+              })};export { a as default }`
+            )
+          }
+        }
       },
 
       // TODO: precisa ser aqui mesmo pois se a pagina for importada no entry, pode incluir codigo nao usado no chunck/bundle

package/src/pages/i18n/client.ts

@@ -84,12 +84,22 @@ export const getLocale = () => {
   }
 }
 
-export const setLocale = (lang: string) => {
+export const setLocale = async (lang: string) => {
+  await loadLang(lang)
   cache(lang)
   _locale = accepted(lang, _locales, _detected)
 }
 
-export default function i18n(
+async function loadLang(lang: string) {
+  if (!_routes[lang] || !_messages[lang]) {
+    const intlMod = await import('/'+ lang +'.js')
+    if (!intlMod) return
+    _routes[lang] = intlMod.routes ?? intlMod.default?.routes
+    _messages[lang] = intlMod.messages ?? intlMod.default?.messages
+  }
+}
+
+export default async function i18n(
   fallbackLocale: string,
   locales: string[],
   messages: Record<string, Record<string, string>>,
@@ -103,6 +113,8 @@ export default function i18n(
   _detected = detect(locales, fallbackLocale)
   _locale = typeof window === 'undefined' ? fallbackLocale : getLocale()
 
+  await loadLang(_locale)
+
   // console.error(routes)
   // console.error(routeMap)
 }
@@ -173,10 +185,10 @@ type TProps = {
 }
 
 const lookup = (key: string, lang: string): string => {
-  if (!key) return '';
-  if (key.startsWith('_')) return key.replace(/^_+/, '');
-  const msg = _messages[lang] ?? _messages[_locale];
-  return (key in msg ? msg[key] : key) as string;
+  if (!key) return ''
+  if (key.startsWith('_')) return key.replace(/^_+/, '')
+  const msg = _messages[lang] ?? _messages[_locale]
+  return (msg && key in msg ? msg[key] : key) as string
 }
 
 const interpolate = (template: string, params: Record<string, Primitives> | Primitives[]): string => {

package/src/pages/i18n/server.ts

@@ -11,7 +11,7 @@ export default async function getI18n(meta: Metadata) {
     'i18n.ts',
     'i18n/index.ts',
   ]) {
-     const path = join(meta.root, variant)
+    const path = join(meta.root, variant)
     if (existsSync(path)) {
       file = path
       break
@@ -22,13 +22,28 @@ export default async function getI18n(meta: Metadata) {
   const mod = await IMPORT<I18nMetadata>(file)
 
   // @ts-ignore
-  if (['locales', 'fallbackLocale', 'messages', 'routes', 'options'].some(i => !mod[i]))
+  if (['locales', 'fallbackLocale', 'options'].some(i => !mod[i]))
     return {} as I18nMetadata
 
+  // const routes = Object.fromEntries(mod.locales.map(locale => [locale, ]))
+
+  const routes: Record<string, Record<string, string>> = {}
+  const messages: Record<string, Record<string, string>> = {}
+  for (const locale of mod.locales) {
+    const intlPath = join(meta.root, 'i18n', locale + '.ts')
+    if (existsSync(intlPath)) {
+      const intlMod = await IMPORT<{default:{routes: Record<string, string>, messages: Record<string, string>}}>(intlPath)
+      routes[locale] = intlMod.default.routes
+      messages[locale] = intlMod.default.messages
+    }
+  }
+
   const i18n: I18nMetadata = {
     ...mod,
+    routes,
+    messages,
     routeMap: Object.fromEntries(
-      Object.values(mod.routes)
+      Object.values(routes)
         .map(paths => Object.entries(paths).map(([key, path]) => path == key ? 0 : [path, key]).filter(Boolean))
         .flat() as Array<[string, string]>
     ),
@@ -36,7 +51,7 @@ export default async function getI18n(meta: Metadata) {
     string: '',
   }
 
-  Object.entries(mod.routes)
+  Object.entries(routes)
     .forEach(([locale, paths]) => {
        Object.entries(paths)
         .forEach(([route, path]) => i18n.pageRoutes.push({ locale, path }))
@@ -44,8 +59,8 @@ export default async function getI18n(meta: Metadata) {
 
   i18n.string = `export const fallbackLocale = ${JSJSON(mod.fallbackLocale)}
 export const locales = ${JSJSON(mod.locales)}
-export const messages = ${JSJSON(mod.messages)}
-export const routes = ${JSJSON(mod.routes)}
+export const messages = ${JSJSON(messages)}
+export const routes = ${JSJSON(routes)}
 export const routeMap = ${JSJSON(i18n.routeMap)}
 export const pageRoutes = ${JSJSON(i18n.pageRoutes)}
 export const options = ${JSJSON(mod.options)}

package/src/pages/index.ts

@@ -21,8 +21,7 @@ export const navigate = <S = any>(
     return
   }
 
-  const n = window?.$duto?.navigate || useLocation()[1]
-  n(to, options)
+  window?.$duto?.navigate || useLocation()[1](to, options)
 }
 
 export { Link } from './components/link'

package/src/server/routes.ts

@@ -1,4 +1,4 @@
-import { Glob, file, write } from 'bun'
+import { file, write } from 'bun'
 
 import { copyFileSync } from 'node:fs'
 import { join, relative } from 'pathe'
@@ -12,7 +12,7 @@ import { STATUS_CODES } from 'node:http'
 import $ from './app'
 import _response from './response'
 import _validator from './validator'
-import { _root, _server } from '@/utils'
+import { _root, _server, scan } from '@/utils'
 import { getLastCommitHash, ensureDir, nextId, verbAlias } from './utils'
 import { generateOpenAPI, generateOpenAPIClient, openAPIConfig } from './open-api/spec'
 import { highlightedMethod, highlightedURI } from './cli/utils'
@@ -21,28 +21,6 @@ import type { Routes, Rule, StandardSchemaV1 } from './types'
 import { autorizedPath } from './middlewares/auth'
 import { isDev } from './utils/environment'
 
-export async function* scan(
-  dir: string | string[],
-  ext: string | string[],
-  ignore: string[] = ['*.d.*'],
-  cwd?: string,
-): AsyncGenerator<[string, string, any]> {
-  if (typeof dir !== 'string')
-    dir = ext.length === 1 ? dir[0] : `{${dir.join(',')}}`
-
-  if (typeof ext !== 'string')
-    ext = ext.length === 1 ? ext[0] : `{${ext.join(',')}}`
-
-  cwd ??= _root
-  for await (const file of new Glob(dir +'/**/*.'+ ext).scan({
-    cwd,
-    absolute: true,
-    onlyFiles: true, // @ts-ignore
-    ignore,
-  })) {
-    yield [file, file.split(cwd as string)[1], await IMPORT(file)]
-  }
-}
 
 const importName = (name: string | undefined, dirs: string[]) => (name || nextId()).replace(/\.ts$/, '')
 
@@ -407,10 +385,10 @@ export async function cacheRoutes() {
   if (isDev()) {
     const _file = join(_server, 'middlewares', 'logger.ts')
     const _mod = await IMPORT(_file) // @ts-ignore
-    middlewares.unshift({
+    middlewares.unshift({ // @ts-ignore
       path: _mod?.path || '*',
       name: 'dev_logger',
-      file: _file,
+      file: _file, // @ts-ignore
       handle: _mod.handle,
     })
   }

package/src/utils.ts

@@ -1,10 +1,10 @@
-import { getEnv } from 't0n'
+import { IMPORT } from 't0n'
 import { dirname, join } from 'pathe'
 
 export const _duto = dirname(new URL(import.meta.url).pathname)
 export const _pages = join(_duto, 'pages')
-export const _server = join(_duto, 'server')
-export const _root = getEnv('npm_config_local_prefix') || getEnv('PWD') || join(_duto, '../../')
+export const _server = join(_duto, 'server') //@ts-ignore
+export const _root = process.env?.npm_config_local_prefix || process.env?.PWD || process.stdin?.path || process.cwd() // || join(_duto, '../../')s
 
 const UNITS = ['B', 'kB', 'MB', 'GB']
 export function filesize(bytes: number, decimals = 2) {
@@ -13,3 +13,34 @@ export function filesize(bytes: number, decimals = 2) {
   const i = Math.min(Math.floor(Math.log(bytes) / Math.log(1024)), UNITS.length - 1)
   return `${parseFloat((bytes / 1024 ** i).toFixed(decimals))} ${UNITS[i]}`
 }
+
+export const formatTime = (ms: number) => {
+  if (ms < 0.001) return `${(ms * 1_000_000).toFixed(2)}ns`
+  if (ms < 1) return `${(ms * 1000).toFixed(2)}µs`
+  if (ms < 1000) return `${ms.toFixed(2)}ms`
+  if (ms < 60000) return `${(ms / 1000).toFixed(2)}s`
+  return `${Math.floor(ms / 60000)}m ${((ms % 60000) / 1000).toFixed(1)}s`
+}
+
+export async function* scan(
+  dir: string | string[],
+  ext: string | string[],
+  ignore: string[] = ['*.d.*'],
+  cwd?: string,
+): AsyncGenerator<[string, string, any]> {
+  if (typeof dir !== 'string')
+    dir = ext.length === 1 ? dir[0] : `{${dir.join(',')}}`
+
+  if (typeof ext !== 'string')
+    ext = ext.length === 1 ? ext[0] : `{${ext.join(',')}}`
+
+  cwd ??= _root
+  for await (const file of new Bun.Glob(dir +'/**/*.'+ ext).scan({
+    cwd,
+    absolute: true,
+    onlyFiles: true, // @ts-ignore
+    ignore,
+  })) {
+    yield [file, file.split(cwd as string)[1], await IMPORT(file)]
+  }
+}

package/src/pages/compiler/island.ts

@@ -1,108 +0,0 @@
-import { h } from 'preact'
-import { renderToString } from 'preact-render-to-string'
-import { IMPORT, newID } from 't0n'
-
-import { getEntry } from './assets'
-import { makeByteToCharMap, extractPropsFromJSX } from './ast'
-
-import type { ImportUsage, IslandMeta } from './types'
-
-function serializeProps(props: Record<string, unknown>) {
-  return JSON.stringify(props)
-}
-
-function htmlEncodeProps(serialized: string) {
-  return serialized
-    .replace(/&/g, '&amp;')
-    .replace(/"/g, '&quot;')
-    .replace(/</g, '&lt;')
-    .replace(/>/g, '&gt;')
-}
-
-async function renderIslandSSR(
-  component: unknown,
-  props: Record<string, unknown>,
-  children?: unknown,
-): Promise<string> {
-  try {
-    return renderToString(h(component as never, props as never, children as never))
-  } catch {
-    return ''
-  }
-}
-
-function buildIslandTag(meta: IslandMeta) {
-  return `<i-s id="${meta.id}" url="${getEntry(meta.url)}"${meta.export === 'default' ? '' : ` export="${meta.export}"`}${meta.props === '{}' ? '' : ` props="${meta.props}"`}>${meta.ssrHtml}</i-s>`
-}
-
-/**
- * Replaces in "sourceCode" each occurrence of imported components
- * from "importSource" by hydrator-compatible <island> tags.
- *
- * @param sourceCode TSX source code
- * @param importSource The target module (e.g. '@/components/counter2')
- * @param opts Resolution callbacks
- * @returns Code with replacements applied
- */
-export async function replaceIslands(
-  code: string,
-  usages: ImportUsage[],
-) {
-  if (!usages.length) return code
-
-  const b2c = makeByteToCharMap(code)
-  const toChar = (byteOffset: number) => b2c[byteOffset - 1]
-
-  const replacements: Array<{ start: number; end: number; replacement: string }> = []
-
-  for (const importUsage of usages) {
-    const component = await IMPORT(importUsage.source, importUsage.imported)
-
-    // schedule removal of the import declaration (replacement with an empty string)
-    replacements.push({
-      start: toChar(importUsage.importStart),
-      end: toChar(importUsage.importEnd),
-      replacement: '',
-    })
-
-    // schedule the replacement of each JSX usage with `<island>`
-    for (const usage of importUsage.usages) {
-      if (usage.type !== 'jsx') continue
-
-      const props = extractPropsFromJSX(usage.node)
-      const ssrHtml = await renderIslandSSR(component, props)
-
-      const island = buildIslandTag({
-        id: newID(),
-        url: importUsage.source,
-        export: importUsage.imported,
-        props: htmlEncodeProps(serializeProps(props)),
-        ssrHtml,
-      })
-
-      replacements.push({
-        start: toChar(usage.start),
-        end: toChar(usage.end),
-        replacement: island,
-      })
-    }
-  }
-
-  if (!replacements.length) return code
-
-  replacements.sort((a, b) => a.start - b.start)
-
-  const parts: string[] = []
-  let cursor = 0
-
-  for (const { start, end, replacement } of replacements) {
-    if (start < cursor) continue // overlapped, discards
-    if (start > cursor) parts.push(code.slice(cursor, start))
-    parts.push(replacement)
-    cursor = end
-  }
-
-  if (cursor < code.length) parts.push(code.slice(cursor))
-
-  return parts.join('').replace(/\n{3,}/g, '\n\n')
-}