@utoo/pack 1.1.3 → 1.1.4

package/cjs/core/project.js

@@ -0,0 +1,291 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TurbopackInternalError = void 0;
+exports.projectFactory = projectFactory;
+const util_1 = require("util");
+const binding = __importStar(require("../binding"));
+const common_1 = require("../utils/common");
+const loaderWorkerPool_1 = require("./loaderWorkerPool");
+class TurbopackInternalError extends Error {
+    constructor(cause) {
+        super(cause.message);
+        this.name = "TurbopackInternalError";
+        this.stack = cause.stack;
+    }
+}
+exports.TurbopackInternalError = TurbopackInternalError;
+async function withErrorCause(fn) {
+    try {
+        return await fn();
+    }
+    catch (nativeError) {
+        throw new TurbopackInternalError(nativeError);
+    }
+}
+function ensureLoadersHaveSerializableOptions(turbopackRules) {
+    for (const [glob, rule] of Object.entries(turbopackRules)) {
+        if (Array.isArray(rule)) {
+            checkLoaderItems(rule, glob);
+        }
+        else {
+            checkConfigItem(rule, glob);
+        }
+    }
+    function checkConfigItem(rule, glob) {
+        if (!rule)
+            return;
+        if ("loaders" in rule) {
+            checkLoaderItems(rule.loaders, glob);
+        }
+        else {
+            for (const key in rule) {
+                const inner = rule[key];
+                if (typeof inner === "object" && inner) {
+                    checkConfigItem(inner, glob);
+                }
+            }
+        }
+    }
+    function checkLoaderItems(loaderItems, glob) {
+        for (const loaderItem of loaderItems) {
+            if (typeof loaderItem !== "string" &&
+                !(0, util_1.isDeepStrictEqual)(loaderItem, JSON.parse(JSON.stringify(loaderItem)))) {
+                throw new Error(`loader ${loaderItem.loader} for match "${glob}" does not have serializable options. Ensure that options passed are plain JavaScript objects and values.`);
+            }
+        }
+    }
+}
+async function serializeConfig(config) {
+    var _a;
+    const configSerializable = { ...config };
+    if (configSerializable.entry) {
+        configSerializable.entry = configSerializable.entry.map((entry) => {
+            const { html, ...rest } = entry;
+            return rest;
+        });
+    }
+    if ((_a = configSerializable.module) === null || _a === void 0 ? void 0 : _a.rules) {
+        ensureLoadersHaveSerializableOptions(configSerializable.module.rules);
+    }
+    if (configSerializable.optimization) {
+        configSerializable.optimization = { ...configSerializable.optimization };
+        const { modularizeImports } = configSerializable.optimization;
+        if (modularizeImports) {
+            configSerializable.optimization.modularizeImports = Object.fromEntries(Object.entries(modularizeImports).map(([mod, config]) => [
+                mod,
+                {
+                    ...config,
+                    transform: typeof config.transform === "string"
+                        ? config.transform
+                        : Object.entries(config.transform).map(([key, value]) => [
+                            key,
+                            value,
+                        ]),
+                },
+            ]));
+        }
+    }
+    return JSON.stringify(configSerializable, null, 2);
+}
+async function rustifyPartialProjectOptions(options) {
+    return {
+        ...options,
+        config: options.config && (await serializeConfig(options.config)),
+        processEnv: options.processEnv && (0, common_1.rustifyEnv)(options.processEnv),
+    };
+}
+async function rustifyProjectOptions(options) {
+    var _a;
+    return {
+        ...options,
+        config: await serializeConfig(options.config),
+        processEnv: (0, common_1.rustifyEnv)((_a = options.processEnv) !== null && _a !== void 0 ? _a : {}),
+    };
+}
+function projectFactory() {
+    const cancel = new (class Cancel extends Error {
+    })();
+    function subscribe(useBuffer, nativeFunction) {
+        // A buffer of produced items. This will only contain values if the
+        // consumer is slower than the producer.
+        let buffer = [];
+        // A deferred value waiting for the next produced item. This will only
+        // exist if the consumer is faster than the producer.
+        let waiting;
+        let canceled = false;
+        // The native function will call this every time it emits a new result. We
+        // either need to notify a waiting consumer, or buffer the new result until
+        // the consumer catches up.
+        function emitResult(err, value) {
+            if (waiting) {
+                let { resolve, reject } = waiting;
+                waiting = undefined;
+                if (err)
+                    reject(err);
+                else
+                    resolve(value);
+            }
+            else {
+                const item = { err, value };
+                if (useBuffer)
+                    buffer.push(item);
+                else
+                    buffer[0] = item;
+            }
+        }
+        async function* createIterator() {
+            const task = await withErrorCause(() => nativeFunction(emitResult));
+            try {
+                while (!canceled) {
+                    if (buffer.length > 0) {
+                        const item = buffer.shift();
+                        if (item.err)
+                            throw item.err;
+                        yield item.value;
+                    }
+                    else {
+                        // eslint-disable-next-line no-loop-func
+                        yield new Promise((resolve, reject) => {
+                            waiting = { resolve, reject };
+                        });
+                    }
+                }
+            }
+            catch (e) {
+                if (e === cancel)
+                    return;
+                if (e instanceof Error) {
+                    throw new TurbopackInternalError(e);
+                }
+                throw e;
+            }
+            finally {
+                if (task) {
+                    binding.rootTaskDispose(task);
+                }
+            }
+        }
+        const iterator = createIterator();
+        iterator.return = async () => {
+            canceled = true;
+            if (waiting)
+                waiting.reject(cancel);
+            return { value: undefined, done: true };
+        };
+        return iterator;
+    }
+    class ProjectImpl {
+        constructor(nativeProject) {
+            this._nativeProject = nativeProject;
+            if (typeof binding.registerWorkerScheduler === "function") {
+                (0, loaderWorkerPool_1.runLoaderWorkerPool)(binding, require.resolve("@utoo/pack/cjs/binding.js"));
+            }
+        }
+        async update(options) {
+            await withErrorCause(async () => binding.projectUpdate(this._nativeProject, await rustifyPartialProjectOptions(options)));
+        }
+        async writeAllEntrypointsToDisk() {
+            return await withErrorCause(async () => {
+                const napiEndpoints = (await binding.projectWriteAllEntrypointsToDisk(this._nativeProject));
+                return napiEntrypointsToRawEntrypoints(napiEndpoints);
+            });
+        }
+        entrypointsSubscribe() {
+            const subscription = subscribe(false, async (callback) => binding.projectEntrypointsSubscribe(this._nativeProject, callback));
+            return (async function* () {
+                for await (const entrypoints of subscription) {
+                    yield napiEntrypointsToRawEntrypoints(entrypoints);
+                }
+            })();
+        }
+        hmrEvents(identifier) {
+            return subscribe(true, async (callback) => binding.projectHmrEvents(this._nativeProject, identifier, callback));
+        }
+        hmrIdentifiersSubscribe() {
+            return subscribe(false, async (callback) => binding.projectHmrIdentifiersSubscribe(this._nativeProject, callback));
+        }
+        traceSource(stackFrame, currentDirectoryFileUrl) {
+            return binding.projectTraceSource(this._nativeProject, stackFrame, currentDirectoryFileUrl);
+        }
+        getSourceForAsset(filePath) {
+            return binding.projectGetSourceForAsset(this._nativeProject, filePath);
+        }
+        getSourceMap(filePath) {
+            return binding.projectGetSourceMap(this._nativeProject, filePath);
+        }
+        getSourceMapSync(filePath) {
+            return binding.projectGetSourceMapSync(this._nativeProject, filePath);
+        }
+        updateInfoSubscribe(aggregationMs) {
+            return subscribe(true, async (callback) => binding.projectUpdateInfoSubscribe(this._nativeProject, aggregationMs, callback));
+        }
+        shutdown() {
+            return binding.projectShutdown(this._nativeProject);
+        }
+        onExit() {
+            return binding.projectOnExit(this._nativeProject);
+        }
+    }
+    class EndpointImpl {
+        constructor(nativeEndpoint) {
+            this._nativeEndpoint = nativeEndpoint;
+        }
+        async writeToDisk() {
+            return await withErrorCause(() => binding.endpointWriteToDisk(this._nativeEndpoint));
+        }
+        async clientChanged() {
+            const clientSubscription = subscribe(false, async (callback) => binding.endpointClientChangedSubscribe(await this._nativeEndpoint, callback));
+            await clientSubscription.next();
+            return clientSubscription;
+        }
+        async serverChanged(includeIssues) {
+            const serverSubscription = subscribe(false, async (callback) => binding.endpointServerChangedSubscribe(await this._nativeEndpoint, includeIssues, callback));
+            await serverSubscription.next();
+            return serverSubscription;
+        }
+    }
+    function napiEntrypointsToRawEntrypoints(entrypoints) {
+        return {
+            apps: (entrypoints.apps || []).map((e) => new EndpointImpl(e)),
+            libraries: (entrypoints.libraries || []).map((e) => new EndpointImpl(e)),
+            issues: entrypoints.issues,
+            diagnostics: entrypoints.diagnostics,
+        };
+    }
+    return async function createProject(options, turboEngineOptions) {
+        return new ProjectImpl(await binding.projectNew(await rustifyProjectOptions(options), turboEngineOptions || {}));
+    };
+}

