@utoo/pack 1.1.3 → 1.1.4

package/esm/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/esm/core/types.js

@@ -0,0 +1 @@
+export {};

package/esm/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/esm/plugins/HtmlPlugin.js

@@ -0,0 +1,109 @@
+import { DOMParser } from "domparser-rs";
+import fs from "fs";
+import path from "path";
+export class HtmlPlugin {
+    constructor(config) {
+        this.config = config;
+    }
+    async generate(outputDir, assets, globalPublicPath) {
+        const templatePath = this.config.template
+            ? path.resolve(process.cwd(), this.config.template)
+            : undefined;
+        const publicPath = globalPublicPath || "";
+        let htmlContent = "";
+        if (this.config.templateContent) {
+            htmlContent = this.config.templateContent;
+        }
+        else if (templatePath && fs.existsSync(templatePath)) {
+            htmlContent = fs.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();
+        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.writeFileSync(path.join(outputDir, filename), finalHtml);
+    }
+}

package/esm/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/esm/utils/common.js

@@ -0,0 +1,18 @@
+import path from "path";
+export { createDefineEnv, debounce, isWellKnownError, ModuleBuildError, processIssues, rustifyEnv, } from "@utoo/pack-shared";
+// ref:
+// https://github.com/vercel/next.js/pull/51883
+export 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);
+    }
+}
+export function getPackPath() {
+    return path.resolve(__dirname, "..");
+}

package/esm/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/esm/utils/find-root.js

@@ -0,0 +1,66 @@
+import findUp from "find-up";
+import { readFileSync } from "fs";
+import { dirname } from "path";
+export function findRootLockFile(cwd) {
+    return findUp.sync([
+        "pnpm-lock.yaml",
+        "package-lock.json",
+        "yarn.lock",
+        "bun.lock",
+        "bun.lockb",
+    ], {
+        cwd,
+    });
+}
+// compatible with tnpm
+export function findPackageJson(cwd) {
+    return findUp.sync(["package.json"], {
+        cwd,
+    });
+}
+function isWorkspaceRoot(pkgPath) {
+    const pkgJson = 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 使用一套方法
+export function findWorkspacesRoot(cwd) {
+    const pkgJson = findPackageJson(cwd);
+    if (!pkgJson)
+        return cwd;
+    const pkgJsonFiles = [pkgJson];
+    while (true) {
+        const lastPkgJson = pkgJsonFiles[pkgJsonFiles.length - 1];
+        const currentDir = dirname(lastPkgJson);
+        const parentDir = dirname(currentDir);
+        if (parentDir === currentDir)
+            break;
+        if (isWorkspaceRoot(lastPkgJson))
+            break;
+        const newPkgJson = findPackageJson(parentDir);
+        if (!newPkgJson)
+            break;
+        pkgJsonFiles.push(newPkgJson);
+    }
+    return dirname(pkgJsonFiles[pkgJsonFiles.length - 1]);
+}
+export 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 = dirname(lastLockFile);
+        const parentDir = 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 dirname(lockFiles[lockFiles.length - 1]);
+}

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

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

package/esm/utils/html-entry.js

