@eighty4/dank 0.0.3 → 0.0.4-1

package/lib/serve.ts

@@ -1,55 +1,95 @@
-import { mkdir, readFile, rm, watch as _watch } from 'node:fs/promises'
+import {
+    mkdir,
+    readFile,
+    rm,
+    watch as _watch,
+    writeFile,
+} from 'node:fs/promises'
 import { extname, join, resolve } from 'node:path'
 import type { BuildContext } from 'esbuild'
 import { buildWebsite } from './build.ts'
 import { loadConfig } from './config.ts'
 import type { DankConfig } from './dank.ts'
 import { createGlobalDefinitions } from './define.ts'
-import { esbuildDevContext } from './esbuild.ts'
-import { isPreviewBuild } from './flags.ts'
+import { esbuildDevContext, type EntryPoint } from './esbuild.ts'
+import { resolveServeFlags, type DankServe } from './flags.ts'
 import { HtmlEntrypoint } from './html.ts'
 import {
     createBuiltDistFilesFetcher,
     createDevServeFilesFetcher,
-    createWebServer,
+    startWebServer,
+    type PageRouteState,
+    type UrlRewrite,
 } from './http.ts'
+import { WebsiteRegistry } from './metadata.ts'
 import { startDevServices, updateDevServices } from './services.ts'
 