package/cjs/core/types.d.ts

@@ -0,0 +1,94 @@
+import { HmrIdentifiers, NapiDiagnostic, NapiIssue, NapiUpdateMessage, NapiWrittenEndpoint, StackFrame } from "../binding";
+import { BundleOptions } from "../config/types";
+declare global {
+    export type TurbopackResult<T = {}> = T & {
+        issues: NapiIssue[];
+        diagnostics: NapiDiagnostic[];
+    };
+    export type RefCell = {
+        readonly __tag: unique symbol;
+    };
+    export type ExternalEndpoint = {
+        readonly __tag: unique symbol;
+    };
+    export type RcStr = string;
+}
+export interface BaseUpdate {
+    resource: {
+        headers: unknown;
+        path: string;
+    };
+    diagnostics: unknown[];
+    issues: NapiIssue[];
+}
+export interface IssuesUpdate extends BaseUpdate {
+    type: "issues";
+}
+export interface EcmascriptMergedUpdate {
+    type: "EcmascriptMergedUpdate";
+    chunks: {
+        [moduleName: string]: {
+            type: "partial";
+        };
+    };
+    entries: {
+        [moduleName: string]: {
+            code: string;
+            map: string;
+            url: string;
+        };
+    };
+}
+export interface PartialUpdate extends BaseUpdate {
+    type: "partial";
+    instruction: {
+        type: "ChunkListUpdate";
+        merged: EcmascriptMergedUpdate[] | undefined;
+    };
+}
+export type Update = IssuesUpdate | PartialUpdate;
+export interface ProjectOptions extends BundleOptions {
+    /**
+     * A root path from which all files must be nested under. Trying to access
+     * a file outside this root will fail. Think of this as a chroot.
+     */
+    rootPath: string;
+    /**
+     * A path inside the root_path which contains the app/pages directories.
+     */
+    projectPath: string;
+}
+export { BundleOptions };
+export interface Project {
+    update(options: Partial<ProjectOptions>): Promise<void>;
+    entrypointsSubscribe(): AsyncIterableIterator<TurbopackResult<RawEntrypoints>>;
+    hmrEvents(identifier: string): AsyncIterableIterator<TurbopackResult<Update>>;
+    hmrIdentifiersSubscribe(): AsyncIterableIterator<TurbopackResult<HmrIdentifiers>>;
+    getSourceForAsset(filePath: string): Promise<string | null>;
+    getSourceMap(filePath: string): Promise<string | null>;
+    getSourceMapSync(filePath: string): string | null;
+    traceSource(stackFrame: StackFrame, currentDirectoryFileUrl: string): Promise<StackFrame | null>;
+    updateInfoSubscribe(aggregationMs: number): AsyncIterableIterator<TurbopackResult<NapiUpdateMessage>>;
+    shutdown(): Promise<void>;
+    onExit(): Promise<void>;
+}
+export interface RawEntrypoints {
+    apps?: Endpoint[];
+    libraries?: Endpoint[];
+}
+export interface Endpoint {
+    /** Write files for the endpoint to disk. */
+    writeToDisk(): Promise<TurbopackResult<NapiWrittenEndpoint>>;
+    /**
+     * Listen to client-side changes to the endpoint.
+     * After clientChanged() has been awaited it will listen to changes.
+     * The async iterator will yield for each change.
+     */
+    clientChanged(): Promise<AsyncIterableIterator<TurbopackResult>>;
+    /**
+     * Listen to server-side changes to the endpoint.
+     * After serverChanged() has been awaited it will listen to changes.
+     * The async iterator will yield for each change.
+     */
+    serverChanged(includeIssues: boolean): Promise<AsyncIterableIterator<TurbopackResult>>;
+}