@@ -0,0 +1,41 @@
+import { DOMParser } from "domparser-rs";
+import fs from "fs";
+import path from "path";
+export function processHtmlEntry(config, projectPath) {
+    if (!config.entry)
+        return;
+    const newEntries = [];
+    config.entry = config.entry.filter((entry) => {
+        if (entry.import.endsWith(".html")) {
+            const htmlPath = path.resolve(projectPath, entry.import);
+            if (fs.existsSync(htmlPath)) {
+                const content = fs.readFileSync(htmlPath, "utf-8");
+                const parser = new 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.join(path.dirname(entry.import), src);
+                        newEntries.push({
+                            import: scriptPath,
+                            html: {
+                                template: entry.import,
+                                templateContent: doc.outerHTML,
+                                filename: path.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);
+}

package/esm/utils/mkcert.d.ts

@@ -0,0 +1,7 @@
+export interface SelfSignedCertificate {
+    key: string;
+    cert: string;
+    rootCA?: string;
+}
+export declare function createSelfSignedCertificate(host?: string, certDir?: string): Promise<SelfSignedCertificate | undefined>;
+export declare function getCacheDirectory(fileDirectory: string, envPath?: string): string;

package/esm/utils/mkcert.js

@@ -0,0 +1,176 @@
+import { execSync } from "node:child_process";
+import { createPrivateKey, X509Certificate } from "node:crypto";
+import fs from "node:fs";
+import path from "node:path";
+import os from "os";
+const { WritableStream } = require("node:stream/web");
+const MKCERT_VERSION = "v1.4.4";
+function getBinaryName() {
+    const platform = process.platform;
+    const arch = process.arch === "x64" ? "amd64" : process.arch;
+    if (platform === "win32") {
+        return `mkcert-${MKCERT_VERSION}-windows-${arch}.exe`;
+    }
+    if (platform === "darwin") {
+        return `mkcert-${MKCERT_VERSION}-darwin-${arch}`;
+    }
+    if (platform === "linux") {
+        return `mkcert-${MKCERT_VERSION}-linux-${arch}`;
+    }
+    throw new Error(`Unsupported platform: ${platform}`);
+}
+async function downloadBinary() {
+    try {
+        const binaryName = getBinaryName();
+        const cacheDirectory = getCacheDirectory("mkcert");
+        const binaryPath = path.join(cacheDirectory, binaryName);
+        if (fs.existsSync(binaryPath)) {
+            return binaryPath;
+        }
+        const downloadUrl = `https://github.com/FiloSottile/mkcert/releases/download/${MKCERT_VERSION}/${binaryName}`;
+        await fs.promises.mkdir(cacheDirectory, { recursive: true });
+        console.log(`Downloading mkcert package...`);
+        const response = await fetch(downloadUrl);
+        if (!response.ok || !response.body) {
+            throw new Error(`request failed with status ${response.status}`);
+        }
+        console.log(`Download response was successful, writing to disk`);
+        const binaryWriteStream = fs.createWriteStream(binaryPath);
+        await response.body.pipeTo(new WritableStream({
+            write(chunk) {
+                return new Promise((resolve, reject) => {
+                    binaryWriteStream.write(chunk, (error) => {
+                        if (error) {
+                            reject(error);
+                            return;
+                        }
+                        resolve();
+                    });
+                });
+            },
+            close() {
+                return new Promise((resolve, reject) => {
+                    binaryWriteStream.close((error) => {
+                        if (error) {
+                            reject(error);
+                            return;
+                        }
+                        resolve();
+                    });
+                });
+            },
+        }));
+        await fs.promises.chmod(binaryPath, 0o755);
+        return binaryPath;
+    }
+    catch (err) {
+        console.error("Error downloading mkcert:", err);
+    }
+}
+export async function createSelfSignedCertificate(host, certDir = "certificates") {
+    try {
+        const binaryPath = await downloadBinary();
+        if (!binaryPath)
+            throw new Error("missing mkcert binary");
+        const resolvedCertDir = path.resolve(process.cwd(), `./${certDir}`);
+        await fs.promises.mkdir(resolvedCertDir, {
+            recursive: true,
+        });
+        const keyPath = path.resolve(resolvedCertDir, "localhost-key.pem");
+        const certPath = path.resolve(resolvedCertDir, "localhost.pem");
+        if (fs.existsSync(keyPath) && fs.existsSync(certPath)) {
+            const cert = new X509Certificate(fs.readFileSync(certPath));
+            const key = fs.readFileSync(keyPath);
+            if (cert.checkHost(host !== null && host !== void 0 ? host : "localhost") &&
+                cert.checkPrivateKey(createPrivateKey(key))) {
+                console.log("Using already generated self signed certificate");
+                const caLocation = execSync(`"${binaryPath}" -CAROOT`)
+                    .toString()
+                    .trim();
+                return {
+                    key: keyPath,
+                    cert: certPath,
+                    rootCA: `${caLocation}/rootCA.pem`,
+                };
+            }
+        }
+        console.log("Attempting to generate self signed certificate. This may prompt for your password");
+        const defaultHosts = ["localhost", "127.0.0.1", "::1"];
+        const hosts = host && !defaultHosts.includes(host)
+            ? [...defaultHosts, host]
+            : defaultHosts;
+        execSync(`"${binaryPath}" -install -key-file "${keyPath}" -cert-file "${certPath}" ${hosts.join(" ")}`, { stdio: "ignore" });
+        const caLocation = execSync(`"${binaryPath}" -CAROOT`).toString().trim();
+        if (!fs.existsSync(keyPath) || !fs.existsSync(certPath)) {
+            throw new Error("Certificate files not found");
+        }
+        console.log(`CA Root certificate created in ${caLocation}`);
+        console.log(`Certificates created in ${resolvedCertDir}`);
+        const gitignorePath = path.resolve(process.cwd(), "./.gitignore");
+        if (fs.existsSync(gitignorePath)) {
+            const gitignore = await fs.promises.readFile(gitignorePath, "utf8");
+            if (!gitignore.includes(certDir)) {
+                console.log("Adding certificates to .gitignore");
+                await fs.promises.appendFile(gitignorePath, `\n${certDir}`);
+            }
+        }
+        return {
+            key: keyPath,
+            cert: certPath,
+            rootCA: `${caLocation}/rootCA.pem`,
+        };
+    }
+    catch (err) {
+        console.error("Failed to generate self-signed certificate. Falling back to http.", err);
+    }
+}
+// get platform specific cache directory adapted from playwright's handling
+// https://github.com/microsoft/playwright/blob/7d924470d397975a74a19184c136b3573a974e13/packages/playwright-core/src/utils/registry.ts#L141
+export function getCacheDirectory(fileDirectory, envPath) {
+    let result;
+    if (envPath) {
+        result = envPath;
+    }
+    else {
+        let systemCacheDirectory;
+        if (process.platform === "linux") {
+            systemCacheDirectory =
+                process.env.XDG_CACHE_HOME || path.join(os.homedir(), ".cache");
+        }
+        else if (process.platform === "darwin") {
+            systemCacheDirectory = path.join(os.homedir(), "Library", "Caches");
+        }
+        else if (process.platform === "win32") {
+            systemCacheDirectory =
+                process.env.LOCALAPPDATA || path.join(os.homedir(), "AppData", "Local");
+        }
+        else {
+            /// Attempt to use generic tmp location for un-handled platform
+            if (!systemCacheDirectory) {
+                for (const dir of [
+                    path.join(os.homedir(), ".cache"),
+                    path.join(os.tmpdir()),
+                ]) {
+                    if (fs.existsSync(dir)) {
+                        systemCacheDirectory = dir;
+                        break;
+                    }
+                }
+            }
+            if (!systemCacheDirectory) {
+                console.error(new Error("Unsupported platform: " + process.platform));
+                process.exit(0);
+            }
+        }
+        result = path.join(systemCacheDirectory, fileDirectory);
+    }
+    if (!path.isAbsolute(result)) {
+        // It is important to resolve to the absolute path:
+        //   - for unzipping to work correctly;
+        //   - so that registry directory matches between installation and execution.
+        // INIT_CWD points to the root of `npm/yarn install` and is probably what
+        // the user meant when typing the relative path.
+        result = path.resolve(process.env["INIT_CWD"] || process.cwd(), result);
+    }
+    return result;
+}

package/esm/utils/print-server-info.d.ts

@@ -0,0 +1 @@
+export declare function printServerInfo(protocol: "http" | "https", hostname: string, port: number): void;

package/esm/utils/print-server-info.js

@@ -0,0 +1,44 @@
+import os from "os";
+import pc from "picocolors";
+export function printServerInfo(protocol, hostname, port) {
+    const localUrl = `${protocol}://localhost:${port}`;
+    const networkAddress = getNetworkAddress();
+    const networkUrl = networkAddress
+        ? `${protocol}://${networkAddress}:${port}`
+        : null;
+    console.log();
+    console.log(pc.green("  ┌──────────────────────────────────────────────────┐"));
+    console.log(pc.green("  │                                                  │"));
+    console.log(pc.green("  │   ") +
+        pc.bold("Serving!") +
+        pc.green("                                       │"));
+    console.log(pc.green("  │                                                  │"));
+    const localLabel = "  │   - Local:    ";
+    const localPadding = 50 - 15 - localUrl.length; // 15 is "   - Local:    ".length
+    console.log(pc.green(localLabel) +
+        pc.cyan(localUrl) +
+        pc.green(" ".repeat(Math.max(0, localPadding)) + "│"));
+    if (networkUrl) {
+        const netLabel = "  │   - Network:  ";
+        const netPadding = 50 - 17 - networkUrl.length; // 17 is "   - Network:  ".length
+        console.log(pc.green(netLabel) +
+            pc.cyan(networkUrl) +
+            pc.green(" ".repeat(Math.max(0, netPadding)) + "│"));
+    }
+    console.log(pc.green("  │                                                  │"));
+    console.log(pc.green("  │   Copied local address to clipboard!             │"));
+    console.log(pc.green("  │                                                  │"));
+    console.log(pc.green("  └──────────────────────────────────────────────────┘"));
+    console.log();
+}
+function getNetworkAddress() {
+    const interfaces = os.networkInterfaces();
+    for (const name of Object.keys(interfaces)) {
+        for (const iface of interfaces[name]) {
+            if (iface.family === "IPv4" && !iface.internal) {
+                return iface.address;
+            }
+        }
+    }
+    return undefined;
+}

package/esm/utils/xcodeProfile.d.ts

@@ -0,0 +1 @@
+export declare function xcodeProfilingReady(): Promise<void>;

package/esm/utils/xcodeProfile.js

@@ -0,0 +1,13 @@
+export async function xcodeProfilingReady() {
+    await new Promise((resolve) => {
+        const readline = require("readline");
+        const rl = readline.createInterface({
+            input: process.stdin,
+            output: process.stdout,
+        });
+        rl.question(`Xcode profile enabled. Current process ${process.title} (${process.pid}) . Press Enter to continue...\n`, () => {
+            rl.close();
+            resolve();
+        });
+    });
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@utoo/pack",
-  "version": "1.1.3",
+  "version": "1.1.4",
   "main": "cjs/index.js",
   "module": "esm/index.js",
   "types": "esm/index.d.ts",
@@ -16,11 +16,9 @@
     "./package.json": "./package.json"
   },
   "files": [
-    "./cjs/*.js",
-    "./cjs/*.d.ts",
-    "./esm/*.js",
-    "./esm/*.d.ts",
-    "./config_schema.json"
+    "cjs",
+    "esm",
+    "config_schema.json"
   ],
   "napi": {
     "name": "pack",
@@ -84,18 +82,18 @@
     "build:binding": "napi build src --platform --release -p pack-napi --cargo-cwd ../../ --cargo-name pack_napi --features plugin --js binding.js --dts binding.d.ts",
     "build:binding:local": "napi build src --platform --profile release-local -p pack-napi --cargo-cwd ../../ --cargo-name pack_napi --features plugin --js binding.js --dts binding.d.ts",
     "clean": "rm -rf cjs esm",
-    "prepublishOnly": "turbo run build:js --filter=@utoo/pack && napi prepublish -t npm --skip-gh-release",
+    "prepublishOnly": "npm run build:js && napi prepublish -t npm --skip-gh-release",
     "version": "napi version",
     "generate-features-list": "node ./scripts/generate-feature-list.js"
   },
   "repository": "git@github.com:utooland/utoo.git",
   "optionalDependencies": {
-    "@utoo/pack-darwin-arm64": "1.1.3",
-    "@utoo/pack-darwin-x64": "1.1.3",
-    "@utoo/pack-linux-arm64-gnu": "1.1.3",
-    "@utoo/pack-linux-arm64-musl": "1.1.3",
-    "@utoo/pack-linux-x64-gnu": "1.1.3",
-    "@utoo/pack-linux-x64-musl": "1.1.3",
-    "@utoo/pack-win32-x64-msvc": "1.1.3"
+    "@utoo/pack-darwin-arm64": "1.1.4",
+    "@utoo/pack-darwin-x64": "1.1.4",
+    "@utoo/pack-linux-arm64-gnu": "1.1.4",
+    "@utoo/pack-linux-arm64-musl": "1.1.4",
+    "@utoo/pack-linux-x64-gnu": "1.1.4",
+    "@utoo/pack-linux-x64-musl": "1.1.4",
+    "@utoo/pack-win32-x64-msvc": "1.1.4"
   }
 }