-const isPreview = isPreviewBuild()
-
-// alternate port for --preview bc of service worker
-const PORT = isPreview ? 4000 : 3000
-
-// port for esbuild.serve
-const ESBUILD_PORT = 2999
-
 export async function serveWebsite(c: DankConfig): Promise<never> {
-    await rm('build', { force: true, recursive: true })
-    if (isPreview) {
-        await startPreviewMode(c)
+    const serve = resolveServeFlags(c)
+    await rm(serve.dirs.buildRoot, { force: true, recursive: true })
+    const abortController = new AbortController()
+    process.once('exit', () => abortController.abort())
+    if (serve.preview) {
+        await startPreviewMode(c, serve, abortController.signal)
     } else {
-        const abortController = new AbortController()
-        await startDevMode(c, abortController.signal)
+        await startDevMode(c, serve, abortController.signal)
     }
     return new Promise(() => {})
 }
 
-async function startPreviewMode(c: DankConfig) {
-    const { dir, files } = await buildWebsite(c)
-    const frontend = createBuiltDistFilesFetcher(dir, files)
-    createWebServer(PORT, frontend).listen(PORT)
-    console.log(`preview is live at http://127.0.0.1:${PORT}`)
+async function startPreviewMode(
+    c: DankConfig,
+    serve: DankServe,
+    signal: AbortSignal,
+) {
+    const manifest = await buildWebsite(c, serve)
+    const frontend = createBuiltDistFilesFetcher(serve.dirs.buildDist, manifest)
+    const devServices = startDevServices(c, signal)
+    startWebServer(serve, frontend, devServices.http, {
+        urls: Object.keys(c.pages),
+        urlRewrites: collectUrlRewrites(c),
+    })
+}
+
+function collectUrlRewrites(c: DankConfig): Array<UrlRewrite> {
+    return Object.keys(c.pages)
+        .sort()
+        .map(url => {
+            const mapping = c.pages[url as `/${string}`]
+            return typeof mapping !== 'object' || !mapping.pattern
+                ? null
+                : { url, pattern: mapping.pattern }
+        })
+        .filter(mapping => mapping !== null)
+}
+
+type BuildContextState =
+    | BuildContext
+    | 'starting'
+    | 'dirty'
+    | 'disposing'
+    | null
+
+type EntrypointsState = {
+    entrypoints: Array<EntryPoint>
+    pathsIn: Set<string>
 }
 
 // todo changing partials triggers update on html pages
-async function startDevMode(c: DankConfig, signal: AbortSignal) {
-    const watchDir = join('build', 'watch')
-    await mkdir(watchDir, { recursive: true })
-    const clientJS = await loadClientJS()
-    const pagesByUrlPath: Record<string, WebpageMetadata> = {}
-    const entryPointsByUrlPath: Record<string, Set<string>> = {}
-    let buildContext: BuildContext | 'starting' | 'dirty' | 'disposing' | null =
-        null
+async function startDevMode(
+    c: DankConfig,
+    serve: DankServe,
+    signal: AbortSignal,
+) {
+    await mkdir(serve.dirs.buildWatch, { recursive: true })
+    const registry = new WebsiteRegistry(serve)
+    const clientJS = await loadClientJS(serve.esbuildPort)
+    const pagesByUrlPath: Record<string, HtmlEntrypoint> = {}
+    const partialsByUrlPath: Record<string, Array<string>> = {}
+    const entryPointsByUrlPath: Record<string, EntrypointsState> = {}
+    let buildContext: BuildContextState = null
+
+    registry.on('workers', resetBuildContext)
 
     watch('dank.config.ts', signal, async () => {
         let updated: DankConfig
@@ -60,15 +100,17 @@ async function startDevMode(c: DankConfig, signal: AbortSignal) {
         }
         const prevPages = new Set(Object.keys(pagesByUrlPath))
         await Promise.all(
-            Object.entries(updated.pages).map(async ([urlPath, srcPath]) => {
-                c.pages[urlPath as `/${string}`] = srcPath
-                if (pagesByUrlPath[urlPath]) {
+            Object.entries(updated.pages).map(async ([urlPath, mapping]) => {
+                c.pages[urlPath as `/${string}`] = mapping
+                const srcPath =
+                    typeof mapping === 'string' ? mapping : mapping.webpage
+                if (!pagesByUrlPath[urlPath]) {
+                    await addPage(urlPath, srcPath)
+                } else {
                     prevPages.delete(urlPath)
-                    if (pagesByUrlPath[urlPath].srcPath !== srcPath) {
+                    if (pagesByUrlPath[urlPath].fsPath !== srcPath) {
                         await updatePage(urlPath)
                     }
-                } else {
-                    await addPage(urlPath, srcPath)
                 }
             }),
         )
@@ -79,114 +121,165 @@ async function startDevMode(c: DankConfig, signal: AbortSignal) {
         updateDevServices(updated)
     })
 
-    watch('pages', signal, filename => {
+    watch(serve.dirs.pages, signal, filename => {
         if (extname(filename) === '.html') {
             for (const [urlPath, srcPath] of Object.entries(c.pages)) {
                 if (srcPath === filename) {
                     updatePage(urlPath)
                 }
             }
+            for (const [urlPath, partials] of Object.entries(
+                partialsByUrlPath,
+            )) {
+                if (partials.includes(filename)) {
+                    updatePage(urlPath, filename)
+                }
+            }
         }
     })
 
     await Promise.all(
-        Object.entries(c.pages).map(([urlPath, srcPath]) =>
-            addPage(urlPath, srcPath),
-        ),
+        Object.entries(c.pages).map(async ([urlPath, mapping]) => {
+            const srcPath =
+                typeof mapping === 'string' ? mapping : mapping.webpage
+            await addPage(urlPath, srcPath)
+            return new Promise(res =>
+                pagesByUrlPath[urlPath].once('entrypoints', res),
+            )
+        }),
     )
 
     async function addPage(urlPath: string, srcPath: string) {
-        const metadata = await processWebpage({
-            clientJS,
-            outDir: watchDir,
-            pagesDir: 'pages',
-            srcPath,
+        await mkdir(join(serve.dirs.buildWatch, urlPath), { recursive: true })
+        const htmlEntrypoint = (pagesByUrlPath[urlPath] = new HtmlEntrypoint(
+            serve,
+            registry.resolver,
             urlPath,
+            srcPath,
+            [{ type: 'script', js: clientJS }],
+        ))
+        htmlEntrypoint.on('entrypoints', entrypoints => {
+            const pathsIn = new Set(entrypoints.map(e => e.in))
+            if (
+                !entryPointsByUrlPath[urlPath] ||
+                !matchingEntrypoints(
+                    entryPointsByUrlPath[urlPath].pathsIn,
+                    pathsIn,
+                )
+            ) {
+                entryPointsByUrlPath[urlPath] = { entrypoints, pathsIn }
+                resetBuildContext()
+            }
+        })
+        htmlEntrypoint.on('partial', partial => {
+            if (!partialsByUrlPath[urlPath]) {
+                partialsByUrlPath[urlPath] = []
+            }
+            partialsByUrlPath[urlPath].push(partial)
         })
-        pagesByUrlPath[urlPath] = metadata
-        entryPointsByUrlPath[urlPath] = new Set(
-            metadata.entryPoints.map(e => e.in),
+        htmlEntrypoint.on(
+            'partials',
+            partials => (partialsByUrlPath[urlPath] = partials),
+        )
+        htmlEntrypoint.on('output', html =>
+            writeFile(join(serve.dirs.buildWatch, urlPath, 'index.html'), html),
         )
-        if (buildContext !== null) {
-            resetBuildContext()
-        }
     }
 
     function deletePage(urlPath: string) {
+        pagesByUrlPath[urlPath].removeAllListeners()
         delete pagesByUrlPath[urlPath]
         delete entryPointsByUrlPath[urlPath]
         resetBuildContext()
     }
 
-    async function updatePage(urlPath: string) {
-        const update = await processWebpage({
-            clientJS,
-            outDir: watchDir,
-            pagesDir: 'pages',
-            srcPath: c.pages[urlPath as `/${string}`],
-            urlPath,
-        })
-        const entryPointUrls = new Set(update.entryPoints.map(e => e.in))
-        if (!hasSameValues(entryPointUrls, entryPointsByUrlPath[urlPath])) {
-            entryPointsByUrlPath[urlPath] = entryPointUrls
-            resetBuildContext()
-        }
+    async function updatePage(urlPath: string, partial?: string) {
+        pagesByUrlPath[urlPath].emit('change', partial)
     }
 
-    function collectEntrypoints(): Array<{ in: string; out: string }> {
-        const sources: Set<string> = new Set()
-        return Object.values(pagesByUrlPath)
-            .flatMap(({ entryPoints }) => entryPoints)
+    function collectEntrypoints(): Array<EntryPoint> {
+        const unique: Set<string> = new Set()
+        const pageBundles = Object.values(entryPointsByUrlPath)
+            .flatMap(entrypointState => entrypointState.entrypoints)
             .filter(entryPoint => {
-                if (sources.has(entryPoint.in)) {
+                if (unique.has(entryPoint.in)) {
                     return false
                 } else {
-                    sources.add(entryPoint.in)
+                    unique.add(entryPoint.in)
                     return true
                 }
             })
+        const workerBundles = registry.workerEntryPoints()
+        if (workerBundles) {
+            return [...pageBundles, ...workerBundles]
+        } else {
+            return pageBundles
+        }
     }
 
     function resetBuildContext() {
-        if (buildContext === 'starting' || buildContext === 'dirty') {
-            buildContext = 'dirty'
-            return
-        }
-        if (buildContext === 'disposing') {
-            return
+        switch (buildContext) {
+            case 'starting':
+                buildContext = 'dirty'
+                return
+            case 'dirty':
+            case 'disposing':
+                return
         }
         if (buildContext !== null) {
-            const prev = buildContext
+            const disposing = buildContext.dispose()
             buildContext = 'disposing'
-            prev.dispose().then(() => {
+            disposing.then(() => {
                 buildContext = null
                 resetBuildContext()
             })
         } else {
-            startEsbuildWatch(collectEntrypoints()).then(ctx => {
-                if (buildContext === 'dirty') {
-                    buildContext = null
-                    resetBuildContext()
-                } else {
-                    buildContext = ctx
-                }
-            })
+            buildContext = 'starting'
+            startEsbuildWatch(c, registry, serve, collectEntrypoints()).then(
+                ctx => {
+                    if (buildContext === 'dirty') {
+                        buildContext = 'disposing'
+                        ctx.dispose().then(() => {
+                            buildContext = null
+                            resetBuildContext()
+                        })
+                    } else {
+                        buildContext = ctx
+                    }
+                },
+            )
         }
     }
 
-    buildContext = await startEsbuildWatch(collectEntrypoints())
-    const frontend = createDevServeFilesFetcher({
-        pages: c.pages,
-        pagesDir: watchDir,
-        proxyPort: ESBUILD_PORT,
-        publicDir: 'public',
-    })
-    createWebServer(PORT, frontend).listen(PORT)
-    console.log(`dev server is live at http://127.0.0.1:${PORT}`)
-    startDevServices(c, signal)
+    // function removePartialFromPage(partial: string, urlPath: string) {
+    //     const deleteIndex = urlPathsByPartials[partial].indexOf(urlPath)
+    //     if (deleteIndex !== -1) {
+    //         if (urlPathsByPartials[partial].length === 1) {
+    //             delete urlPathsByPartials[partial]
+    //         } else {
+    //             urlPathsByPartials[partial].splice(deleteIndex, 1)
+    //         }
+    //     }
+    // }
+
+    // inital start of esbuild ctx
+    resetBuildContext()
+
+    // todo this page route state could be built on change and reused
+    const pageRoutes: PageRouteState = {
+        get urls(): Array<string> {
+            return Object.keys(c.pages)
+        },
+        get urlRewrites(): Array<UrlRewrite> {
+            return collectUrlRewrites(c)
+        },
+    }
+    const frontend = createDevServeFilesFetcher(pageRoutes, serve)
+    const devServices = startDevServices(c, signal)
+    startWebServer(serve, frontend, devServices.http, pageRoutes)
 }
 
-function hasSameValues(a: Set<string>, b: Set<string>): boolean {
+function matchingEntrypoints(a: Set<string>, b: Set<string>): boolean {
     if (a.size !== b.size) {
         return false
     }
@@ -198,73 +291,41 @@ function hasSameValues(a: Set<string>, b: Set<string>): boolean {
     return true
 }
 
-type WebpageInputs = {
-    clientJS: string
-    outDir: string
-    pagesDir: string
-    srcPath: string
-    urlPath: string
-}
-
-type WebpageMetadata = {
-    entryPoints: Array<{ in: string; out: string }>
-    srcPath: string
-    urlPath: string
-}
-
-async function processWebpage(inputs: WebpageInputs): Promise<WebpageMetadata> {
-    const html = await HtmlEntrypoint.readFrom(
-        inputs.urlPath,
-        join(inputs.pagesDir, inputs.srcPath),
-    )
-    await html.injectPartials()
-    if (inputs.urlPath !== '/') {
-        await mkdir(join(inputs.outDir, inputs.urlPath), { recursive: true })
-    }
-    const entryPoints: Array<{ in: string; out: string }> = []
-    html.collectScripts().forEach(scriptImport => {
-        entryPoints.push({
-            in: scriptImport.in,
-            out: scriptImport.out,
-        })
-    })
-    html.rewriteHrefs()
-    html.appendScript(inputs.clientJS)
-    await html.writeTo(inputs.outDir)
-    return {
-        entryPoints,
-        srcPath: inputs.srcPath,
-        urlPath: inputs.urlPath,
-    }
-}
-
 async function startEsbuildWatch(
-    entryPoints: Array<{ in: string; out: string }>,
+    c: DankConfig,
+    registry: WebsiteRegistry,
+    serve: DankServe,
+    entryPoints: Array<EntryPoint>,
 ): Promise<BuildContext> {
     const ctx = await esbuildDevContext(
-        createGlobalDefinitions(),
+        serve,
+        registry,
+        createGlobalDefinitions(serve),
         entryPoints,
-        'build/watch',
+        c.esbuild,
     )
 
     await ctx.watch()
 
     await ctx.serve({
         host: '127.0.0.1',
-        port: ESBUILD_PORT,
+        port: serve.esbuildPort,
         cors: {
-            origin: 'http://127.0.0.1:' + PORT,
+            origin: ['127.0.0.1', 'localhost'].map(
+                hostname => `http://${hostname}:${serve.dankPort}`,
+            ),
         },
     })
 
     return ctx
 }
 
-async function loadClientJS() {
-    return await readFile(
+async function loadClientJS(esbuildPort: number) {
+    const clientJS = await readFile(
         resolve(import.meta.dirname, join('..', 'client', 'esbuild.js')),
         'utf-8',
     )
+    return clientJS.replace('3995', `${esbuildPort}`)
 }
 
 async function watch(

package/lib/services.ts

@@ -2,6 +2,16 @@ import { type ChildProcess, spawn } from 'node:child_process'
 import { basename, isAbsolute, resolve } from 'node:path'
 import type { DankConfig, DevService } from './dank.ts'
 
+export type DevServices = {
+    http: HttpServices
+}
+
+export type HttpServices = {
+    running: Array<HttpService>
+}
+
+export type HttpService = NonNullable<DevService['http']>
+
 // up to date representation of dank.config.ts services
 const running: Array<{ s: DevService; process: ChildProcess | null }> = []
 
@@ -13,13 +23,23 @@ let updating: null | {
     starting: Array<DevService>
 } = null
 
-export function startDevServices(c: DankConfig, _signal: AbortSignal) {
+export function startDevServices(
+    c: DankConfig,
+    _signal: AbortSignal,
+): DevServices {
     signal = _signal
     if (c.services?.length) {
         for (const s of c.services) {
             running.push({ s, process: startService(s) })
         }
     }
+    return {
+        http: {
+            get running(): Array<NonNullable<DevService['http']>> {
+                return running.map(({ s }) => s.http).filter(http => !!http)
+            },
+        },
+    }
 }
 
 export function updateDevServices(c: DankConfig) {
@@ -138,9 +158,13 @@ function startService(s: DevService): ChildProcess {
     spawned.stderr.on('data', chunk => printChunk(stderrLabel, chunk))
 
     spawned.on('error', e => {
-        const cause =
-            'code' in e && e.code === 'ENOENT' ? 'program not found' : e.message
-        opPrint(s, 'error: ' + cause)
+        if (e.name !== 'AbortError') {
+            const cause =
+                'code' in e && e.code === 'ENOENT'
+                    ? 'program not found'
+                    : e.message
+            opPrint(s, 'error: ' + cause)
+        }
         removeFromRunning(s)
     })
 

package/lib_js/build.js

@@ -1,70 +1,95 @@
-import { mkdir, rm } from 'node:fs/promises';
+import { mkdir, readFile, rm, writeFile } from 'node:fs/promises';
 import { join } from 'node:path';
-import { isProductionBuild, willMinify } from "./flags.js";
-import { copyAssets } from "./public.js";
-import { createBuildTag } from "./tag.js";
-import { writeBuildManifest, writeMetafile } from "./manifest.js";
+import { createBuildTag } from "./build_tag.js";
 import { createGlobalDefinitions } from "./define.js";
+import { esbuildWebpages, esbuildWorkers } from "./esbuild.js";
+import { resolveBuildFlags } from "./flags.js";
 import { HtmlEntrypoint } from "./html.js";
-import { esbuildWebpages } from "./esbuild.js";
-export async function buildWebsite(c) {
-    const buildDir = 'build';
-    const distDir = join(buildDir, 'dist');
-    const buildTag = await createBuildTag();
-    console.log(willMinify()
-        ? isProductionBuild()
+import { WebsiteRegistry } from "./metadata.js";
+import { copyAssets } from "./public.js";
+export async function buildWebsite(c, build = resolveBuildFlags()) {
+    const buildTag = await createBuildTag(build);
+    console.log(build.minify
+        ? build.production
             ? 'minified production'
             : 'minified'
         : 'unminified', 'build', buildTag, 'building in ./build/dist');
-    await rm(buildDir, { recursive: true, force: true });
-    await mkdir(distDir, { recursive: true });
-    await mkdir(join(buildDir, 'metafiles'), { recursive: true });
-    const staticAssets = await copyAssets(distDir);
-    const buildUrls = [];
-    buildUrls.push(...(await buildWebpages(distDir, createGlobalDefinitions(), c.pages)));
-    if (staticAssets) {
-        buildUrls.push(...staticAssets);
+    await rm(build.dirs.buildRoot, { recursive: true, force: true });
+    await mkdir(build.dirs.buildDist, { recursive: true });
+    for (const subdir of Object.keys(c.pages).filter(url => url !== '/')) {
+        await mkdir(join(build.dirs.buildDist, subdir), { recursive: true });
     }
-    const result = new Set(buildUrls);
-    await writeBuildManifest(buildTag, result);
-    return {
-        dir: distDir,
-        files: result,
-    };
+    await mkdir(join(build.dirs.buildRoot, 'metafiles'), { recursive: true });
+    const registry = new WebsiteRegistry(build);
+    registry.pageUrls = Object.keys(c.pages);
+    registry.copiedAssets = await copyAssets(build);
+    await buildWebpages(c, registry, build, createGlobalDefinitions(build));
+    return await registry.writeManifest(buildTag);
 }
-async function buildWebpages(distDir, define, pages) {
-    const entryPointUrls = new Set();
-    const entryPoints = [];
-    const htmlEntrypoints = await Promise.all(Object.entries(pages).map(async ([urlPath, fsPath]) => {
-        const html = await HtmlEntrypoint.readFrom(urlPath, join('pages', fsPath));
-        await html.injectPartials();
-        if (urlPath !== '/') {
-            await mkdir(join(distDir, urlPath), { recursive: true });
+// builds all webpage entrypoints in one esbuild.build context
+// to support code splitting
+// returns all built assets URLs and webpage URLs from DankConfig.pages
+async function buildWebpages(c, registry, build, define) {
+    // create HtmlEntrypoint for each webpage and collect awaitable esbuild entrypoints
+    const loadingEntryPoints = [];
+    const htmlEntrypoints = [];
+    for (const [urlPath, mapping] of Object.entries(c.pages)) {
+        const fsPath = typeof mapping === 'string' ? mapping : mapping.webpage;
+        const html = new HtmlEntrypoint(build, registry.resolver, urlPath, fsPath);
+        loadingEntryPoints.push(new Promise(res => html.on('entrypoints', res)));
+        htmlEntrypoints.push(html);
+    }
+    // collect esbuild entrypoints from every HtmlEntrypoint
+    const uniqueEntryPoints = new Set();
+    const buildEntryPoints = [];
+    for (const pageEntryPoints of await Promise.all(loadingEntryPoints)) {
+        for (const entryPoint of pageEntryPoints) {
+            if (!uniqueEntryPoints.has(entryPoint.in)) {
+                buildEntryPoints.push(entryPoint);
+            }
         }
-        html.collectScripts()
-            .filter(scriptImport => !entryPointUrls.has(scriptImport.in))
-            .forEach(scriptImport => {
-            entryPointUrls.add(scriptImport.in);
-            entryPoints.push({
-                in: scriptImport.in,
-                out: scriptImport.out,
-            });
-        });
-        return html;
-    }));
-    const metafile = await esbuildWebpages(define, entryPoints, distDir);
-    await writeMetafile(`pages.json`, metafile);
-    // todo these hrefs would have \ path separators on windows
-    const buildUrls = [...Object.keys(pages)];
-    const mapInToOutHrefs = {};
-    for (const [outputFile, { entryPoint }] of Object.entries(metafile.outputs)) {
-        const outputUrl = outputFile.replace(/^build\/dist/, '');
-        buildUrls.push(outputUrl);
-        mapInToOutHrefs[entryPoint] = outputUrl;
     }
+    await esbuildWebpages(build, registry, define, buildEntryPoints, c.esbuild);
+    // todo recursively build workers on building workers that create workers
+    const workerEntryPoints = registry.workerEntryPoints();
+    if (workerEntryPoints?.length) {
+        await esbuildWorkers(build, registry, define, workerEntryPoints, c.esbuild);
+    }
+    await rewriteWorkerUrls(build, registry);
+    // write out html output with rewritten hrefs
     await Promise.all(htmlEntrypoints.map(async (html) => {
-        html.rewriteHrefs(mapInToOutHrefs);
-        await html.writeTo(distDir);
+        await writeFile(join(build.dirs.buildDist, html.url, 'index.html'), html.output(registry));
+    }));
+}
+export async function rewriteWorkerUrls(build, registry) {
+    const workers = registry.workers();
+    if (!workers) {
+        return;
+    }
+    const dependentBundlePaths = workers.map(w => registry.mappedHref(w.dependentEntryPoint));
+    const bundleOutputs = {};
+    // collect all js file contents concurrently
+    const readingFiles = Promise.all(dependentBundlePaths.map(async (p) => {
+        bundleOutputs[p] = await readFile(join(build.dirs.projectRootAbs, build.dirs.buildDist, p), 'utf8');
+    }));
+    // build regex replacements during file reads
+    const rewriteChains = {};
+    for (const p of dependentBundlePaths)
+        rewriteChains[p] = [];
+    for (const w of workers) {
+        rewriteChains[registry.mappedHref(w.dependentEntryPoint)].push(s => s.replace(createWorkerRegex(w.workerUrlPlaceholder), `new Worker('${registry.mappedHref(w.workerEntryPoint)}')`));
+    }
+    // wait for file reads
+    await readingFiles;
+    // run rewrite regex chain and write back to dist
+    await Promise.all(Object.entries(bundleOutputs).map(async ([p, content]) => {
+        let result = content;
+        for (const rewriteFn of rewriteChains[p]) {
+            result = rewriteFn(result);
+        }
+        await writeFile(join(build.dirs.projectRootAbs, build.dirs.buildDist, p), result);
     }));
-    return buildUrls;
+}
+export function createWorkerRegex(workerUrl) {
+    return new RegExp(`new(?:\\s|\\r?\\n)+Worker(?:\\s|\\r?\\n)*\\((?:\\s|\\r?\\n)*['"]${workerUrl}['"](?:\\s|\\r?\\n)*\\)`, 'g');
 }