package/cjs/core/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/cjs/plugins/HtmlPlugin.d.ts

@@ -0,0 +1,9 @@
+import { HtmlConfig } from "../config/types";
+export declare class HtmlPlugin {
+    private config;
+    constructor(config: HtmlConfig);
+    generate(outputDir: string, assets: {
+        js: string[];
+        css: string[];
+    }, globalPublicPath?: string): Promise<void>;
+}

package/cjs/plugins/HtmlPlugin.js

@@ -0,0 +1,116 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HtmlPlugin = void 0;
+const domparser_rs_1 = require("domparser-rs");
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+class HtmlPlugin {
+    constructor(config) {
+        this.config = config;
+    }
+    async generate(outputDir, assets, globalPublicPath) {
+        const templatePath = this.config.template
+            ? path_1.default.resolve(process.cwd(), this.config.template)
+            : undefined;
+        const publicPath = globalPublicPath || "";
+        let htmlContent = "";
+        if (this.config.templateContent) {
+            htmlContent = this.config.templateContent;
+        }
+        else if (templatePath && fs_1.default.existsSync(templatePath)) {
+            htmlContent = fs_1.default.readFileSync(templatePath, "utf-8");
+        }
+        else {
+            htmlContent = `<!DOCTYPE html>
+<html>
+  <head>
+    <meta charset="utf-8">
+    <title>${this.config.title || "Utoo App"}</title>
+  </head>
+  <body>
+    <div id="root"></div>
+  </body>
+</html>`;
+        }
+        const parser = new domparser_rs_1.DOMParser();
+        const doc = parser.parseFromString(htmlContent, "text/html");
+        if (this.config.title) {
+            const title = doc.querySelector("title");
+            if (title) {
+                title.textContent = this.config.title;
+            }
+            else {
+                const head = doc.querySelector("head");
+                if (head) {
+                    const titleNode = doc.createElement("title");
+                    titleNode.textContent = this.config.title;
+                    head.appendChild(titleNode);
+                }
+            }
+        }
+        // Inject meta
+        if (this.config.meta) {
+            const head = doc.querySelector("head");
+            if (head) {
+                Object.entries(this.config.meta).forEach(([name, value]) => {
+                    const meta = doc.createElement("meta");
+                    if (typeof value === "string") {
+                        meta.setAttribute("name", name);
+                        meta.setAttribute("content", value);
+                    }
+                    else {
+                        Object.entries(value).forEach(([k, v]) => {
+                            meta.setAttribute(k, v);
+                        });
+                    }
+                    head.appendChild(meta);
+                });
+            }
+        }
+        const head = doc.querySelector("head");
+        const body = doc.querySelector("body");
+        // Inject CSS
+        assets.css.forEach((cssFile) => {
+            const link = doc.createElement("link");
+            link.setAttribute("rel", "stylesheet");
+            link.setAttribute("href", publicPath
+                ? publicPath.endsWith("/")
+                    ? publicPath + cssFile
+                    : publicPath + "/" + cssFile
+                : cssFile);
+            if (head)
+                head.appendChild(link);
+        });
+        // Inject JS
+        assets.js.forEach((jsFile) => {
+            const script = doc.createElement("script");
+            script.setAttribute("src", publicPath
+                ? publicPath.endsWith("/")
+                    ? publicPath + jsFile
+                    : publicPath + "/" + jsFile
+                : jsFile);
+            if (this.config.scriptLoading === "defer") {
+                script.setAttribute("defer", "");
+            }
+            else if (this.config.scriptLoading === "module") {
+                script.setAttribute("type", "module");
+            }
+            if (this.config.inject === "head" && head) {
+                head.appendChild(script);
+            }
+            else if (body) {
+                body.appendChild(script);
+            }
+            else if (head) {
+                head.appendChild(script); // Fallback
+            }
+        });
+        const finalHtml = doc.outerHTML;
+        const filename = this.config.filename || "index.html";
+        fs_1.default.writeFileSync(path_1.default.join(outputDir, filename), finalHtml);
+    }
+}
+exports.HtmlPlugin = HtmlPlugin;

package/cjs/utils/common.d.ts

@@ -0,0 +1,3 @@
+export { createDefineEnv, debounce, isWellKnownError, ModuleBuildError, processIssues, rustifyEnv, } from "@utoo/pack-shared";
+export declare function blockStdout(): void;
+export declare function getPackPath(): string;

package/cjs/utils/common.js

@@ -0,0 +1,32 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.rustifyEnv = exports.processIssues = exports.ModuleBuildError = exports.isWellKnownError = exports.debounce = exports.createDefineEnv = void 0;
+exports.blockStdout = blockStdout;
+exports.getPackPath = getPackPath;
+const path_1 = __importDefault(require("path"));
+var pack_shared_1 = require("@utoo/pack-shared");
+Object.defineProperty(exports, "createDefineEnv", { enumerable: true, get: function () { return pack_shared_1.createDefineEnv; } });
+Object.defineProperty(exports, "debounce", { enumerable: true, get: function () { return pack_shared_1.debounce; } });
+Object.defineProperty(exports, "isWellKnownError", { enumerable: true, get: function () { return pack_shared_1.isWellKnownError; } });
+Object.defineProperty(exports, "ModuleBuildError", { enumerable: true, get: function () { return pack_shared_1.ModuleBuildError; } });
+Object.defineProperty(exports, "processIssues", { enumerable: true, get: function () { return pack_shared_1.processIssues; } });
+Object.defineProperty(exports, "rustifyEnv", { enumerable: true, get: function () { return pack_shared_1.rustifyEnv; } });
+// ref:
+// https://github.com/vercel/next.js/pull/51883
+function blockStdout() {
+    // rust needs stdout to be blocking, otherwise it will throw an error (on macOS at least) when writing a lot of data (logs) to it
+    // see https://github.com/napi-rs/napi-rs/issues/1630
+    // and https://github.com/nodejs/node/blob/main/doc/api/process.md#a-note-on-process-io
+    if (process.stdout._handle != null) {
+        process.stdout._handle.setBlocking(true);
+    }
+    if (process.stderr._handle != null) {
+        process.stderr._handle.setBlocking(true);
+    }
+}
+function getPackPath() {
+    return path_1.default.resolve(__dirname, "..");
+}

package/cjs/utils/find-root.d.ts

@@ -0,0 +1,4 @@
+export declare function findRootLockFile(cwd: string): string | undefined;
+export declare function findPackageJson(cwd: string): string | undefined;
+export declare function findWorkspacesRoot(cwd: string): string;
+export declare function findRootDir(cwd: string): string;

package/cjs/utils/find-root.js

@@ -0,0 +1,75 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findRootLockFile = findRootLockFile;
+exports.findPackageJson = findPackageJson;
+exports.findWorkspacesRoot = findWorkspacesRoot;
+exports.findRootDir = findRootDir;
+const find_up_1 = __importDefault(require("find-up"));
+const fs_1 = require("fs");
+const path_1 = require("path");
+function findRootLockFile(cwd) {
+    return find_up_1.default.sync([
+        "pnpm-lock.yaml",
+        "package-lock.json",
+        "yarn.lock",
+        "bun.lock",
+        "bun.lockb",
+    ], {
+        cwd,
+    });
+}
+// compatible with tnpm
+function findPackageJson(cwd) {
+    return find_up_1.default.sync(["package.json"], {
+        cwd,
+    });
+}
+function isWorkspaceRoot(pkgPath) {
+    const pkgJson = (0, fs_1.readFileSync)(pkgPath, "utf-8");
+    const pkgJsonContent = JSON.parse(pkgJson);
+    return Boolean(pkgJsonContent.workspaces);
+}
+// refer from: https://github.com/umijs/mako/blob/next/crates/pm/src/helper/workspace.rs#L153
+// TODO: 这块逻辑后续跟 utoo-pkg 使用一套方法
+function findWorkspacesRoot(cwd) {
+    const pkgJson = findPackageJson(cwd);
+    if (!pkgJson)
+        return cwd;
+    const pkgJsonFiles = [pkgJson];
+    while (true) {
+        const lastPkgJson = pkgJsonFiles[pkgJsonFiles.length - 1];
+        const currentDir = (0, path_1.dirname)(lastPkgJson);
+        const parentDir = (0, path_1.dirname)(currentDir);
+        if (parentDir === currentDir)
+            break;
+        if (isWorkspaceRoot(lastPkgJson))
+            break;
+        const newPkgJson = findPackageJson(parentDir);
+        if (!newPkgJson)
+            break;
+        pkgJsonFiles.push(newPkgJson);
+    }
+    return (0, path_1.dirname)(pkgJsonFiles[pkgJsonFiles.length - 1]);
+}
+function findRootDir(cwd) {
+    const lockFile = findRootLockFile(cwd);
+    if (!lockFile)
+        return findWorkspacesRoot(cwd);
+    const lockFiles = [lockFile];
+    while (true) {
+        const lastLockFile = lockFiles[lockFiles.length - 1];
+        const currentDir = (0, path_1.dirname)(lastLockFile);
+        const parentDir = (0, path_1.dirname)(currentDir);
+        // dirname('/')==='/' so if we happen to reach the FS root (as might happen in a container we need to quit to avoid looping forever
+        if (parentDir === currentDir)
+            break;
+        const newLockFile = findRootLockFile(parentDir);
+        if (!newLockFile)
+            break;
+        lockFiles.push(newLockFile);
+    }
+    return (0, path_1.dirname)(lockFiles[lockFiles.length - 1]);
+}

package/cjs/utils/html-entry.d.ts

@@ -0,0 +1,2 @@
+import { ConfigComplete } from "../config/types";
+export declare function processHtmlEntry(config: ConfigComplete, projectPath: string): void;

package/cjs/utils/html-entry.js

@@ -0,0 +1,47 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.processHtmlEntry = processHtmlEntry;
+const domparser_rs_1 = require("domparser-rs");
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+function processHtmlEntry(config, projectPath) {
+    if (!config.entry)
+        return;
+    const newEntries = [];
+    config.entry = config.entry.filter((entry) => {
+        if (entry.import.endsWith(".html")) {
+            const htmlPath = path_1.default.resolve(projectPath, entry.import);
+            if (fs_1.default.existsSync(htmlPath)) {
+                const content = fs_1.default.readFileSync(htmlPath, "utf-8");
+                const parser = new domparser_rs_1.DOMParser();
+                const doc = parser.parseFromString(content, "text/html");
+                const scripts = doc.querySelectorAll("script");
+                scripts.forEach((script) => {
+                    const src = script.getAttribute("src");
+                    if (src && !src.startsWith("http") && !src.startsWith("//")) {
+                        const scriptPath = path_1.default.join(path_1.default.dirname(entry.import), src);
+                        newEntries.push({
+                            import: scriptPath,
+                            html: {
+                                template: entry.import,
+                                templateContent: doc.outerHTML,
+                                filename: path_1.default.basename(entry.import),
+                            },
+                        });
+                        // Remove the script tag from the DOM
+                        if (script.parentNode) {
+                            script.parentNode.removeChild(script);
+                        }
+                    }
+                });
+                return false;
+            }
+        }
+        return true;
+    });
+    // Add new script entries
+    config.entry.push(...newEntries);
+}