ic-mops 0.37.0 → 0.37.2

package/dist/templates/cli.js

@@ -1,3660 +0,0 @@
-#!/usr/bin/env node
-// dist/cli.js
-import fs14 from "node:fs";
-import { program, Argument, Option } from "commander";
-import chalk29 from "chalk";
-import { Principal as Principal2 } from "@dfinity/principal";
-// dist/commands/init.js
-import { execSync } from "node:child_process";
-import path8 from "node:path";
-import { existsSync as existsSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "node:fs";
-import chalk7 from "chalk";
-import prompts3 from "prompts";
-// dist/mops.js
-import path from "node:path";
-import fs2 from "node:fs";
-import TOML from "@iarna/toml";
-import chalk from "chalk";
-import prompts from "prompts";
-import ncp from "ncp";
-import fetch2 from "node-fetch";
-// dist/pem.js
-import fs from "node:fs";
-import { Ed25519KeyIdentity } from "@dfinity/identity";
-import { Secp256k1KeyIdentity } from "@dfinity/identity-secp256k1";
-import pemfile from "pem-file";
-import crypto from "crypto";
-function decodeFile(file, password) {
-    let rawKey = fs.readFileSync(file);
-    if (password) {
-        return decode(decrypt(rawKey, password));
-    }
-    return decode(rawKey);
-}
-function decode(rawKey) {
-    let buf = pemfile.decode(rawKey);
-    if (rawKey.includes("EC PRIVATE KEY")) {
-        if (buf.length != 118) {
-            throw "expecting byte length 118 but got " + buf.length;
-        }
-        return Secp256k1KeyIdentity.fromSecretKey(buf.subarray(7, 39));
-    }
-    if (buf.length != 85) {
-        throw "expecting byte length 85 but got " + buf.length;
-    }
-    let secretKey = Buffer.concat([buf.subarray(16, 48), buf.subarray(53, 85)]);
-    return Ed25519KeyIdentity.fromSecretKey(secretKey);
-}
-var algorithm = "aes-256-ctr";
-function encrypt(buffer, password) {
-    let key = crypto.createHash("sha256").update(password).digest("base64").slice(0, 32);
-    let iv = crypto.randomBytes(16);
-    let cipher = crypto.createCipheriv(algorithm, key, iv);
-    let result = Buffer.concat([iv, cipher.update(buffer), cipher.final()]);
-    return result;
-}
-function decrypt(encrypted, password) {
-    let key = crypto.createHash("sha256").update(password).digest("base64").slice(0, 32);
-    let iv = encrypted.subarray(0, 16);
-    encrypted = encrypted.subarray(16);
-    let decipher = crypto.createDecipheriv(algorithm, key, iv);
-    let result = Buffer.concat([decipher.update(encrypted), decipher.final()]);
-    return result;
-}
-// dist/api/actors.js
-import { Actor as Actor3, HttpAgent as HttpAgent3 } from "@dfinity/agent";
-// dist/declarations/main/index.js
-import { Actor, HttpAgent } from "@dfinity/agent";
-// dist/declarations/main/main.did.js
-var idlFactory = ({ IDL }) => {
-    const TestsChanges = IDL.Record({
-        "addedNames": IDL.Vec(IDL.Text),
-        "removedNames": IDL.Vec(IDL.Text)
-    });
-    const DepChange = IDL.Record({
-        "oldVersion": IDL.Text,
-        "name": IDL.Text,
-        "newVersion": IDL.Text
-    });
-    const PackageChanges__1 = IDL.Record({
-        "tests": TestsChanges,
-        "deps": IDL.Vec(DepChange),
-        "notes": IDL.Text,
-        "devDeps": IDL.Vec(DepChange)
-    });
-    const PublishingId = IDL.Text;
-    const Err = IDL.Text;
-    const Result = IDL.Variant({ "ok": IDL.Null, "err": Err });
-    const Text = IDL.Text;
-    const PackageName = IDL.Text;
-    const PackageVersion = IDL.Text;
-    const PackageId = IDL.Text;
-    const Time = IDL.Int;
-    const DownloadsSnapshot__1 = IDL.Record({
-        "startTime": Time,
-        "endTime": Time,
-        "downloads": IDL.Nat
-    });
-    const FileId = IDL.Text;
-    const Result_8 = IDL.Variant({
-        "ok": IDL.Vec(IDL.Tuple(FileId, IDL.Vec(IDL.Nat8))),
-        "err": Err
-    });
-    const Result_7 = IDL.Variant({ "ok": IDL.Vec(FileId), "err": Err });
-    const SemverPart = IDL.Variant({
-        "major": IDL.Null,
-        "minor": IDL.Null,
-        "patch": IDL.Null
-    });
-    const Result_6 = IDL.Variant({
-        "ok": IDL.Vec(IDL.Tuple(PackageName, PackageVersion)),
-        "err": Err
-    });
-    const Result_5 = IDL.Variant({ "ok": PackageVersion, "err": Err });
-    const User = IDL.Record({
-        "id": IDL.Principal,
-        "emailVerified": IDL.Bool,
-        "twitter": IDL.Text,
-        "displayName": IDL.Text,
-        "name": IDL.Text,
-        "site": IDL.Text,
-        "email": IDL.Text,
-        "twitterVerified": IDL.Bool,
-        "githubVerified": IDL.Bool,
-        "github": IDL.Text
-    });
-    const DepsStatus = IDL.Variant({
-        "allLatest": IDL.Null,
-        "tooOld": IDL.Null,
-        "updatesAvailable": IDL.Null
-    });
-    const PackageQuality = IDL.Record({
-        "depsStatus": DepsStatus,
-        "hasDescription": IDL.Bool,
-        "hasKeywords": IDL.Bool,
-        "hasLicense": IDL.Bool,
-        "hasDocumentation": IDL.Bool,
-        "hasTests": IDL.Bool,
-        "hasRepository": IDL.Bool,
-        "hasReleaseNotes": IDL.Bool
-    });
-    const Script = IDL.Record({ "value": IDL.Text, "name": IDL.Text });
-    const PackageName__1 = IDL.Text;
-    const DependencyV2 = IDL.Record({
-        "name": PackageName__1,
-        "repo": IDL.Text,
-        "version": IDL.Text
-    });
-    const PackageConfigV2__1 = IDL.Record({
-        "dfx": IDL.Text,
-        "moc": IDL.Text,
-        "scripts": IDL.Vec(Script),
-        "baseDir": IDL.Text,
-        "documentation": IDL.Text,
-        "name": PackageName__1,
-        "homepage": IDL.Text,
-        "description": IDL.Text,
-        "version": IDL.Text,
-        "keywords": IDL.Vec(IDL.Text),
-        "donation": IDL.Text,
-        "devDependencies": IDL.Vec(DependencyV2),
-        "repository": IDL.Text,
-        "dependencies": IDL.Vec(DependencyV2),
-        "license": IDL.Text,
-        "readme": IDL.Text
-    });
-    const PackagePublication = IDL.Record({
-        "storage": IDL.Principal,
-        "time": Time,
-        "user": IDL.Principal
-    });
-    const PackageSummary = IDL.Record({
-        "ownerInfo": User,
-        "owner": IDL.Principal,
-        "quality": PackageQuality,
-        "downloadsTotal": IDL.Nat,
-        "downloadsInLast30Days": IDL.Nat,
-        "downloadsInLast7Days": IDL.Nat,
-        "config": PackageConfigV2__1,
-        "publication": PackagePublication
-    });
-    const PackageSummary__1 = IDL.Record({
-        "ownerInfo": User,
-        "owner": IDL.Principal,
-        "quality": PackageQuality,
-        "downloadsTotal": IDL.Nat,
-        "downloadsInLast30Days": IDL.Nat,
-        "downloadsInLast7Days": IDL.Nat,
-        "config": PackageConfigV2__1,
-        "publication": PackagePublication
-    });
-    const TestStats__1 = IDL.Record({
-        "passedNames": IDL.Vec(IDL.Text),
-        "passed": IDL.Nat
-    });
-    const DownloadsSnapshot = IDL.Record({
-        "startTime": Time,
-        "endTime": Time,
-        "downloads": IDL.Nat
-    });
-    const PackageFileStatsPublic = IDL.Record({
-        "sourceFiles": IDL.Nat,
-        "sourceSize": IDL.Nat
-    });
-    const PackageChanges = IDL.Record({
-        "tests": TestsChanges,
-        "deps": IDL.Vec(DepChange),
-        "notes": IDL.Text,
-        "devDeps": IDL.Vec(DepChange)
-    });
-    const PackageSummaryWithChanges__1 = IDL.Record({
-        "ownerInfo": User,
-        "owner": IDL.Principal,
-        "quality": PackageQuality,
-        "downloadsTotal": IDL.Nat,
-        "downloadsInLast30Days": IDL.Nat,
-        "downloadsInLast7Days": IDL.Nat,
-        "config": PackageConfigV2__1,
-        "changes": PackageChanges,
-        "publication": PackagePublication
-    });
-    const PackageDetails = IDL.Record({
-        "ownerInfo": User,
-        "owner": IDL.Principal,
-        "deps": IDL.Vec(PackageSummary__1),
-        "quality": PackageQuality,
-        "testStats": TestStats__1,
-        "downloadsTotal": IDL.Nat,
-        "downloadsInLast30Days": IDL.Nat,
-        "downloadTrend": IDL.Vec(DownloadsSnapshot),
-        "fileStats": PackageFileStatsPublic,
-        "versionHistory": IDL.Vec(PackageSummaryWithChanges__1),
-        "dependents": IDL.Vec(PackageSummary__1),
-        "devDeps": IDL.Vec(PackageSummary__1),
-        "downloadsInLast7Days": IDL.Nat,
-        "config": PackageConfigV2__1,
-        "changes": PackageChanges,
-        "publication": PackagePublication
-    });
-    const Result_4 = IDL.Variant({ "ok": PackageDetails, "err": Err });
-    const PackageSummaryWithChanges = IDL.Record({
-        "ownerInfo": User,
-        "owner": IDL.Principal,
-        "quality": PackageQuality,
-        "downloadsTotal": IDL.Nat,
-        "downloadsInLast30Days": IDL.Nat,
-        "downloadsInLast7Days": IDL.Nat,
-        "config": PackageConfigV2__1,
-        "changes": PackageChanges,
-        "publication": PackagePublication
-    });
-    const StorageId = IDL.Principal;
-    const StorageStats = IDL.Record({
-        "fileCount": IDL.Nat,
-        "cyclesBalance": IDL.Nat,
-        "memorySize": IDL.Nat
-    });
-    const User__1 = IDL.Record({
-        "id": IDL.Principal,
-        "emailVerified": IDL.Bool,
-        "twitter": IDL.Text,
-        "displayName": IDL.Text,
-        "name": IDL.Text,
-        "site": IDL.Text,
-        "email": IDL.Text,
-        "twitterVerified": IDL.Bool,
-        "githubVerified": IDL.Bool,
-        "github": IDL.Text
-    });
-    const Header = IDL.Tuple(IDL.Text, IDL.Text);
-    const Request = IDL.Record({
-        "url": IDL.Text,
-        "method": IDL.Text,
-        "body": IDL.Vec(IDL.Nat8),
-        "headers": IDL.Vec(Header),
-        "certificate_version": IDL.Opt(IDL.Nat16)
-    });
-    const StreamingToken = IDL.Vec(IDL.Nat8);
-    const StreamingCallbackResponse = IDL.Record({
-        "token": IDL.Opt(StreamingToken),
-        "body": IDL.Vec(IDL.Nat8)
-    });
-    const StreamingCallback = IDL.Func([StreamingToken], [IDL.Opt(StreamingCallbackResponse)], ["query"]);
-    const StreamingStrategy = IDL.Variant({
-        "Callback": IDL.Record({
-            "token": StreamingToken,
-            "callback": StreamingCallback
-        })
-    });
-    const Response = IDL.Record({
-        "body": IDL.Vec(IDL.Nat8),
-        "headers": IDL.Vec(Header),
-        "upgrade": IDL.Opt(IDL.Bool),
-        "streaming_strategy": IDL.Opt(StreamingStrategy),
-        "status_code": IDL.Nat16
-    });
-    const PageCount = IDL.Nat;
-    const Result_1 = IDL.Variant({ "ok": IDL.Null, "err": IDL.Text });
-    const Result_3 = IDL.Variant({ "ok": FileId, "err": Err });
-    const PackageConfigV2 = IDL.Record({
-        "dfx": IDL.Text,
-        "moc": IDL.Text,
-        "scripts": IDL.Vec(Script),
-        "baseDir": IDL.Text,
-        "documentation": IDL.Text,
-        "name": PackageName__1,
-        "homepage": IDL.Text,
-        "description": IDL.Text,
-        "version": IDL.Text,
-        "keywords": IDL.Vec(IDL.Text),
-        "donation": IDL.Text,
-        "devDependencies": IDL.Vec(DependencyV2),
-        "repository": IDL.Text,
-        "dependencies": IDL.Vec(DependencyV2),
-        "license": IDL.Text,
-        "readme": IDL.Text
-    });
-    const PublishingErr = IDL.Text;
-    const Result_2 = IDL.Variant({ "ok": PublishingId, "err": PublishingErr });
-    const TestStats = IDL.Record({
-        "passedNames": IDL.Vec(IDL.Text),
-        "passed": IDL.Nat
-    });
-    return IDL.Service({
-        "backup": IDL.Func([], [], []),
-        "claimAirdrop": IDL.Func([IDL.Principal], [IDL.Text], []),
-        "computeHashesForExistingFiles": IDL.Func([], [], []),
-        "diff": IDL.Func([IDL.Text, IDL.Text], [PackageChanges__1], ["query"]),
-        "finishPublish": IDL.Func([PublishingId], [Result], []),
-        "getAirdropAmount": IDL.Func([], [IDL.Nat], ["query"]),
-        "getAirdropAmountAll": IDL.Func([], [IDL.Nat], ["query"]),
-        "getApiVersion": IDL.Func([], [Text], ["query"]),
-        "getBackupCanisterId": IDL.Func([], [IDL.Principal], ["query"]),
-        "getDefaultPackages": IDL.Func([IDL.Text], [IDL.Vec(IDL.Tuple(PackageName, PackageVersion))], ["query"]),
-        "getDownloadTrendByPackageId": IDL.Func([PackageId], [IDL.Vec(DownloadsSnapshot__1)], ["query"]),
-        "getDownloadTrendByPackageName": IDL.Func([PackageName], [IDL.Vec(DownloadsSnapshot__1)], ["query"]),
-        "getFileHashes": IDL.Func([PackageName, PackageVersion], [Result_8], []),
-        "getFileHashesByPackageIds": IDL.Func([IDL.Vec(PackageId)], [
-            IDL.Vec(IDL.Tuple(PackageId, IDL.Vec(IDL.Tuple(FileId, IDL.Vec(IDL.Nat8)))))
-        ], []),
-        "getFileIds": IDL.Func([PackageName, PackageVersion], [Result_7], ["query"]),
-        "getHighestSemverBatch": IDL.Func([IDL.Vec(IDL.Tuple(PackageName, PackageVersion, SemverPart))], [Result_6], ["query"]),
-        "getHighestVersion": IDL.Func([PackageName], [Result_5], ["query"]),
-        "getMostDownloadedPackages": IDL.Func([], [IDL.Vec(PackageSummary)], ["query"]),
-        "getMostDownloadedPackagesIn7Days": IDL.Func([], [IDL.Vec(PackageSummary)], ["query"]),
-        "getNewPackages": IDL.Func([], [IDL.Vec(PackageSummary)], ["query"]),
-        "getPackageDetails": IDL.Func([PackageName, PackageVersion], [Result_4], ["query"]),
-        "getPackagesByCategory": IDL.Func([], [IDL.Vec(IDL.Tuple(IDL.Text, IDL.Vec(PackageSummary)))], ["query"]),
-        "getRecentlyUpdatedPackages": IDL.Func([], [IDL.Vec(PackageSummaryWithChanges)], ["query"]),
-        "getStoragesStats": IDL.Func([], [IDL.Vec(IDL.Tuple(StorageId, StorageStats))], ["query"]),
-        "getTotalDownloads": IDL.Func([], [IDL.Nat], ["query"]),
-        "getTotalPackages": IDL.Func([], [IDL.Nat], ["query"]),
-        "getUser": IDL.Func([IDL.Principal], [IDL.Opt(User__1)], ["query"]),
-        "http_request": IDL.Func([Request], [Response], ["query"]),
-        "notifyInstall": IDL.Func([PackageName, PackageVersion], [], ["oneway"]),
-        "notifyInstalls": IDL.Func([IDL.Vec(IDL.Tuple(PackageName, PackageVersion))], [], ["oneway"]),
-        "restore": IDL.Func([IDL.Nat, IDL.Nat], [], []),
-        "search": IDL.Func([Text, IDL.Opt(IDL.Nat), IDL.Opt(IDL.Nat)], [IDL.Vec(PackageSummary), PageCount], ["query"]),
-        "setUserProp": IDL.Func([IDL.Text, IDL.Text], [Result_1], []),
-        "startFileUpload": IDL.Func([PublishingId, Text, IDL.Nat, IDL.Vec(IDL.Nat8)], [Result_3], []),
-        "startPublish": IDL.Func([PackageConfigV2], [Result_2], []),
-        "takeAirdropSnapshot": IDL.Func([], [], ["oneway"]),
-        "transferOwnership": IDL.Func([PackageName, IDL.Principal], [Result_1], []),
-        "uploadFileChunk": IDL.Func([PublishingId, FileId, IDL.Nat, IDL.Vec(IDL.Nat8)], [Result], []),
-        "uploadNotes": IDL.Func([PublishingId, IDL.Text], [Result], []),
-        "uploadTestStats": IDL.Func([PublishingId, TestStats], [Result], [])
-    });
-};
-// dist/declarations/main/index.js
-var canisterId = process.env.CANISTER_ID_MAIN || process.env.MAIN_CANISTER_ID;
-// dist/declarations/storage/index.js
-import { Actor as Actor2, HttpAgent as HttpAgent2 } from "@dfinity/agent";
-// dist/declarations/storage/storage.did.js
-var idlFactory2 = ({ IDL }) => {
-    const FileId = IDL.Text;
-    const Chunk = IDL.Vec(IDL.Nat8);
-    const Err = IDL.Text;
-    const Result_2 = IDL.Variant({ "ok": Chunk, "err": Err });
-    const FileId__1 = IDL.Text;
-    const FileMeta = IDL.Record({
-        "id": FileId__1,
-        "owners": IDL.Vec(IDL.Principal),
-        "path": IDL.Text,
-        "chunkCount": IDL.Nat
-    });
-    const Result_1 = IDL.Variant({ "ok": FileMeta, "err": Err });
-    const StorageStats = IDL.Record({
-        "fileCount": IDL.Nat,
-        "cyclesBalance": IDL.Nat,
-        "memorySize": IDL.Nat
-    });
-    const Result = IDL.Variant({ "ok": IDL.Null, "err": Err });
-    const Storage = IDL.Service({
-        "acceptCycles": IDL.Func([], [], []),
-        "deleteFile": IDL.Func([FileId], [], []),
-        "downloadChunk": IDL.Func([FileId, IDL.Nat], [Result_2], ["query"]),
-        "finishUpload": IDL.Func([FileId], [], []),
-        "getFileIdsRange": IDL.Func([IDL.Nat, IDL.Nat], [IDL.Vec(FileId)], ["query"]),
-        "getFileMeta": IDL.Func([FileId], [Result_1], ["query"]),
-        "getStats": IDL.Func([], [StorageStats], ["query"]),
-        "startUpload": IDL.Func([FileMeta], [Result], []),
-        "updateFileOwners": IDL.Func([FileId, IDL.Vec(IDL.Principal)], [], []),
-        "uploadChunk": IDL.Func([FileId, IDL.Nat, Chunk], [], [])
-    });
-    return Storage;
-};
-// dist/api/network.js
-function getNetwork() {
-    return globalThis.MOPS_NETWORK || "ic";
-}
-function getEndpoint(network) {
-    if (network === "staging") {
-        return {
-            host: "https://icp-api.io",
-            canisterId: "2d2zu-vaaaa-aaaak-qb6pq-cai"
-        };
-    }
-    else if (network === "ic") {
-        return {
-            host: "https://icp-api.io",
-            canisterId: "oknww-riaaa-aaaam-qaf6a-cai"
-        };
-    }
-    else {
-        return {
-            host: "http://127.0.0.1:4943",
-            canisterId: "2d2zu-vaaaa-aaaak-qb6pq-cai"
-        };
-    }
-}
-// dist/api/actors.js
-var mainActor = async (identity) => {
-    let network = getNetwork();
-    let host = getEndpoint(network).host;
-    let canisterId3 = getEndpoint(network).canisterId;
-    let agent = new HttpAgent3({ host, identity });
-    if (network === "local") {
-        await agent.fetchRootKey();
-    }
-    return Actor3.createActor(idlFactory, {
-        agent,
-        canisterId: canisterId3
-    });
-};
-var storageActor = async (storageId, identity) => {
-    let network = getNetwork();
-    let host = getEndpoint(network).host;
-    let agent = new HttpAgent3({ host, identity });
-    if (network === "local") {
-        await agent.fetchRootKey();
-    }
-    return Actor3.createActor(idlFactory2, {
-        agent,
-        canisterId: storageId
-    });
-};
-// dist/api/getHighestVersion.js
-async function getHighestVersion(pkgName) {
-    let actor = await mainActor();
-    return actor.getHighestVersion(pkgName);
-}
-// dist/mops.js
-if (!global.fetch) {
-    global.fetch = fetch2;
-}
-var apiVersion = "1.2";
-var globalConfigDir = "";
-var globalCacheDir = "";
-if (process.platform == "win32") {
-    globalConfigDir = path.join(process.env.LOCALAPPDATA || "", "mops/config");
-    globalCacheDir = path.join(process.env.LOCALAPPDATA || "", "mops/cache");
-}
-else if (process.platform == "darwin") {
-    globalConfigDir = path.join(process.env.HOME || "", "Library/Application Support/mops");
-    globalCacheDir = path.join(process.env.HOME || "", "Library/Caches/mops");
-}
-else {
-    globalConfigDir = path.join(process.env.HOME || "", ".config/mops");
-    globalCacheDir = path.join(process.env.HOME || "", ".cache/mops");
-}
-if (process.env.XDG_CONFIG_HOME) {
-    globalConfigDir = path.join(process.env.XDG_CONFIG_HOME, "mops");
-}
-if (process.env.XDG_CACHE_HOME) {
-    globalCacheDir = path.join(process.env.XDG_CACHE_HOME, "mops");
-}
-var oldGlobalConfigDir = path.resolve(process.env.HOME || process.env.APPDATA || "/", "mops");
-if (fs2.existsSync(oldGlobalConfigDir) && !fs2.existsSync(globalConfigDir)) {
-    fs2.mkdirSync(globalConfigDir, { recursive: true });
-    if (fs2.existsSync(path.join(oldGlobalConfigDir, "identity.pem"))) {
-        fs2.copyFileSync(path.join(oldGlobalConfigDir, "identity.pem"), path.join(globalConfigDir, "identity.pem"));
-    }
-    if (fs2.existsSync(path.join(oldGlobalConfigDir, "identity.pem.encrypted"))) {
-        fs2.copyFileSync(path.join(oldGlobalConfigDir, "identity.pem.encrypted"), path.join(globalConfigDir, "identity.pem.encrypted"));
-    }
-    console.log("Moved config to " + chalk.green(globalConfigDir));
-}
-if (fs2.existsSync(oldGlobalConfigDir) && !fs2.existsSync(globalCacheDir)) {
-    fs2.mkdirSync(globalCacheDir, { recursive: true });
-    ncp.ncp(path.join(oldGlobalConfigDir, "packages"), path.join(globalCacheDir, "packages"), {
-        stopOnErr: true,
-        clobber: false
-    }, (err) => {
-        if (err) {
-            console.log("Error moving config: ", err);
-            fs2.rmSync(globalCacheDir, { recursive: true, force: true });
-        }
-    });
-    console.log("Moved cache to " + chalk.green(globalCacheDir));
-}
-function getNetworkFile() {
-    let networkFile2 = "";
-    try {
-        networkFile2 = new URL("./network.txt", import.meta.url);
-    }
-    catch {
-        networkFile2 = path.join(__dirname, "network.txt");
-    }
-    return networkFile2;
-}
-function setNetwork(network) {
-    fs2.writeFileSync(getNetworkFile(), network);
-}
-var getIdentity = async () => {
-    let identityPem = path.resolve(globalConfigDir, "identity.pem");
-    let identityPemEncrypted = path.resolve(globalConfigDir, "identity.pem.encrypted");
-    if (fs2.existsSync(identityPemEncrypted)) {
-        let res = await prompts({
-            type: "invisible",
-            name: "value",
-            message: "Enter password:"
-        });
-        return await decodeFile(identityPemEncrypted, res.value);
-    }
-    if (fs2.existsSync(identityPem)) {
-        return decodeFile(identityPem);
-    }
-    return void 0;
-};
-function getClosestConfigFile(dir = process.cwd()) {
-    if (!path.basename(dir)) {
-        throw "";
-    }
-    let configFile = path.join(dir, "mops.toml");
-    if (fs2.existsSync(configFile)) {
-        return configFile;
-    }
-    return getClosestConfigFile(path.resolve(dir, ".."));
-}
-function getRootDir() {
-    let configFile = getClosestConfigFile();
-    if (!configFile) {
-        return "";
-    }
-    return path.dirname(configFile);
-}
-function checkConfigFile() {
-    let configFile = getClosestConfigFile();
-    if (!configFile) {
-        console.log(chalk.red("Error: ") + `Config file 'mops.toml' not found. Please run ${chalk.green("mops init")} first`);
-        return false;
-    }
-    return true;
-}
-function progressBar(step, total) {
-    let done = Math.round(step / total * 10);
-    return `[${":".repeat(done)}${" ".repeat(Math.max(0, 10 - done))}]`;
-}
-function parseGithubURL(href) {
-    var _a;
-    const url = new URL(href);
-    let branchAndSha = (_a = url.hash) == null ? void 0 : _a.substring(1).split("@");
-    let branch = branchAndSha[0] || "master";
-    let commitHash = branchAndSha[1] || "";
-    let [org, gitName] = url.pathname.split("/").filter((path18) => !!path18);
-    org = org || "";
-    gitName = gitName || "";
-    if (gitName == null ? void 0 : gitName.endsWith(".git")) {
-        gitName = gitName.substring(0, gitName.length - 4);
-    }
-    return { org, gitName, branch, commitHash };
-}
-async function getGithubCommit(repo, ref) {
-    let res = await fetch2(`https://api.github.com/repos/${repo}/commits/${ref}`);
-    let json = await res.json();
-    if (json.message && ref === "master") {
-        res = await fetch2(`https://api.github.com/repos/${repo}/commits/main`);
-        json = await res.json();
-    }
-    return json;
-}
-function getDependencyType(version) {
-    if (!version || typeof version !== "string") {
-        throw Error(`Invalid dependency value "${version}"`);
-    }
-    if (version.startsWith("https://github.com/")) {
-        return "github";
-    }
-    else if (version.match(/^(\.?\.)?\//)) {
-        return "local";
-    }
-    else {
-        return "mops";
-    }
-}
-function readConfig(configFile = getClosestConfigFile()) {
-    let text = fs2.readFileSync(configFile).toString();
-    let toml = TOML.parse(text);
-    let processDeps = (deps) => {
-        Object.entries(deps).forEach(([name, data]) => {
-            if (!data || typeof data !== "string") {
-                throw Error(`Invalid dependency value ${name} = "${data}"`);
-            }
-            let depType = getDependencyType(data);
-            if (depType === "github") {
-                deps[name] = { name, repo: data, version: "" };
-            }
-            else if (depType === "local") {
-                deps[name] = { name, repo: "", path: data, version: "" };
-            }
-            else {
-                deps[name] = { name, repo: "", version: data };
-            }
-        });
-    };
-    processDeps(toml.dependencies || {});
-    processDeps(toml["dev-dependencies"] || {});
-    return toml;
-}
-function writeConfig(config, configFile = getClosestConfigFile()) {
-    let resConfig = { ...config };
-    let deps = resConfig.dependencies || {};
-    Object.entries(config.dependencies || {}).forEach(([name, { repo, path: path18, version }]) => {
-        deps[name] = repo || path18 || version;
-    });
-    let devDeps = resConfig["dev-dependencies"] || {};
-    Object.entries(config["dev-dependencies"] || {}).forEach(([name, { repo, path: path18, version }]) => {
-        devDeps[name] = repo || path18 || version;
-    });
-    let text = TOML.stringify(resConfig).trim();
-    if (fs2.existsSync(configFile) && fs2.readFileSync(configFile).toString().endsWith("\n")) {
-        text += "\n";
-    }
-    fs2.writeFileSync(configFile, text);
-}
-function formatDir(name, version) {
-    return path.join(getRootDir(), ".mops", `${name}@${version}`);
-}
-function formatGithubDir(name, repo) {
-    const { branch, commitHash } = parseGithubURL(repo);
-    return path.join(getRootDir(), ".mops/_github", `${name}#${branch}` + (commitHash ? `@${commitHash}` : ""));
-}
-async function checkApiCompatibility() {
-    let actor = await mainActor();
-    let backendApiVer = await actor.getApiVersion();
-    if (backendApiVer.split(".")[0] !== apiVersion.split(".")[0]) {
-        console.log(chalk.red("ERR: ") + `CLI incompatible with backend. CLI v${apiVersion}, Backend v${backendApiVer}`);
-        console.log("Run " + chalk.greenBright("npm i -g ic-mops") + " to upgrade cli.");
-        return false;
-    }
-    else if (backendApiVer.split(".")[1] !== apiVersion.split(".")[1]) {
-        console.log("-".repeat(50));
-        console.log(chalk.yellow("WARN: ") + `CLI probably incompatible with backend. CLI v${apiVersion}, Backend v${backendApiVer}`);
-        console.log("Recommended to run " + chalk.greenBright("npm i -g ic-mops") + " to upgrade cli.");
-        console.log("-".repeat(50));
-    }
-    return true;
-}
-// dist/commands/install-all.js
-import chalk5 from "chalk";
-import logUpdate3 from "log-update";
-// dist/commands/install.js
-import path4 from "node:path";
-import fs4 from "node:fs";
-import logUpdate2 from "log-update";
-import chalk3 from "chalk";
-// dist/parallel.js
-async function parallel(threads, items, fn) {
-    return new Promise((resolve) => {
-        let busyThreads = 0;
-        items = items.slice();
-        let loop = () => {
-            if (!items.length) {
-                if (busyThreads === 0) {
-                    resolve();
-                }
-                return;
-            }
-            if (busyThreads >= threads) {
-                return;
-            }
-            busyThreads++;
-            fn(items.shift()).then(() => {
-                busyThreads--;
-                loop();
-            });
-            loop();
-        };
-        loop();
-    });
-}
-// dist/vessel.js
-import { existsSync, mkdirSync, createWriteStream, readFileSync, writeFileSync } from "node:fs";
-import path3 from "node:path";
-import { deleteSync } from "del";
-import { execaCommand } from "execa";
-import chalk2 from "chalk";
-import logUpdate from "log-update";
-import got from "got";
-import decompress from "decompress";
-import { pipeline } from "stream";
-// dist/cache.js
-import fs3 from "node:fs";
-import path2 from "node:path";
-import ncp2 from "ncp";
-import getFolderSize from "get-folder-size";
-var isCached = (pkgId) => {
-    let dir = path2.join(globalCacheDir, "packages", pkgId);
-    return fs3.existsSync(dir);
-};
-var addCache = (pkgId, source) => {
-    let dest = path2.join(globalCacheDir, "packages", pkgId);
-    fs3.mkdirSync(dest, { recursive: true });
-    return new Promise((resolve, reject) => {
-        ncp2.ncp(source, dest, { stopOnErr: true }, (err) => {
-            if (err) {
-                reject(err);
-            }
-            resolve();
-        });
-    });
-};
-var copyCache = (pkgId, dest) => {
-    let source = path2.join(globalCacheDir, "packages", pkgId);
-    fs3.mkdirSync(dest, { recursive: true });
-    return new Promise((resolve, reject) => {
-        ncp2.ncp(source, dest, { stopOnErr: true }, (err) => {
-            if (err) {
-                reject(err);
-            }
-            resolve();
-        });
-    });
-};
-var cacheSize = async () => {
-    let dir = path2.join(globalCacheDir, "packages");
-    fs3.mkdirSync(dir, { recursive: true });
-    let size = await getFolderSize.strict(dir);
-    if (size < 1024 * 1024) {
-        return (size / 1024).toFixed(2) + " KB";
-    }
-    return (size / 1024 / 1024).toFixed(2) + " MB";
-};
-var cleanCache = async () => {
-    let dir = path2.join(globalCacheDir, "packages");
-    fs3.rmSync(dir, { recursive: true, force: true });
-};
-// dist/vessel.js
-var dhallFileToJson = async (filePath, silent) => {
-    var _a;
-    if (existsSync(filePath)) {
-        let cwd = new URL(path3.dirname(import.meta.url)).pathname;
-        let res;
-        try {
-            res = await execaCommand(`dhall-to-json --file ${filePath}`, { preferLocal: true, cwd });
-        }
-        catch (err) {
-            silent || console.error("dhall-to-json error:", (_a = err.message) == null ? void 0 : _a.split("Message:")[0]);
-            return null;
-        }
-        if (res.exitCode === 0) {
-            return JSON.parse(res.stdout);
-        }
-        else {
-            return res;
-        }
-    }
-    return null;
-};
-var readVesselConfig = async (dir, { cache = true, silent = false } = {}) => {
-    const cachedFile = (dir || process.cwd()) + "/vessel.json";
-    if (existsSync(cachedFile)) {
-        let cachedConfig = readFileSync(cachedFile).toString();
-        return JSON.parse(cachedConfig);
-    }
-    const [vessel, packageSetArray] = await Promise.all([
-        dhallFileToJson((dir || process.cwd()) + "/vessel.dhall", silent),
-        dhallFileToJson((dir || process.cwd()) + "/package-set.dhall", silent)
-    ]);
-    if (!vessel || !packageSetArray) {
-        return null;
-    }
-    let repos = {};
-    for (const { name, repo, version } of packageSetArray) {
-        const { org, gitName } = parseGithubURL(repo);
-        repos[name] = `https://github.com/${org}/${gitName}#${version}`;
-    }
-    let config = {
-        dependencies: vessel.dependencies.map((name) => {
-            return { name, repo: repos[name], version: "" };
-        }),
-        "dev-dependencies": []
-    };
-    if (cache === true) {
-        writeFileSync(cachedFile, JSON.stringify(config), "utf-8");
-    }
-    return config;
-};
-var downloadFromGithub = async (repo, dest, onProgress) => {
-    const { branch, org, gitName, commitHash } = parseGithubURL(repo);
-    const zipFile = `https://github.com/${org}/${gitName}/archive/${commitHash || branch}.zip`;
-    const readStream = got.stream(zipFile);
-    const promise = new Promise((resolve, reject) => {
-        readStream.on("error", (err) => {
-            console.error(chalk2.red(`Error: failed to download from GitHub: ${zipFile}`));
-            console.error(err.message);
-            reject(err);
-        });
-        readStream.on("downloadProgress", ({ transferred, total }) => {
-            onProgress == null ? void 0 : onProgress(transferred, total || 2 * 1024 ** 2);
-        });
-        readStream.on("response", (response) => {
-            if (response.headers.age > 3600) {
-                console.error(chalk2.red("Error: ") + "Failure - response too old");
-                readStream.destroy();
-                reject();
-                return;
-            }
-            readStream.off("error", reject);
-            const tmpDir = path3.resolve(process.cwd(), ".mops/_tmp/");
-            const tmpFile = path3.resolve(tmpDir, `${gitName}@${commitHash || branch}.zip`);
-            try {
-                mkdirSync(tmpDir, { recursive: true });
-                pipeline(readStream, createWriteStream(tmpFile), (err) => {
-                    if (err) {
-                        deleteSync([tmpDir]);
-                        reject(err);
-                    }
-                    else {
-                        let options = {
-                            extract: true,
-                            strip: 1,
-                            headers: {
-                                accept: "application/zip"
-                            }
-                        };
-                        decompress(tmpFile, dest, options).then((unzippedFiles) => {
-                            deleteSync([tmpDir]);
-                            resolve(unzippedFiles);
-                        }).catch((err2) => {
-                            deleteSync([tmpDir]);
-                            reject(err2);
-                        });
-                    }
-                });
-            }
-            catch (err) {
-                deleteSync([tmpDir]);
-                reject(err);
-            }
-        });
-    });
-    return promise;
-};
-var installFromGithub = async (name, repo, { verbose = false, dep = false, silent = false } = {}) => {
-    let { branch, commitHash } = parseGithubURL(repo);
-    let dir = formatGithubDir(name, repo);
-    let cacheName = `_github/${name}#${branch}` + (commitHash ? `@${commitHash}` : "");
-    if (existsSync(dir)) {
-        silent || logUpdate(`${dep ? "Dependency" : "Installing"} ${repo} (local cache)`);
-    }
-    else if (isCached(cacheName)) {
-        await copyCache(cacheName, dir);
-        silent || logUpdate(`${dep ? "Dependency" : "Installing"} ${repo} (global cache)`);
-    }
-    else {
-        mkdirSync(dir, { recursive: true });
-        let progress = (step, total) => {
-            silent || logUpdate(`${dep ? "Dependency" : "Installing"} ${repo} ${progressBar(step, total)}`);
-        };
-        progress(0, 2 * 1024 ** 2);
-        try {
-            await downloadFromGithub(repo, dir, progress);
-        }
-        catch (err) {
-            deleteSync([dir]);
-            process.exit(1);
-        }
-        await addCache(cacheName, dir);
-    }
-    if (verbose) {
-        silent || logUpdate.done();
-    }
-    const config = await readVesselConfig(dir, { silent });
-    if (config) {
-        for (const { name: name2, repo: repo2 } of config.dependencies) {
-            if (repo2) {
-                await installFromGithub(name2, repo2, { verbose, silent, dep: true });
-            }
-        }
-    }
-};
-// dist/api/downloadPackageFiles.js
-async function getPackageFilesInfo(pkg, version) {
-    let actor = await mainActor();
-    let [packageDetailsRes, fileIds] = await Promise.all([
-        actor.getPackageDetails(pkg, version),
-        getFileIds(pkg, version)
-    ]);
-    if ("err" in packageDetailsRes) {
-        throw packageDetailsRes.err;
-    }
-    let packageDetails = packageDetailsRes.ok;
-    return {
-        storageId: packageDetails.publication.storage,
-        fileIds
-    };
-}
-async function getFileIds(pkg, version) {
-    let actor = await mainActor();
-    let fileIdsRes = await actor.getFileIds(pkg, version);
-    if ("err" in fileIdsRes) {
-        throw fileIdsRes.err;
-    }
-    let filesIds = fileIdsRes.ok;
-    return filesIds;
-}
-async function downloadFile(storage, fileId) {
-    let fileMetaRes = await storage.getFileMeta(fileId);
-    if ("err" in fileMetaRes) {
-        throw fileMetaRes.err;
-    }
-    let fileMeta = fileMetaRes.ok;
-    let data = [];
-    for (let i = 0n; i < fileMeta.chunkCount; i++) {
-        let chunkRes = await storage.downloadChunk(fileId, i);
-        if ("err" in chunkRes) {
-            throw chunkRes.err;
-        }
-        let chunk = chunkRes.ok;
-        data = [...data, ...chunk];
-    }
-    return {
-        path: fileMeta.path,
-        data
-    };
-}
-// dist/commands/install.js
-async function install(pkg, version = "", { verbose = false, silent = false, dep = false } = {}) {
-    if (!checkConfigFile()) {
-        return false;
-    }
-    let total = Infinity;
-    let step = 0;
-    let progress = () => {
-        step++;
-        silent || logUpdate2(`${dep ? "Dependency" : "Installing"} ${pkg}@${version} ${progressBar(step, total)}`);
-    };
-    progress();
-    if (!version) {
-        let versionRes = await getHighestVersion(pkg);
-        if ("err" in versionRes) {
-            console.log(chalk3.red("Error: ") + versionRes.err);
-            return false;
-        }
-        version = versionRes.ok;
-    }
-    let dir = formatDir(pkg, version);
-    let alreadyInstalled = false;
-    if (fs4.existsSync(dir)) {
-        silent || logUpdate2(`${dep ? "Dependency" : "Installing"} ${pkg}@${version} (local cache)`);
-        alreadyInstalled = true;
-    }
-    else if (isCached(`${pkg}@${version}`)) {
-        await copyCache(`${pkg}@${version}`, dir);
-        silent || logUpdate2(`${dep ? "Dependency" : "Installing"} ${pkg}@${version} (global cache)`);
-    }
-    else {
-        let threads = 16;
-        if (process.env.GITHUB_ENV) {
-            threads = 4;
-        }
-        try {
-            let { storageId, fileIds } = await getPackageFilesInfo(pkg, version);
-            total = fileIds.length + 2;
-            let filesData = /* @__PURE__ */ new Map();
-            let storage = await storageActor(storageId);
-            await parallel(threads, fileIds, async (fileId) => {
-                let { path: path18, data } = await downloadFile(storage, fileId);
-                filesData.set(path18, data);
-                progress();
-            });
-            for (let [filePath, data] of filesData.entries()) {
-                fs4.mkdirSync(path4.join(dir, path4.dirname(filePath)), { recursive: true });
-                fs4.writeFileSync(path4.join(dir, filePath), Buffer.from(data));
-            }
-        }
-        catch (err) {
-            console.error(chalk3.red("Error: ") + err);
-            return false;
-        }
-        await addCache(`${pkg}@${version}`, dir);
-        progress();
-    }
-    if (verbose) {
-        silent || logUpdate2.done();
-    }
-    let ok = true;
-    let config = readConfig(path4.join(dir, "mops.toml"));
-    let deps = Object.values(config.dependencies || {});
-    let installedDeps = {};
-    for (const { name, repo, version: version2 } of deps) {
-        if (repo) {
-            await installFromGithub(name, repo, { silent, verbose });
-        }
-        else {
-            let res = await install(name, version2, { silent, verbose });
-            if (res) {
-                installedDeps = { ...installedDeps, ...res };
-            }
-            else {
-                ok = false;
-            }
-        }
-    }
-    if (!alreadyInstalled) {
-        installedDeps = { ...installedDeps, [pkg]: version };
-    }
-    if (!ok) {
-        return false;
-    }
-    return installedDeps;
-}
-// dist/resolve-packages.js
-import path5 from "node:path";
-import chalk4 from "chalk";
-async function resolvePackages({ verbose = false } = {}) {
-    if (!checkConfigFile()) {
-        return {};
-    }
-    let packages = {};
-    let versions = {};
-    let compareVersions = (a = "0.0.0", b = "0.0.0") => {
-        let ap = a.split(".").map((x) => parseInt(x));
-        let bp = b.split(".").map((x) => parseInt(x));
-        if (ap[0] - bp[0]) {
-            return Math.sign(ap[0] - bp[0]);
-        }
-        if (ap[0] === bp[0] && ap[1] - bp[1]) {
-            return Math.sign(ap[1] - bp[1]);
-        }
-        if (ap[0] === bp[0] && ap[1] === bp[1] && ap[2] - bp[2]) {
-            return Math.sign(ap[2] - bp[2]);
-        }
-        return 0;
-    };
-    const gitVerRegex = new RegExp(/v(\d{1,2}\.\d{1,2}\.\d{1,2})(-.*)?$/);
-    const compareGitVersions = (repoA, repoB) => {
-        const { branch: a } = parseGithubURL(repoA);
-        const { branch: b } = parseGithubURL(repoB);
-        if (gitVerRegex.test(a) && gitVerRegex.test(b)) {
-            return compareVersions(a.substring(1), b.substring(1));
-        }
-        else if (!gitVerRegex.test(a)) {
-            return -1;
-        }
-        else {
-            return 1;
-        }
-    };
-    let collectDeps = async (config2, isRoot = false) => {
-        var _a, _b, _c, _d, _e, _f;
-        let allDeps = [...Object.values(config2.dependencies || {})];
-        if (isRoot) {
-            allDeps = [...allDeps, ...Object.values(config2["dev-dependencies"] || {})];
-        }
-        for (const pkgDetails of allDeps) {
-            const { name, repo, version } = pkgDetails;
-            if (isRoot || !packages[name] || !((_a = packages[name]) == null ? void 0 : _a.isRoot) && (repo && ((_b = packages[name]) == null ? void 0 : _b.repo) && compareGitVersions(((_c = packages[name]) == null ? void 0 : _c.repo) || "", repo) === -1 || compareVersions((_d = packages[name]) == null ? void 0 : _d.version, version) === -1)) {
-                packages[name] = {
-                    ...pkgDetails,
-                    isRoot
-                };
-            }
-            let nestedConfig;
-            if (repo) {
-                const dir = formatGithubDir(name, repo);
-                nestedConfig = await readVesselConfig(dir, { silent: true }) || {};
-            }
-            else if (!pkgDetails.path && version) {
-                const file = formatDir(name, version) + "/mops.toml";
-                nestedConfig = readConfig(file);
-            }
-            if (nestedConfig && !pkgDetails.path) {
-                await collectDeps(nestedConfig);
-            }
-            if (!versions[name]) {
-                versions[name] = [];
-            }
-            if (repo) {
-                const { branch } = parseGithubURL(repo);
-                (_e = versions[name]) == null ? void 0 : _e.push(branch);
-            }
-            else if (version) {
-                (_f = versions[name]) == null ? void 0 : _f.push(version);
-            }
-        }
-    };
-    let config = readConfig();
-    await collectDeps(config, true);
-    if (verbose) {
-        for (let [dep, vers] of Object.entries(versions)) {
-            if (vers.length > 1) {
-                console.log(chalk4.yellow("WARN:"), `Conflicting package versions "${dep}" - ${vers.join(", ")}`);
-            }
-        }
-    }
-    let rootDir = getRootDir();
-    return Object.fromEntries(Object.entries(packages).map(([name, pkg]) => {
-        let version;
-        if (pkg.path) {
-            version = path5.resolve(rootDir, pkg.path).replaceAll("{MOPS_ENV}", process.env.MOPS_ENV || "local");
-        }
-        else if (pkg.repo) {
-            version = pkg.repo;
-        }
-        else if (pkg.version) {
-            version = pkg.version;
-        }
-        else {
-            return [name, ""];
-        }
-        return [name, version];
-    }).filter(([, version]) => version !== ""));
-}
-// dist/notify-installs.js
-async function notifyInstalls(names) {
-    let resolvedPackages = await resolvePackages();
-    let packages = names.map((name) => [name, resolvedPackages[name]]);
-    if (packages.length) {
-        let actor = await mainActor();
-        await actor.notifyInstalls(packages.filter(([_, version]) => getDependencyType(version) === "mops"));
-    }
-}
-// dist/integrity.js
-import fs5 from "node:fs";
-import path6 from "node:path";
-import { sha256 } from "@noble/hashes/sha256";
-import { bytesToHex } from "@noble/hashes/utils";
-async function checkIntegrity(lock) {
-    let force = !!lock;
-    if (!lock && !process.env["CI"] && fs5.existsSync(path6.join(getRootDir(), "mops.lock"))) {
-        lock = "save";
-    }
-    if (!lock) {
-        lock = process.env["CI"] ? "check" : "ignore";
-    }
-    if (lock === "save") {
-        await saveLockFile();
-        await checkLockFile(force);
-    }
-    else if (lock === "check") {
-        await checkLockFile(force);
-    }
-}
-async function getFileHashesFromRegistry() {
-    let packageIds = await getResolvedMopsPackageIds();
-    let actor = await mainActor();
-    let fileHashesByPackageIds = await actor.getFileHashesByPackageIds(packageIds);
-    return fileHashesByPackageIds;
-}
-async function getResolvedMopsPackageIds() {
-    let resolvedPackages = await resolvePackages();
-    let packageIds = Object.entries(resolvedPackages).filter(([_, version]) => getDependencyType(version) === "mops").map(([name, version]) => `${name}@${version}`);
-    return packageIds;
-}
-function getLocalFileHash(fileId) {
-    let rootDir = getRootDir();
-    let file = path6.join(rootDir, ".mops", fileId);
-    if (!fs5.existsSync(file)) {
-        console.error(`Missing file ${fileId} in .mops dir`);
-        process.exit(1);
-    }
-    let fileData = fs5.readFileSync(file);
-    return bytesToHex(sha256(fileData));
-}
-function getMopsTomlHash() {
-    return bytesToHex(sha256(fs5.readFileSync(getRootDir() + "/mops.toml")));
-}
-async function saveLockFile() {
-    let rootDir = getRootDir();
-    let lockFile = path6.join(rootDir, "mops.lock");
-    if (fs5.existsSync(lockFile)) {
-        let lockFileJson2 = JSON.parse(fs5.readFileSync(lockFile).toString());
-        let mopsTomlHash = getMopsTomlHash();
-        if (mopsTomlHash === lockFileJson2.mopsTomlHash) {
-            return;
-        }
-    }
-    let fileHashes = await getFileHashesFromRegistry();
-    let lockFileJson = {
-        version: 1,
-        mopsTomlHash: getMopsTomlHash(),
-        hashes: fileHashes.reduce((acc, [packageId, fileHashes2]) => {
-            acc[packageId] = fileHashes2.reduce((acc2, [fileId, hash]) => {
-                acc2[fileId] = bytesToHex(new Uint8Array(hash));
-                return acc2;
-            }, {});
-            return acc;
-        }, {})
-    };
-    fs5.writeFileSync(lockFile, JSON.stringify(lockFileJson, null, 2));
-}
-async function checkLockFile(force = false) {
-    let rootDir = getRootDir();
-    let lockFile = path6.join(rootDir, "mops.lock");
-    if (!fs5.existsSync(lockFile)) {
-        if (force) {
-            console.error("Missing lock file. Run `mops install` to generate it.");
-            process.exit(1);
-        }
-        return;
-    }
-    let lockFileJson = JSON.parse(fs5.readFileSync(lockFile).toString());
-    let packageIds = await getResolvedMopsPackageIds();
-    if (lockFileJson.version !== 1) {
-        console.error("Integrity check failed");
-        console.error(`Invalid lock file version: ${lockFileJson.version}. Supported versions: 1`);
-        process.exit(1);
-    }
-    if (lockFileJson.mopsTomlHash !== getMopsTomlHash()) {
-        console.error("Integrity check failed");
-        console.error("Mismatched mops.toml hash");
-        console.error(`Locked hash: ${lockFileJson.mopsTomlHash}`);
-        console.error(`Actual hash: ${getMopsTomlHash()}`);
-        process.exit(1);
-    }
-    if (Object.keys(lockFileJson.hashes).length !== packageIds.length) {
-        console.error("Integrity check failed");
-        console.error(`Mismatched number of resolved packages: ${JSON.stringify(Object.keys(lockFileJson.hashes).length)} vs ${JSON.stringify(packageIds.length)}`);
-        process.exit(1);
-    }
-    for (let packageId of packageIds) {
-        if (!(packageId in lockFileJson.hashes)) {
-            console.error("Integrity check failed");
-            console.error(`Missing package ${packageId} in lock file`);
-            process.exit(1);
-        }
-    }
-    for (let [packageId, hashes] of Object.entries(lockFileJson.hashes)) {
-        if (!packageIds.includes(packageId)) {
-            console.error("Integrity check failed");
-            console.error(`Package ${packageId} in lock file but not in resolved packages`);
-            process.exit(1);
-        }
-        for (let [fileId, lockedHash] of Object.entries(hashes)) {
-            if (!fileId.startsWith(packageId)) {
-                console.error("Integrity check failed");
-                console.error(`File ${fileId} in lock file does not belong to package ${packageId}`);
-                process.exit(1);
-            }
-            let localHash = getLocalFileHash(fileId);
-            if (lockedHash !== localHash) {
-                console.error("Integrity check failed");
-                console.error(`Mismatched hash for ${fileId}`);
-                console.error(`Locked hash: ${lockedHash}`);
-                console.error(`Actual hash: ${localHash}`);
-                process.exit(1);
-            }
-        }
-    }
-}
-// dist/commands/install-all.js
-async function installAll({ verbose = false, silent = false, lockfile } = {}) {
-    if (!checkConfigFile()) {
-        return;
-    }
-    let config = readConfig();
-    let deps = Object.values(config.dependencies || {});
-    let devDeps = Object.values(config["dev-dependencies"] || {});
-    let allDeps = [...deps, ...devDeps];
-    let installedPackages = {};
-    for (let { name, repo, path: path18, version } of allDeps) {
-        if (repo) {
-            await installFromGithub(name, repo, { verbose, silent });
-        }
-        else if (!path18) {
-            let res = await install(name, version, { verbose, silent });
-            if (res === false) {
-                return;
-            }
-            installedPackages = { ...installedPackages, ...res };
-        }
-    }
-    if (!silent && lockfile !== "ignore") {
-        logUpdate3("Checking integrity...");
-    }
-    await Promise.all([
-        notifyInstalls(Object.keys(installedPackages)),
-        checkIntegrity(lockfile)
-    ]);
-    if (!silent) {
-        logUpdate3.clear();
-        console.log(chalk5.green("All packages installed"));
-    }
-}
-// dist/commands/template.js
-import fs6 from "node:fs";
-import path7 from "node:path";
-import chalk6 from "chalk";
-import prompts2 from "prompts";
-import camelCase from "camelcase";
-async function template(templateName, options = {}) {
-    var _a;
-    if (!templateName) {
-        let res = await prompts2({
-            type: "select",
-            name: "value",
-            message: "Select template:",
-            choices: [
-                { title: "README.md", value: "readme" },
-                { title: "src/lib.mo", value: "lib.mo" },
-                { title: "test/lib.test.mo", value: "lib.test.mo" },
-                { title: "License MIT", value: "license:MIT" },
-                { title: "License Apache-2.0", value: "license:Apache-2.0" },
-                { title: "GitHub Workflow to run 'mops test'", value: "github-workflow:mops-test" },
-                { title: "\xD7 Cancel", value: "" }
-            ],
-            initial: 0
-        });
-        templateName = res.value;
-    }
-    if (templateName === "github-workflow:mops-test") {
-        let dest = path7.resolve(getRootDir(), ".github/workflows/mops-test.yml");
-        if (fs6.existsSync(dest)) {
-            console.log(chalk6.yellow("Workflow already exists:"), path7.relative(getRootDir(), dest));
-            return;
-        }
-        let mopsTestYml = new URL("../templates/mops-test.yml", import.meta.url);
-        fs6.mkdirSync(path7.resolve(getRootDir(), ".github/workflows"), { recursive: true });
-        fs6.copyFileSync(mopsTestYml, dest);
-        console.log(chalk6.green("Created"), path7.relative(getRootDir(), dest));
-    }
-    else if (templateName == null ? void 0 : templateName.startsWith("license:")) {
-        let dest = path7.resolve(getRootDir(), "LICENSE");
-        if (fs6.existsSync(dest)) {
-            console.log(chalk6.yellow("LICENSE already exists"));
-            return;
-        }
-        let setYearAndOwner = (file) => {
-            let license = fs6.readFileSync(file).toString();
-            license = license.replace(/<year>/g, ( /* @__PURE__ */new Date()).getFullYear().toString());
-            if (options.copyrightOwner) {
-                license = license.replace(/<copyright-owner>/g, options.copyrightOwner);
-            }
-            fs6.writeFileSync(file, license);
-        };
-        if (templateName === "license:MIT") {
-            fs6.copyFileSync(new URL("../templates/licenses/MIT", import.meta.url), path7.resolve(getRootDir(), "LICENSE"));
-            setYearAndOwner(path7.resolve(getRootDir(), "LICENSE"));
-            console.log(chalk6.green("Created"), path7.relative(getRootDir(), "LICENSE"));
-        }
-        else if (templateName === "license:Apache-2.0") {
-            fs6.copyFileSync(new URL("../templates/licenses/Apache-2.0", import.meta.url), path7.resolve(getRootDir(), "LICENSE"));
-            fs6.copyFileSync(new URL("../templates/licenses/Apache-2.0-NOTICE", import.meta.url), path7.resolve(getRootDir(), "NOTICE"));
-            setYearAndOwner(path7.resolve(getRootDir(), "NOTICE"));
-            console.log(chalk6.green("Created"), path7.relative(getRootDir(), "LICENSE"));
-            console.log(chalk6.green("Created"), path7.relative(getRootDir(), "NOTICE"));
-        }
-    }
-    else if (templateName === "lib.mo") {
-        fs6.mkdirSync(path7.join(getRootDir(), "src"), { recursive: true });
-        fs6.copyFileSync(new URL("../templates/src/lib.mo", import.meta.url), path7.resolve(getRootDir(), "src/lib.mo"));
-        console.log(chalk6.green("Created"), path7.relative(getRootDir(), "src/lib.mo"));
-    }
-    else if (templateName === "lib.test.mo") {
-        fs6.mkdirSync(path7.join(getRootDir(), "test"), { recursive: true });
-        fs6.copyFileSync(new URL("../templates/test/lib.test.mo", import.meta.url), path7.resolve(getRootDir(), "test/lib.test.mo"));
-        console.log(chalk6.green("Created"), path7.relative(getRootDir(), "test/lib.test.mo"));
-    }
-    else if (templateName === "readme") {
-        let dest = path7.resolve(getRootDir(), "README.md");
-        if (fs6.existsSync(dest)) {
-            console.log(chalk6.yellow("README.md already exists"));
-            return;
-        }
-        fs6.copyFileSync(new URL("../templates/README.md", import.meta.url), dest);
-        let config = readConfig();
-        let data = fs6.readFileSync(dest).toString();
-        data = data.replace(/<year>/g, ( /* @__PURE__ */new Date()).getFullYear().toString());
-        if ((_a = config.package) == null ? void 0 : _a.name) {
-            data = data.replace(/<name>/g, config.package.name);
-            data = data.replace(/<import-name>/g, camelCase(config.package.name, { pascalCase: true }));
-        }
-        fs6.writeFileSync(dest, data);
-        console.log(chalk6.green("Created"), path7.relative(getRootDir(), "README.md"));
-    }
-}
-// dist/commands/init.js
-async function init({ yes = false } = {}) {
-    let configFile = path8.join(process.cwd(), "mops.toml");
-    let exists = existsSync2(configFile);
-    if (exists) {
-        console.log(chalk7.yellow("mops.toml already exists"));
-        return;
-    }
-    console.log("Initializing...");
-    let config = {};
-    if (yes) {
-        await applyInit({
-            type: "project",
-            config,
-            setupWorkflow: true,
-            addTest: false,
-            copyrightOwner: ""
-        });
-        return;
-    }
-    let vesselFile = path8.join(process.cwd(), "vessel.dhall");
-    let vesselConfig = { dependencies: [], "dev-dependencies": [] };
-    if (existsSync2(vesselFile)) {
-        console.log("Reading vessel.dhall file");
-        let res = await readVesselConfig(process.cwd(), { cache: false });
-        if (res) {
-            vesselConfig = { ...res };
-        }
-    }
-    if (vesselConfig.dependencies) {
-        let deps = {};
-        deps = {};
-        for (const dep of vesselConfig.dependencies || []) {
-            deps[dep.name] = dep;
-        }
-        if (Object.keys(deps).length) {
-            config.dependencies = deps;
-        }
-    }
-    let promptsConfig = {
-        onCancel() {
-            console.log("aborted");
-            process.exit(0);
-        }
-    };
-    let { type } = await prompts3({
-        type: "select",
-        name: "type",
-        message: "Select type:",
-        choices: [
-            { title: `Project ${chalk7.dim("(I just want to use mops packages in my project)")}`, value: "project" },
-            { title: `Package ${chalk7.dim("(I plan to publish this package on mops)")}`, value: "package" }
-        ]
-    }, promptsConfig);
-    let addTest = false;
-    let copyrightOwner = "";
-    if (type === "package") {
-        let res = await prompts3([
-            {
-                type: "text",
-                name: "name",
-                message: "Enter package name:",
-                initial: ""
-            },
-            {
-                type: "text",
-                name: "description",
-                message: "Enter package description:",
-                initial: ""
-            },
-            {
-                type: "text",
-                name: "repository",
-                message: "Enter package repository url:",
-                initial: ""
-            },
-            {
-                type: "text",
-                name: "keywords",
-                message: "Enter keywords separated by spaces:",
-                initial: ""
-            },
-            {
-                type: "select",
-                name: "license",
-                message: "Choose a license:",
-                choices: [
-                    { title: "MIT", value: "MIT" },
-                    { title: "Apache-2.0", value: "Apache-2.0" }
-                ],
-                initial: 0
-            },
-            {
-                type: "text",
-                name: "copyrightOwner",
-                message: "Enter license copyright owner:",
-                initial: ""
-            },
-            {
-                type: "confirm",
-                name: "addTest",
-                message: `Add example test file? ${chalk7.dim("(test/lib.test.mo)")}`,
-                initial: true
-            }
-        ], promptsConfig);
-        config.package = {
-            name: (res.name || "").trim(),
-            version: "1.0.0",
-            description: (res.description || "").trim(),
-            repository: (res.repository || "").trim(),
-            keywords: [...new Set(res.keywords.split(" ").filter(Boolean))],
-            license: (res.license || "").trim()
-        };
-        addTest = res.addTest;
-        copyrightOwner = res.copyrightOwner;
-    }
-    let { setupWorkflow } = await prompts3({
-        type: "confirm",
-        name: "setupWorkflow",
-        message: `Setup GitHub workflow? ${chalk7.dim("(run `mops test` on push)")}`,
-        initial: true
-    }, promptsConfig);
-    await applyInit({
-        type,
-        config,
-        setupWorkflow,
-        addTest,
-        copyrightOwner
-    });
-}
-async function applyInit({ type, config, setupWorkflow, addTest, copyrightOwner }) {
-    var _a, _b;
-    let dfxJson2 = path8.resolve(process.cwd(), "dfx.json");
-    let dfxJsonData;
-    if (existsSync2(dfxJson2)) {
-        let dfxJsonText = readFileSync2(dfxJson2).toString();
-        try {
-            dfxJsonData = JSON.parse(dfxJsonText);
-        }
-        catch (err) {
-            console.log(chalk7.yellow("Failed to parse dfx.json"));
-        }
-        if (dfxJsonData) {
-            console.log("Setting packtool in dfx.json...");
-            dfxJsonData.defaults = dfxJsonData.defaults || {};
-            dfxJsonData.defaults.build = dfxJsonData.defaults.build || {};
-            if (dfxJsonData.defaults.build.packtool !== "mops sources") {
-                dfxJsonData.defaults.build.packtool = "mops sources";
-                let indent = ((_a = dfxJsonText.match(/([ \t]+)"/)) == null ? void 0 : _a[1]) || "  ";
-                writeFileSync2(path8.join(process.cwd(), "dfx.json"), JSON.stringify(dfxJsonData, null, indent));
-                console.log(chalk7.green('packtool set to "mops sources"'));
-            }
-        }
-    }
-    if (type === "project") {
-        let compatible = await checkApiCompatibility();
-        if (!compatible) {
-            return;
-        }
-        let dfxVersion = (dfxJsonData == null ? void 0 : dfxJsonData.dfx) || "";
-        if (!dfxVersion) {
-            try {
-                let res = execSync("dfx --version").toString();
-                let match = res.match(/\d+\.\d+\.\d+/);
-                if (match) {
-                    dfxVersion = match[0];
-                }
-            }
-            catch {
-            }
-        }
-        console.log(`Fetching default packages for dfx ${dfxVersion}...`);
-        let actor = await mainActor();
-        let defaultPackages = await actor.getDefaultPackages(dfxVersion);
-        if (!config.dependencies) {
-            config.dependencies = {};
-        }
-        for (let [name, version] of defaultPackages) {
-            config.dependencies[name] = { name, version };
-        }
-    }
-    let configFile = path8.join(process.cwd(), "mops.toml");
-    writeConfig(config, configFile);
-    console.log(chalk7.green("Created"), "mops.toml");
-    if (type === "package" && !existsSync2(path8.join(process.cwd(), "src"))) {
-        await template("lib.mo");
-    }
-    if (addTest && !existsSync2(path8.join(process.cwd(), "test"))) {
-        await template("lib.test.mo");
-    }
-    if ((_b = config.package) == null ? void 0 : _b.license) {
-        await template(`license:${config.package.license}`, { copyrightOwner });
-    }
-    if (type === "package") {
-        await template("readme");
-    }
-    if (setupWorkflow) {
-        await template("github-workflow:mops-test");
-    }
-    {
-        let gitignore = path8.join(process.cwd(), ".gitignore");
-        let gitignoreData = existsSync2(gitignore) ? readFileSync2(gitignore).toString() : "";
-        let lf = gitignoreData.endsWith("\n") ? "\n" : "";
-        if (!gitignoreData.includes(".mops")) {
-            writeFileSync2(gitignore, `${gitignoreData}
-.mops${lf}`.trimStart());
-            console.log(chalk7.green("Added"), ".mops to .gitignore");
-        }
-    }
-    if (Object.keys(config.dependencies || {}).length) {
-        console.log("Installing dependencies...");
-        await installAll({ verbose: true });
-    }
-    console.log(chalk7.green("Done!"));
-}
-// dist/commands/publish.js
-import fs10 from "node:fs";
-import path13 from "node:path";
-import chalk15 from "chalk";
-import logUpdate5 from "log-update";
-import { globbySync } from "globby";
-import { minimatch } from "minimatch";
-import prompts4 from "prompts";
-import { fromMarkdown } from "mdast-util-from-markdown";
-import { toMarkdown } from "mdast-util-to-markdown";
-// dist/commands/docs.js
-import { spawn, execSync as execSync2 } from "node:child_process";
-import fs7 from "node:fs";
-import path9 from "node:path";
-import chalk8 from "chalk";
-import { globSync } from "glob";
-import { deleteSync as deleteSync2 } from "del";
-import tar from "tar";
-import streamToPromise from "stream-to-promise";
-var moDoc;
-async function docs({ silent = false } = {}) {
-    let rootDir = getRootDir();
-    let docsDir = path9.join(rootDir, ".mops/.docs");
-    let docsDirRelative = path9.relative(process.cwd(), docsDir);
-    deleteSync2([docsDir], { force: true });
-    if (process.env.DFX_MOC_PATH && process.env.DFX_MOC_PATH.includes("mocv/versions")) {
-        moDoc = process.env.DFX_MOC_PATH.replace(/\/moc$/, "/mo-doc");
-    }
-    else {
-        moDoc = execSync2("dfx cache show").toString().trim() + "/mo-doc";
-    }
-    await new Promise((resolve) => {
-        let proc = spawn(moDoc, [`--source=${path9.join(rootDir, "src")}`, `--output=${docsDirRelative}`, "--format=adoc"]);
-        proc.stdout.on("data", (data) => {
-            let text = data.toString().trim();
-            let failedText = "Failed to extract documentation";
-            if (text.includes(failedText)) {
-                console.log(text.replaceAll(failedText, chalk8.yellow("Warning: ") + failedText));
-            }
-            silent || console.log("stdout", text);
-        });
-        let stderr = "";
-        proc.stderr.on("data", (data) => {
-            let text = data.toString().trim();
-            if (text.includes("syntax error")) {
-                console.log(chalk8.red("Error:"), text);
-                process.exit(1);
-            }
-            if (text.includes("No such file or directory") || text.includes("Couldn't find a module expression")) {
-                silent || console.log(text);
-                return;
-            }
-            stderr += text;
-        });
-        proc.on("exit", (code) => {
-            if (code === 2 && !stderr) {
-                resolve();
-                return;
-            }
-            if (code !== 0) {
-                console.log(chalk8.red("Error:"), code, stderr);
-                process.exit(1);
-            }
-            resolve();
-        });
-    });
-    let ignore4 = [
-        `${docsDir}/**/*.test.adoc`,
-        `${docsDir}/test/**/*`
-    ];
-    let files = globSync(`${docsDir}/**/*.adoc`, { ignore: ignore4 }).map((f) => path9.relative(docsDir, f));
-    files.sort();
-    if (files.length) {
-        let stream = tar.create({
-            cwd: docsDir,
-            gzip: true,
-            portable: true
-        }, files).pipe(fs7.createWriteStream(path9.join(docsDir, "docs.tgz")));
-        await streamToPromise(stream);
-    }
-    silent || console.log(`${chalk8.green("Documentation generated")} at ${docsDirRelative}`);
-}
-// dist/commands/test/test.js
-import { spawn as spawn2, execSync as execSync3 } from "node:child_process";
-import path12 from "node:path";
-import fs9 from "node:fs";
-import os from "node:os";
-import chalk14 from "chalk";
-import { globSync as globSync2 } from "glob";
-import chokidar from "chokidar";
-import debounce from "debounce";
-// dist/commands/sources.js
-import path10 from "node:path";
-import fs8 from "node:fs";
-async function sources({ verbose = false, cwd = process.cwd() } = {}) {
-    if (!checkConfigFile()) {
-        return [];
-    }
-    let resolvedPackages = await resolvePackages({ verbose });
-    return Object.entries(resolvedPackages).map(([name, version]) => {
-        var _a;
-        let depType = getDependencyType(version);
-        let pkgDir;
-        if (depType === "local") {
-            pkgDir = path10.relative(cwd, version);
-        }
-        else if (depType === "github") {
-            pkgDir = path10.relative(cwd, formatGithubDir(name, version));
-        }
-        else if (depType === "mops") {
-            pkgDir = path10.relative(cwd, formatDir(name, version));
-        }
-        else {
-            return;
-        }
-        let pkgBaseDir;
-        if (fs8.existsSync(path10.join(pkgDir, "mops.toml"))) {
-            let config = readConfig(path10.join(pkgDir, "mops.toml"));
-            pkgBaseDir = path10.join(pkgDir, ((_a = config.package) == null ? void 0 : _a.baseDir) || "src");
-        }
-        else {
-            pkgBaseDir = path10.join(pkgDir, "src");
-        }
-        if (depType === "local" && !fs8.existsSync(pkgBaseDir)) {
-            pkgBaseDir = pkgDir;
-        }
-        return `--package ${name} ${pkgBaseDir}`;
-    });
-}
-// dist/commands/test/mmf1.js
-import chalk9 from "chalk";
-var MMF1 = class {
-    constructor(srategy, file) {
-        this.stack = [];
-        this.currSuite = "";
-        this.failed = 0;
-        this.passed = 0;
-        this.skipped = 0;
-        this.output = [];
-        this.nestingSymbol = " \u203A ";
-        this.passedNamesFlat = [];
-        this.srategy = srategy;
-        this.file = file;
-    }
-    _log(type, ...args) {
-        if (this.srategy === "store") {
-            this.output.push({
-                type,
-                message: args.join(" ")
-            });
-        }
-        else if (this.srategy === "print") {
-            console.log(...args);
-        }
-    }
-    flush(messageType) {
-        for (let out of this.output) {
-            if (!messageType || out.type === messageType) {
-                console.log(out.message);
-            }
-        }
-        this.output = [];
-    }
-    parseLine(line) {
-        if (line.startsWith("mops:1:start ")) {
-            this._testStart(line.split("mops:1:start ")[1] || "");
-        }
-        else if (line.startsWith("mops:1:end ")) {
-            this._testEnd(line.split("mops:1:end ")[1] || "");
-        }
-        else if (line.startsWith("mops:1:skip ")) {
-            this._testSkip(line.split("mops:1:skip ")[1] || "");
-        }
-        else if (line.startsWith("mops:")) {
-        }
-        else {
-            this._log("stdout", " ".repeat(this.stack.length * 2), chalk9.gray("stdout"), line);
-        }
-    }
-    _testStart(name) {
-        let suite = this.stack[this.stack.length - 1];
-        if (suite) {
-            if (this.currSuite !== suite) {
-                this.currSuite = suite;
-                this._log("suite", " ".repeat((this.stack.length - 1) * 2), chalk9.gray("\u2022") + "", suite);
-            }
-        }
-        this.stack.push(name);
-    }
-    _testEnd(name) {
-        if (name !== this.stack.pop()) {
-            throw "mmf1._testEnd: start and end test mismatch";
-        }
-        this._status(name, "pass");
-    }
-    _testSkip(name) {
-        this._status(name, "skip");
-    }
-    _status(name, status) {
-        if (status === "pass") {
-            if (name === this.currSuite) {
-                return;
-            }
-            this.passed++;
-            this._log(status, " ".repeat(this.stack.length * 2), chalk9.green("\u2713"), name);
-            this.passedNamesFlat.push([this.file, ...this.stack, name].join(this.nestingSymbol));
-        }
-        else if (status === "fail") {
-            this.failed++;
-            this._log(status, " ".repeat(this.stack.length * 2), chalk9.red("\u2716"), name);
-        }
-        else if (status === "skip") {
-            this.skipped++;
-            this._log(status, " ".repeat(this.stack.length * 2), chalk9.yellow("\u2212"), name);
-        }
-    }
-    fail(stderr) {
-        let name = this.stack.pop() || "";
-        this._status(name, "fail");
-        this._log("fail", " ".repeat(this.stack.length * 2), chalk9.red("FAIL"), stderr);
-    }
-    pass() {
-        let name = this.stack.pop();
-        if (name) {
-            this._status(name, "pass");
-        }
-        this._log("pass", " ".repeat(this.stack.length * 2), chalk9.green("PASS"));
-    }
-};
-// dist/commands/test/utils.js
-import path11 from "node:path";
-function absToRel(p) {
-    let rootDir = getRootDir();
-    return path11.relative(rootDir, path11.resolve(p));
-}
-// dist/commands/test/reporters/verbose-reporter.js
-import chalk10 from "chalk";
-var __classPrivateFieldGet = function (receiver, state, kind, f) {
-    if (kind === "a" && !f)
-        throw new TypeError("Private accessor was defined without a getter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver))
-        throw new TypeError("Cannot read private member from an object whose class did not declare it");
-    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
-};
-var __classPrivateFieldSet = function (receiver, state, value, kind, f) {
-    if (kind === "m")
-        throw new TypeError("Private method is not writable");
-    if (kind === "a" && !f)
-        throw new TypeError("Private accessor was defined without a setter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver))
-        throw new TypeError("Cannot write private member to an object whose class did not declare it");
-    return kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value), value;
-};
-var _VerboseReporter_startTime;
-var _VerboseReporter_curFileIndex;
-var VerboseReporter = class {
-    constructor() {
-        this.passed = 0;
-        this.failed = 0;
-        this.skipped = 0;
-        _VerboseReporter_startTime.set(this, Date.now());
-        _VerboseReporter_curFileIndex.set(this, 0);
-    }
-    addFiles(files) {
-        console.log("Test files:");
-        for (let file of files) {
-            console.log(chalk10.gray(`\u2022 ${absToRel(file)}`));
-        }
-        console.log("=".repeat(50));
-    }
-    addRun(file, mmf, state, wasiMode) {
-        state.then(() => {
-            var _a, _b;
-            this.passed += mmf.passed;
-            this.failed += mmf.failed;
-            this.skipped += mmf.skipped;
-            if (mmf.passed === 0 && mmf.failed === 0) {
-                this.passed++;
-            }
-            (__classPrivateFieldSet(this, _VerboseReporter_curFileIndex, (_b = __classPrivateFieldGet(this, _VerboseReporter_curFileIndex, "f"), _a = _b++, _b), "f"), _a) && console.log("-".repeat(50));
-            console.log(`Running ${chalk10.gray(absToRel(file))} ${wasiMode ? chalk10.gray("(wasi)") : ""}`);
-            mmf.flush();
-        });
-    }
-    done() {
-        console.log("=".repeat(50));
-        if (this.failed) {
-            console.log(chalk10.redBright("Tests failed"));
-        }
-        else {
-            console.log(chalk10.greenBright("Tests passed"));
-        }
-        console.log(`Done in ${chalk10.gray(((Date.now() - __classPrivateFieldGet(this, _VerboseReporter_startTime, "f")) / 1e3).toFixed(2) + "s")}, passed ${chalk10.greenBright(this.passed)}` + (this.skipped ? `, skipped ${chalk10[this.skipped ? "yellowBright" : "gray"](this.skipped)}` : "") + (this.failed ? `, failed ${chalk10[this.failed ? "redBright" : "gray"](this.failed)}` : ""));
-        return this.failed === 0;
-    }
-};
-_VerboseReporter_startTime = /* @__PURE__ */ new WeakMap(), _VerboseReporter_curFileIndex = /* @__PURE__ */ new WeakMap();
-// dist/commands/test/reporters/files-reporter.js
-import chalk11 from "chalk";
-var __classPrivateFieldGet2 = function (receiver, state, kind, f) {
-    if (kind === "a" && !f)
-        throw new TypeError("Private accessor was defined without a getter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver))
-        throw new TypeError("Cannot read private member from an object whose class did not declare it");
-    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
-};
-var _FilesReporter_startTime;
-var FilesReporter = class {
-    constructor() {
-        this.passed = 0;
-        this.failed = 0;
-        this.skipped = 0;
-        _FilesReporter_startTime.set(this, Date.now());
-    }
-    addFiles(files) {
-        console.log(`Test files: ${files.length}`);
-        console.log("=".repeat(50));
-    }
-    addRun(file, mmf, state, wasiMode) {
-        state.then(() => {
-            this.passed += Number(mmf.failed === 0);
-            this.failed += Number(mmf.failed !== 0);
-            this.skipped += mmf.skipped;
-            if (mmf.failed) {
-                console.log(chalk11.red("\u2716"), absToRel(file));
-                mmf.flush("fail");
-                console.log("-".repeat(50));
-            }
-            else {
-                console.log(`${chalk11.green("\u2713")} ${absToRel(file)} ${wasiMode ? chalk11.gray("(wasi)") : ""}`);
-            }
-        });
-    }
-    done() {
-        console.log("=".repeat(50));
-        if (this.failed) {
-            console.log(chalk11.redBright("Tests failed"));
-        }
-        else {
-            console.log(chalk11.greenBright("Tests passed"));
-        }
-        console.log(`Done in ${chalk11.gray(((Date.now() - __classPrivateFieldGet2(this, _FilesReporter_startTime, "f")) / 1e3).toFixed(2) + "s")}, passed ${chalk11.greenBright(this.passed)} files` + (this.skipped ? `, skipped ${chalk11[this.skipped ? "yellowBright" : "gray"](this.skipped)} cases` : "") + (this.failed ? `, failed ${chalk11[this.failed ? "redBright" : "gray"](this.failed)} files` : ""));
-        return this.failed === 0;
-    }
-};
-_FilesReporter_startTime = /* @__PURE__ */ new WeakMap();
-// dist/commands/test/reporters/compact-reporter.js
-import chalk12 from "chalk";
-import logUpdate4 from "log-update";
-var __classPrivateFieldSet2 = function (receiver, state, value, kind, f) {
-    if (kind === "m")
-        throw new TypeError("Private method is not writable");
-    if (kind === "a" && !f)
-        throw new TypeError("Private accessor was defined without a setter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver))
-        throw new TypeError("Cannot write private member to an object whose class did not declare it");
-    return kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value), value;
-};
-var __classPrivateFieldGet3 = function (receiver, state, kind, f) {
-    if (kind === "a" && !f)
-        throw new TypeError("Private accessor was defined without a getter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver))
-        throw new TypeError("Cannot read private member from an object whose class did not declare it");
-    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
-};
-var _CompactReporter_instances;
-var _CompactReporter_allFiles;
-var _CompactReporter_runningFiles;
-var _CompactReporter_failedFiles;
-var _CompactReporter_finishedFiles;
-var _CompactReporter_startTime;
-var _CompactReporter_timerId;
-var _CompactReporter_startTimer;
-var _CompactReporter_clearTimer;
-var _CompactReporter_log;
-var CompactReporter = class {
-    constructor() {
-        _CompactReporter_instances.add(this);
-        this.passed = 0;
-        this.failed = 0;
-        this.skipped = 0;
-        this.passedFiles = 0;
-        this.failedFiles = 0;
-        _CompactReporter_allFiles.set(this, /* @__PURE__ */ new Set());
-        _CompactReporter_runningFiles.set(this, /* @__PURE__ */ new Set());
-        _CompactReporter_failedFiles.set(this, /* @__PURE__ */ new Set());
-        _CompactReporter_finishedFiles.set(this, /* @__PURE__ */ new Set());
-        _CompactReporter_startTime.set(this, Date.now());
-        _CompactReporter_timerId.set(this, null);
-    }
-    addFiles(files) {
-        __classPrivateFieldSet2(this, _CompactReporter_allFiles, new Set(files), "f");
-        __classPrivateFieldGet3(this, _CompactReporter_instances, "m", _CompactReporter_log).call(this);
-        __classPrivateFieldGet3(this, _CompactReporter_instances, "m", _CompactReporter_startTimer).call(this);
-    }
-    addRun(file, mmf, state, _wasiMode) {
-        __classPrivateFieldGet3(this, _CompactReporter_runningFiles, "f").add(file);
-        __classPrivateFieldGet3(this, _CompactReporter_instances, "m", _CompactReporter_log).call(this);
-        state.then(() => {
-            this.passed += mmf.passed;
-            this.failed += mmf.failed;
-            this.skipped += mmf.skipped;
-            if (mmf.passed === 0 && mmf.failed === 0) {
-                this.passed++;
-            }
-            this.passedFiles += Number(mmf.failed === 0);
-            this.failedFiles += Number(mmf.failed !== 0);
-            if (mmf.failed) {
-                __classPrivateFieldGet3(this, _CompactReporter_failedFiles, "f").add(file);
-                logUpdate4.clear();
-                console.log(chalk12.red("\u2716"), absToRel(file));
-                mmf.flush("fail");
-                console.log("-".repeat(50));
-            }
-            __classPrivateFieldGet3(this, _CompactReporter_runningFiles, "f").delete(file);
-            __classPrivateFieldGet3(this, _CompactReporter_finishedFiles, "f").add(file);
-            __classPrivateFieldGet3(this, _CompactReporter_instances, "m", _CompactReporter_log).call(this);
-        });
-    }
-    done() {
-        __classPrivateFieldGet3(this, _CompactReporter_instances, "m", _CompactReporter_log).call(this);
-        logUpdate4.done();
-        __classPrivateFieldGet3(this, _CompactReporter_instances, "m", _CompactReporter_clearTimer).call(this);
-        return this.failed === 0;
-    }
-};
-_CompactReporter_allFiles = /* @__PURE__ */ new WeakMap(), _CompactReporter_runningFiles = /* @__PURE__ */ new WeakMap(), _CompactReporter_failedFiles = /* @__PURE__ */ new WeakMap(), _CompactReporter_finishedFiles = /* @__PURE__ */ new WeakMap(), _CompactReporter_startTime = /* @__PURE__ */ new WeakMap(), _CompactReporter_timerId = /* @__PURE__ */ new WeakMap(), _CompactReporter_instances = /* @__PURE__ */ new WeakSet(), _CompactReporter_startTimer = function _CompactReporter_startTimer2() {
-    __classPrivateFieldSet2(this, _CompactReporter_timerId, setInterval(() => __classPrivateFieldGet3(this, _CompactReporter_instances, "m", _CompactReporter_log).call(this), 55), "f");
-}, _CompactReporter_clearTimer = function _CompactReporter_clearTimer2() {
-    if (__classPrivateFieldGet3(this, _CompactReporter_timerId, "f")) {
-        clearInterval(__classPrivateFieldGet3(this, _CompactReporter_timerId, "f"));
-    }
-}, _CompactReporter_log = function _CompactReporter_log2() {
-    let res = [];
-    let i = 0;
-    for (let file of __classPrivateFieldGet3(this, _CompactReporter_allFiles, "f")) {
-        if (__classPrivateFieldGet3(this, _CompactReporter_runningFiles, "f").has(file)) {
-            res[Number(i)] = ".";
-        }
-        else if (__classPrivateFieldGet3(this, _CompactReporter_finishedFiles, "f").has(file)) {
-            res[Number(i)] = __classPrivateFieldGet3(this, _CompactReporter_failedFiles, "f").has(file) ? chalk12.red(":") : ":";
-        }
-        else {
-            res[Number(i)] = " ";
-        }
-        i++;
-    }
-    let output = `[${res.join("")}]
-${chalk12.gray(((Date.now() - __classPrivateFieldGet3(this, _CompactReporter_startTime, "f")) / 1e3).toFixed(2) + "s")}, total ${__classPrivateFieldGet3(this, _CompactReporter_allFiles, "f").size} files, passed ${chalk12.greenBright(this.passedFiles)} files` + (this.skipped ? `, skipped ${chalk12[this.skipped ? "yellowBright" : "gray"](this.skipped)} cases` : "") + (this.failed ? `, failed ${chalk12[this.failed ? "redBright" : "gray"](this.failed)} cases` : "");
-    logUpdate4(output);
-};
-// dist/commands/test/reporters/silent-reporter.js
-import chalk13 from "chalk";
-var SilentReporter = class {
-    constructor() {
-        this.passed = 0;
-        this.failed = 0;
-        this.skipped = 0;
-        this.passedFiles = 0;
-        this.failedFiles = 0;
-        this.passedNamesFlat = [];
-    }
-    addFiles(_files) {
-    }
-    addRun(file, mmf, state, _wasiMode) {
-        state.then(() => {
-            this.passed += mmf.passed;
-            this.failed += mmf.failed;
-            this.skipped += mmf.skipped;
-            this.passedNamesFlat = [...this.passedNamesFlat, ...mmf.passedNamesFlat];
-            if (mmf.passed === 0 && mmf.failed === 0) {
-                this.passed++;
-                this.passedNamesFlat.push(absToRel(file));
-            }
-            this.passedFiles += Number(mmf.failed === 0);
-            this.failedFiles += Number(mmf.failed !== 0);
-            if (mmf.failed) {
-                console.log(chalk13.red("\u2716"), absToRel(file));
-                mmf.flush("fail");
-                console.log("-".repeat(50));
-            }
-        });
-    }
-    done() {
-        return this.failed === 0;
-    }
-};
-// dist/commands/test/test.js
-var ignore = [
-    "**/node_modules/**",
-    "**/.mops/**",
-    "**/.vessel/**",
-    "**/.git/**"
-];
-var globConfig = {
-    nocase: true,
-    ignore
-};
-async function test(filter = "", { watch = false, reporter = "verbose", mode = "interpreter" } = {}) {
-    let rootDir = getRootDir();
-    if (watch) {
-        let run = debounce(async () => {
-            console.clear();
-            process.stdout.write("\x1Bc");
-            await runAll(reporter, filter, mode);
-            console.log("-".repeat(50));
-            console.log("Waiting for file changes...");
-            console.log(chalk14.gray(`Press ${chalk14.gray("Ctrl+C")} to exit.`));
-        }, 200);
-        let watcher = chokidar.watch([
-            path12.join(rootDir, "**/*.mo"),
-            path12.join(rootDir, "mops.toml")
-        ], {
-            ignored: ignore,
-            ignoreInitial: true
-        });
-        watcher.on("all", () => {
-            run();
-        });
-        run();
-    }
-    else {
-        let passed = await runAll(reporter, filter, mode);
-        if (!passed) {
-            process.exit(1);
-        }
-    }
-}
-var mocPath = process.env.DFX_MOC_PATH;
-async function runAll(reporterName = "verbose", filter = "", mode = "interpreter") {
-    let reporter;
-    if (reporterName == "compact") {
-        reporter = new CompactReporter();
-    }
-    else if (reporterName == "files") {
-        reporter = new FilesReporter();
-    }
-    else if (reporterName == "silent") {
-        reporter = new SilentReporter();
-    }
-    else {
-        reporter = new VerboseReporter();
-    }
-    let done = await testWithReporter(reporter, filter, mode);
-    return done;
-}
-async function testWithReporter(reporter, filter = "", mode = "interpreter") {
-    let rootDir = getRootDir();
-    let files = [];
-    let libFiles = globSync2("**/test?(s)/lib.mo", globConfig);
-    if (libFiles[0]) {
-        files = [libFiles[0]];
-    }
-    else {
-        let globStr = "**/test?(s)/**/*.test.mo";
-        if (filter) {
-            globStr = `**/test?(s)/**/*${filter}*.mo`;
-        }
-        files = globSync2(path12.join(rootDir, globStr), globConfig);
-    }
-    if (!files.length) {
-        if (filter) {
-            console.log(`No test files found for filter '${filter}'`);
-            return false;
-        }
-        console.log("No test files found");
-        console.log("Put your tests in 'test' directory in *.test.mo files");
-        return false;
-    }
-    reporter.addFiles(files);
-    let sourcesArr = await sources();
-    if (!mocPath) {
-        mocPath = execSync3("dfx cache show").toString().trim() + "/moc";
-    }
-    let wasmDir = `${getRootDir()}/.mops/.test/`;
-    fs9.mkdirSync(wasmDir, { recursive: true });
-    await parallel(os.cpus().length, files, async (file) => {
-        let mmf = new MMF1("store", absToRel(file));
-        let wasiMode = mode === "wasi" || fs9.readFileSync(file, "utf8").startsWith("// @testmode wasi");
-        let promise = new Promise((resolve) => {
-            if (!mocPath) {
-                mocPath = "moc";
-            }
-            let mocArgs = ["--hide-warnings", "--error-detail=2", ...sourcesArr.join(" ").split(" "), file].filter((x) => x);
-            if (wasiMode) {
-                let wasmFile = `${path12.join(wasmDir, path12.parse(file).name)}.wasm`;
-                let buildProc = spawn2(mocPath, [`-o=${wasmFile}`, "-wasi-system-api", ...mocArgs]);
-                pipeMMF(buildProc, mmf).then(async () => {
-                    if (mmf.failed > 0) {
-                        return;
-                    }
-                    let proc = spawn2("wasmtime", [
-                        "--max-wasm-stack=2000000",
-                        "--enable-cranelift-nan-canonicalization",
-                        "--wasm-features",
-                        "multi-memory,bulk-memory",
-                        wasmFile
-                    ], {
-                        env: {
-                            ...process.env,
-                            WASMTIME_NEW_CLI: "0"
-                        }
-                    });
-                    await pipeMMF(proc, mmf);
-                }).finally(() => {
-                    fs9.rmSync(wasmFile, { force: true });
-                }).then(resolve);
-            }
-            else {
-                let proc = spawn2(mocPath, ["-r", "-ref-system-api", ...mocArgs]);
-                pipeMMF(proc, mmf).then(resolve);
-            }
-        });
-        reporter.addRun(file, mmf, promise, wasiMode);
-        await promise;
-    });
-    fs9.rmSync(wasmDir, { recursive: true, force: true });
-    return reporter.done();
-}
-function pipeMMF(proc, mmf) {
-    return new Promise((resolve) => {
-        proc.stdout.on("data", (data) => {
-            for (let line of data.toString().split("\n")) {
-                line = line.trim();
-                if (line) {
-                    mmf.parseLine(line);
-                }
-            }
-        });
-        proc.stderr.on("data", (data) => {
-            let text = data.toString().trim();
-            let failedLine = "";
-            text = text.replace(/([\w+._/-]+):(\d+).(\d+)(-\d+.\d+)/g, (_m0, m1, m2, m3) => {
-                var _a, _b;
-                let res = `${absToRel(m1)}:${m2}:${m3}`;
-                if (!fs9.existsSync(m1)) {
-                    return res;
-                }
-                let content = fs9.readFileSync(m1);
-                let lines = content.toString().split("\n") || [];
-                failedLine += chalk14.dim("\n   ...");
-                let lineBefore = lines[+m2 - 2];
-                if (lineBefore) {
-                    failedLine += chalk14.dim(`
-   ${+m2 - 1}	| ${lineBefore.replaceAll("	", "  ")}`);
-                }
-                failedLine += `
-${chalk14.redBright `->`} ${m2}	| ${(_a = lines[+m2 - 1]) == null ? void 0 : _a.replaceAll("	", "  ")}`;
-                if (lines.length > +m2) {
-                    failedLine += chalk14.dim(`
-   ${+m2 + 1}	| ${(_b = lines[+m2]) == null ? void 0 : _b.replaceAll("	", "  ")}`);
-                }
-                failedLine += chalk14.dim("\n   ...");
-                return res;
-            });
-            if (failedLine) {
-                text += failedLine;
-            }
-            mmf.fail(text);
-        });
-        proc.on("close", (code) => {
-            if (code === 0) {
-                mmf.pass();
-            }
-            else if (code !== 1) {
-                mmf.fail(`unknown exit code: ${code}`);
-            }
-            resolve();
-        });
-    });
-}
-// dist/commands/publish.js
-async function publish(options = {}) {
-    var _a, _b;
-    if (!checkConfigFile()) {
-        return;
-    }
-    let rootDir = getRootDir();
-    let config = readConfig();
-    console.log(`Publishing ${(_a = config.package) == null ? void 0 : _a.name}@${(_b = config.package) == null ? void 0 : _b.version}`);
-    for (let key of Object.keys(config)) {
-        if (!["package", "dependencies", "dev-dependencies", "scripts"].includes(key)) {
-            console.log(chalk15.red("Error: ") + `Unknown config section [${key}]`);
-            process.exit(1);
-        }
-    }
-    if (!config.package) {
-        console.log(chalk15.red("Error: ") + "Please specify [package] section in your mops.toml");
-        process.exit(1);
-    }
-    for (let key of ["name", "version"]) {
-        if (!config.package[key]) {
-            console.log(chalk15.red("Error: ") + `Please specify "${key}" in [config] section in your mops.toml`);
-            process.exit(1);
-        }
-    }
-    for (let key of ["description", "repository"]) {
-        if (!config.package[key]) {
-            let res2 = await prompts4({
-                type: "confirm",
-                name: "ok",
-                message: `Missing recommended config key "${key}", publish anyway?`
-            });
-            if (!res2.ok) {
-                return;
-            }
-        }
-    }
-    let packageKeys = [
-        "name",
-        "version",
-        "keywords",
-        "description",
-        "repository",
-        "documentation",
-        "homepage",
-        "baseDir",
-        "readme",
-        "license",
-        "files",
-        "dfx",
-        "moc",
-        "donation"
-    ];
-    for (let key of Object.keys(config.package)) {
-        if (!packageKeys.includes(key)) {
-            console.log(chalk15.red("Error: ") + `Unknown config key 'package.${key}'`);
-            process.exit(1);
-        }
-    }
-    let keysMax = {
-        name: 50,
-        version: 20,
-        keywords: 10,
-        description: 200,
-        repository: 300,
-        documentation: 300,
-        homepage: 300,
-        readme: 100,
-        license: 30,
-        files: 20,
-        dfx: 10,
-        moc: 10,
-        donation: 64,
-        root: 50
-    };
-    for (let [key, max] of Object.entries(keysMax)) {
-        if (config.package[key] && config.package[key].length > max) {
-            console.log(chalk15.red("Error: ") + `package.${key} value max length is ${max}`);
-            process.exit(1);
-        }
-    }
-    if (config.dependencies) {
-        if (Object.keys(config.dependencies).length > 100) {
-            console.log(chalk15.red("Error: ") + "max dependencies is 100");
-            process.exit(1);
-        }
-        for (let dep of Object.values(config.dependencies)) {
-            if (dep.path) {
-                console.log(chalk15.red("Error: ") + "you can't publish packages with local dependencies");
-                process.exit(1);
-            }
-            delete dep.path;
-        }
-    }
-    if (config["dev-dependencies"]) {
-        if (Object.keys(config["dev-dependencies"]).length > 100) {
-            console.log(chalk15.red("Error: ") + "max dev-dependencies is 100");
-            process.exit(1);
-        }
-        for (let dep of Object.values(config["dev-dependencies"])) {
-            if (dep.path) {
-                console.log(chalk15.red("Error: ") + "you can't publish packages with local dev-dependencies");
-                process.exit(1);
-            }
-            delete dep.path;
-        }
-    }
-    if (config.package.keywords) {
-        for (let keyword of config.package.keywords) {
-            if (keyword.length > 20) {
-                console.log(chalk15.red("Error: ") + "max keyword length is 20");
-                return;
-            }
-        }
-    }
-    if (config.package.files) {
-        for (let file of config.package.files) {
-            if (file.startsWith("/") || file.startsWith("../")) {
-                console.log(chalk15.red("Error: ") + "file path cannot start with '/' or '../'");
-                return;
-            }
-        }
-    }
-    let toBackendDep = (dep) => {
-        return {
-            ...dep,
-            version: dep.version || "",
-            repo: dep.repo || ""
-        };
-    };
-    let backendPkgConfig = {
-        name: config.package.name,
-        version: config.package.version,
-        keywords: config.package.keywords || [],
-        description: config.package.description || "",
-        repository: config.package.repository || "",
-        homepage: config.package.homepage || "",
-        documentation: config.package.documentation || "",
-        baseDir: "src",
-        readme: "README.md",
-        license: config.package.license || "",
-        dfx: config.package.dfx || "",
-        moc: config.package.moc || "",
-        donation: config.package.donation || "",
-        dependencies: Object.values(config.dependencies || {}).map(toBackendDep),
-        devDependencies: Object.values(config["dev-dependencies"] || {}).map(toBackendDep),
-        scripts: []
-    };
-    let defaultFiles = [
-        "mops.toml",
-        "README.md",
-        "LICENSE",
-        "NOTICE",
-        "!.mops/**",
-        "!test/**",
-        "!tests/**",
-        "!**/*.test.mo",
-        "!**/*.Test.mo",
-        "!bench/**",
-        "!benchmark/**",
-        "!**/*.bench.mo",
-        "!**/*.Bench.mo"
-    ];
-    let files = config.package.files || ["**/*.mo"];
-    files = [...files, ...defaultFiles];
-    files = globbySync([...files, ...defaultFiles]);
-    let docsFile = path13.join(rootDir, ".mops/.docs/docs.tgz");
-    if (options.docs) {
-        console.log("Generating documentation...");
-        await docs({ silent: true });
-        if (fs10.existsSync(docsFile)) {
-            files.unshift(docsFile);
-        }
-    }
-    if (!files.includes("mops.toml")) {
-        console.log(chalk15.red("Error: ") + " please add mops.toml file");
-        process.exit(1);
-    }
-    if (!files.includes("README.md")) {
-        console.log(chalk15.red("Error: ") + " please add README.md file");
-        process.exit(1);
-    }
-    for (let file of files) {
-        if (!minimatch(file, "**/*.{mo,did,md,toml}") && !file.toLowerCase().endsWith("license") && !file.toLowerCase().endsWith("notice") && file !== docsFile) {
-            console.log(chalk15.red("Error: ") + `file ${file} has unsupported extension. Allowed: .mo, .did, .md, .toml`);
-            process.exit(1);
-        }
-    }
-    console.log("Parsing CHANGELOG.md...");
-    let changelog = parseChangelog(config.package.version);
-    if (!changelog && config.package.repository) {
-        console.log("Fetching release notes from GitHub...");
-        changelog = await fetchGitHubReleaseNotes(config.package.repository, config.package.version);
-    }
-    if (changelog) {
-        console.log("Changelog:");
-        console.log(chalk15.gray(changelog));
-    }
-    let reporter = new SilentReporter();
-    if (options.test) {
-        console.log("Running tests...");
-        await testWithReporter(reporter);
-        if (reporter.failed > 0) {
-            console.log(chalk15.red("Error: ") + "tests failed");
-            process.exit(1);
-        }
-    }
-    let total = files.length + 2;
-    let step = 0;
-    function progress() {
-        step++;
-        logUpdate5(`Uploading files ${progressBar(step, total)}`);
-    }
-    let identity = await getIdentity();
-    let actor = await mainActor(identity);
-    progress();
-    let publishing = await actor.startPublish(backendPkgConfig);
-    if ("err" in publishing) {
-        console.log(chalk15.red("Error: ") + publishing.err);
-        return;
-    }
-    let puiblishingId = publishing.ok;
-    if (options.test) {
-        await actor.uploadTestStats(puiblishingId, {
-            passed: BigInt(reporter.passed),
-            passedNames: reporter.passedNamesFlat
-        });
-    }
-    if (changelog) {
-        await actor.uploadNotes(puiblishingId, changelog);
-    }
-    await parallel(8, files, async (file) => {
-        progress();
-        let chunkSize = 1024 * 1024 + 512 * 1024;
-        let content = fs10.readFileSync(file);
-        let chunkCount = Math.ceil(content.length / chunkSize);
-        let firstChunk = Array.from(content.slice(0, chunkSize));
-        if (file === docsFile) {
-            file = path13.basename(file);
-        }
-        let res2 = await actor.startFileUpload(puiblishingId, file, BigInt(chunkCount), firstChunk);
-        if ("err" in res2) {
-            console.log(chalk15.red("Error: ") + res2.err);
-            return;
-        }
-        let fileId = res2.ok;
-        for (let i = 1; i < chunkCount; i++) {
-            let start = i * chunkSize;
-            let chunk = Array.from(content.slice(start, start + chunkSize));
-            let res3 = await actor.uploadFileChunk(puiblishingId, fileId, BigInt(i), chunk);
-            if ("err" in res3) {
-                console.log(chalk15.red("Error: ") + res3.err);
-                return;
-            }
-        }
-    });
-    fs10.rmSync(path13.join(rootDir, ".mops/.docs"), { force: true, recursive: true });
-    progress();
-    let res = await actor.finishPublish(puiblishingId);
-    if ("err" in res) {
-        console.log(chalk15.red("Error: ") + res.err);
-        return;
-    }
-    console.log(chalk15.green("Published ") + `${config.package.name}@${config.package.version}`);
-}
-function parseChangelog(version) {
-    let rootDir = getRootDir();
-    let changelogFile = "";
-    let files = ["CHANGELOG.md", "Changelog.md", "changelog.md"];
-    for (let file of files) {
-        if (fs10.existsSync(path13.join(rootDir, file))) {
-            changelogFile = path13.join(rootDir, file);
-            break;
-        }
-    }
-    if (!changelogFile) {
-        console.log(chalk15.yellow("CHANGELOG.md not found"));
-        return "";
-    }
-    let str = fs10.readFileSync(changelogFile, "utf-8");
-    let changelog = findChangelogEntry(str, version);
-    if (!changelog) {
-        console.log(chalk15.yellow("No changelog entry found"));
-    }
-    return changelog || "";
-}
-async function fetchGitHubReleaseNotes(repo, version) {
-    let repoPath = new URL(repo).pathname;
-    let res = await fetch(`https://api.github.com/repos${repoPath}/releases/tags/${version}`);
-    let release = await res.json();
-    if (release.message === "Not Found") {
-        res = await fetch(`https://api.github.com/repos${repoPath}/releases/tags/v${version}`);
-        release = await res.json();
-        if (release.message === "Not Found") {
-            console.log(chalk15.yellow(`No GitHub release found with name ${version} or v${version}`));
-            return "";
-        }
-    }
-    return release.body;
-}
-function findChangelogEntry(changelog, version) {
-    let tree = fromMarkdown(changelog);
-    let found = false;
-    let nodes = [];
-    for (let node of tree.children) {
-        if (found) {
-            if (node.type === "heading") {
-                break;
-            }
-            else {
-                nodes.push(node);
-            }
-        }
-        else if (node.type === "heading" && toMarkdown(node).match(new RegExp(`\\b${version}\\b`))) {
-            found = true;
-        }
-    }
-    return toMarkdown({
-        type: "root",
-        children: nodes
-    });
-}
-// dist/commands/import-identity.js
-import fs11 from "node:fs";
-import path14 from "node:path";
-import chalk16 from "chalk";
-import prompts5 from "prompts";
-import { deleteSync as deleteSync3 } from "del";
-async function importPem(data, options = { encrypt: true }) {
-    try {
-        if (!fs11.existsSync(globalConfigDir)) {
-            fs11.mkdirSync(globalConfigDir);
-        }
-        let password = "";
-        if (options.encrypt) {
-            let res = await prompts5({
-                type: "invisible",
-                name: "password",
-                message: "Enter password to encrypt identity.pem"
-            });
-            password = res.password;
-            if (!password) {
-                let res2 = await prompts5({
-                    type: "confirm",
-                    name: "ok",
-                    message: "Are you sure you don't want to protect your identity.pem with a password?"
-                });
-                if (!res2.ok) {
-                    console.log("aborted");
-                    return;
-                }
-            }
-        }
-        let identityPem = path14.resolve(globalConfigDir, "identity.pem");
-        let identityPemEncrypted = path14.resolve(globalConfigDir, "identity.pem.encrypted");
-        deleteSync3([identityPem, identityPemEncrypted], { force: true });
-        if (password) {
-            let encrypted = await encrypt(Buffer.from(data), password);
-            fs11.writeFileSync(identityPemEncrypted, encrypted);
-        }
-        else {
-            fs11.writeFileSync(identityPem, data);
-        }
-        console.log(chalk16.green("Success"));
-    }
-    catch (err) {
-        console.log(chalk16.red("Error: ") + err);
-    }
-}
-// dist/commands/whoami.js
-import chalk17 from "chalk";
-async function whoami() {
-    let identity = await getIdentity();
-    if (identity) {
-        console.log(identity.getPrincipal().toText());
-    }
-    else {
-        console.log(chalk17.red("Error: ") + "identity not found. Run " + chalk17.greenBright("mops import-identity") + " command.");
-    }
-}
-// dist/commands/search.js
-import asTable from "as-table";
-import chalk18 from "chalk";
-async function search(text) {
-    let actor = await mainActor();
-    let [packages, _pageCount] = await actor.search(text, [], []);
-    if (!packages.length) {
-        console.log("Packages not found");
-        return;
-    }
-    let ellipsis = (text2, max) => {
-        if (text2.length <= max) {
-            return text2;
-        }
-        else {
-            return text2.slice(0, max) + "\u2026";
-        }
-    };
-    let maxNameLength = Math.max(...packages.map((a) => a.config.name.length));
-    let table = packages.map((item) => {
-        return {
-            NAME: chalk18.bold(item.config.name),
-            DESCRIPTION: ellipsis(item.config.description, process.stdout.columns - 40 - maxNameLength),
-            VERSION: item.config.version,
-            UPDATED: new Date(Number(item.publication.time / 1000000n)).toISOString().split("T")[0]
-        };
-    });
-    console.log("");
-    console.log(asTable.configure({
-        delimiter: chalk18.gray(" | "),
-        dash: chalk18.gray("\u2500"),
-        title: (t) => chalk18.gray.bold(t)
-    })(table));
-    console.log("");
-}
-// dist/commands/add.js
-import path15 from "node:path";
-import chalk19 from "chalk";
-import logUpdate6 from "log-update";
-async function add(name, { verbose = false, dev = false, lockfile } = {}, asName) {
-    if (!checkConfigFile()) {
-        return;
-    }
-    let config = readConfig();
-    if (dev) {
-        if (!config["dev-dependencies"]) {
-            config["dev-dependencies"] = {};
-        }
-    }
-    else {
-        if (!config.dependencies) {
-            config.dependencies = {};
-        }
-    }
-    let pkgDetails;
-    if (name.startsWith("./") || name.startsWith("../") || name.startsWith("/")) {
-        pkgDetails = {
-            name: path15.parse(name).name === "." ? "_" : path15.parse(name).name,
-            path: name,
-            repo: "",
-            version: ""
-        };
-    }
-    else if (name.startsWith("https://github.com") || name.split("/").length > 1) {
-        let { org, gitName, branch, commitHash } = parseGithubURL(name);
-        if (!commitHash) {
-            let commit = await getGithubCommit(`${org}/${gitName}`, branch);
-            if (!commit.sha) {
-                throw Error(`Could not find commit hash for ${name}`);
-            }
-            commitHash = commit.sha;
-        }
-        pkgDetails = {
-            name: asName || parseGithubURL(name).gitName,
-            repo: `https://github.com/${org}/${gitName}#${branch}@${commitHash}`,
-            version: ""
-        };
-    }
-    else {
-        let ver;
-        if (name.includes("@")) {
-            [name, ver] = name.split("@");
-        }
-        else {
-            let versionRes = await getHighestVersion(name);
-            if ("err" in versionRes) {
-                console.log(chalk19.red("Error: ") + versionRes.err);
-                return;
-            }
-            ver = versionRes.ok;
-        }
-        pkgDetails = {
-            name,
-            repo: "",
-            version: ver
-        };
-    }
-    let installedPackages = {};
-    if (pkgDetails.repo) {
-        await installFromGithub(pkgDetails.name, pkgDetails.repo, { verbose });
-    }
-    else if (!pkgDetails.path) {
-        let res = await install(pkgDetails.name, pkgDetails.version, { verbose });
-        if (res === false) {
-            return;
-        }
-        installedPackages = { ...installedPackages, ...res };
-    }
-    const depsProp = dev ? "dev-dependencies" : "dependencies";
-    let deps = config[depsProp];
-    if (deps) {
-        deps[pkgDetails.name] = pkgDetails;
-    }
-    else {
-        throw Error(`Invalid config file: [${depsProp}] not found`);
-    }
-    writeConfig(config);
-    await Promise.all([
-        notifyInstalls(Object.keys(installedPackages))
-        // checkIntegrity(lockfile),
-    ]);
-    logUpdate6.clear();
-    console.log(chalk19.green("Package installed ") + `${pkgDetails.name} = "${pkgDetails.repo || pkgDetails.path || pkgDetails.version}"`);
-}
-// dist/commands/self-update.js
-import child_process from "node:child_process";
-function selfUpdate({ detached = false } = {}) {
-    console.log("Updating mops CLI...");
-    child_process.spawn("npm", ["install", "ic-mops", "-g"], { stdio: "inherit", detached });
-}
-// dist/commands/remove.js
-import fs12 from "node:fs";
-import { deleteSync as deleteSync4 } from "del";
-import chalk20 from "chalk";
-async function remove(name, { dev = false, verbose = false, dryRun = false, lockfile } = {}) {
-    if (!checkConfigFile()) {
-        return;
-    }
-    function getTransitiveDependencies(config2, exceptPkgId) {
-        let deps2 = Object.values(config2.dependencies || {});
-        let devDeps = Object.values(config2["dev-dependencies"] || {});
-        return [...deps2, ...devDeps].filter((dep) => {
-            let depId = dep.name + "@" + dep.version;
-            return depId !== exceptPkgId;
-        }).map((dep) => {
-            return [dep, ...getTransitiveDependenciesOf(dep.name, dep.version, dep.repo)];
-        }).flat();
-    }
-    function getTransitiveDependenciesOf(name2, version2, repo) {
-        let pkgDir = "";
-        if (repo) {
-            pkgDir = formatGithubDir(name2, repo);
-        }
-        else if (version2) {
-            pkgDir = formatDir(name2, version2);
-        }
-        let configFile = pkgDir + "/mops.toml";
-        if (!fs12.existsSync(configFile)) {
-            verbose && console.log("no config", configFile);
-            return [];
-        }
-        let config2 = readConfig(configFile);
-        let deps2 = Object.values(config2.dependencies || {}).map((dep) => {
-            return [dep, ...getTransitiveDependenciesOf(dep.name, dep.version)];
-        }).flat();
-        return deps2;
-    }
-    let config = readConfig();
-    let deps = dev ? config["dev-dependencies"] : config.dependencies;
-    deps = deps || {};
-    let pkgDetails = deps[name];
-    if (!pkgDetails) {
-        return console.log(chalk20.red("Error: ") + `No ${dev ? "dev " : ""}dependency to remove "${name}"`);
-    }
-    let version = pkgDetails.version;
-    let packageId = `${name}@${version}`;
-    let transitiveDeps = getTransitiveDependencies(config, packageId);
-    let transitiveDepIds = new Set(transitiveDeps.map((dep) => {
-        return dep.name + "@" + dep.version;
-    }));
-    let transitiveDepsOfPackage = [pkgDetails, ...getTransitiveDependenciesOf(name, version)];
-    for (let dep of transitiveDepsOfPackage) {
-        let depId = dep.name + "@" + dep.version;
-        if (transitiveDepIds.has(depId)) {
-            verbose && console.log(`Ignored transitive dependency ${depId} (other deps depend on it)`);
-            continue;
-        }
-        let pkgDir;
-        if (dep.repo) {
-            pkgDir = formatGithubDir(dep.name, dep.repo);
-        }
-        else if (dep.version) {
-            pkgDir = formatDir(dep.name, dep.version);
-        }
-        if (pkgDir && fs12.existsSync(pkgDir)) {
-            dryRun || deleteSync4([`${pkgDir}`], { force: true });
-            verbose && console.log(`Removed local cache ${pkgDir}`);
-        }
-    }
-    if (!dev && config.dependencies) {
-        delete config.dependencies[name];
-    }
-    if (dev && config["dev-dependencies"]) {
-        delete config["dev-dependencies"][name];
-    }
-    dryRun || writeConfig(config);
-    console.log(chalk20.green("Package removed ") + `${name} = "${version}"`);
-}
-// dist/commands/user.js
-import chalk21 from "chalk";
-async function getUserProp(prop) {
-    var _a;
-    let actor = await mainActor();
-    let identity = await getIdentity();
-    if (!identity) {
-        console.log(chalk21.red("Error: ") + "No identity found");
-        process.exit(1);
-    }
-    let res = await actor.getUser(identity.getPrincipal());
-    console.log(((_a = res[0]) == null ? void 0 : _a[prop]) || "");
-}
-async function setUserProp(prop, value) {
-    let identity = await getIdentity();
-    let actor = await mainActor(identity);
-    let res = await actor.setUserProp(prop, value);
-    if ("ok" in res) {
-        console.log(chalk21.green("Success!"));
-    }
-    else {
-        console.log(chalk21.red("Error: ") + res.err);
-    }
-}
-// dist/commands/bump.js
-import prompts6 from "prompts";
-import chalk22 from "chalk";
-async function bump(part) {
-    if (!checkConfigFile()) {
-        return;
-    }
-    if (part && !["major", "minor", "patch"].includes(part)) {
-        console.log(chalk22.red("Unknown version part. Available parts: major, minor, patch"));
-        process.exit(1);
-    }
-    let config = readConfig();
-    if (!config.package) {
-        console.log(chalk22.red("No [package] section found in mops.toml."));
-        process.exit(1);
-    }
-    console.log(`Current version: ${chalk22.yellow.bold(config.package.version)}`);
-    if (!part) {
-        let res = await prompts6({
-            type: "select",
-            name: "part",
-            message: "Select new version:",
-            choices: [
-                { title: `${updateVersion(config.package.version, "major")} ${chalk22.dim("(major, breaking changes)")}`, value: "major" },
-                { title: `${updateVersion(config.package.version, "minor")} ${chalk22.dim("(minor, new features)")}`, value: "minor" },
-                { title: `${updateVersion(config.package.version, "patch")} ${chalk22.dim("(patch, bug fixes)")}`, value: "patch" }
-            ],
-            initial: 2
-        });
-        if (!res.part) {
-            return;
-        }
-        part = res.part;
-    }
-    config.package.version = updateVersion(config.package.version, part);
-    writeConfig(config);
-    console.log(`Updated version: ${chalk22.green.bold(config.package.version)}`);
-}
-function updateVersion(version, part) {
-    let parts = version.split(".");
-    let idx = ["major", "minor", "patch"].indexOf(part);
-    if (!parts[idx]) {
-        throw new Error(`Invalid version part: ${part}`);
-    }
-    parts[idx] = String(parseInt(parts[idx] || "0") + 1);
-    for (let i = idx + 1; i < parts.length; i++) {
-        parts[i] = "0";
-    }
-    return parts.join(".");
-}
-// dist/commands/sync.js
-import path16 from "node:path";
-import { execSync as execSync4 } from "node:child_process";
-import { globSync as globSync3 } from "glob";
-import chalk23 from "chalk";
-async function sync({ lockfile } = {}) {
-    if (!checkConfigFile()) {
-        return;
-    }
-    let missing = await getMissingPackages();
-    let unused = await getUnusedPackages();
-    missing.length && console.log(`${chalk23.yellow("Missing packages:")} ${missing.join(", ")}`);
-    unused.length && console.log(`${chalk23.yellow("Unused packages:")} ${unused.join(", ")}`);
-    let config = readConfig();
-    let deps = new Set(Object.keys(config.dependencies || {}));
-    let devDeps = new Set(Object.keys(config["dev-dependencies"] || {}));
-    for (let pkg of missing) {
-        await add(pkg, { lockfile: "ignore" });
-    }
-    for (let pkg of unused) {
-        let dev = devDeps.has(pkg) && !deps.has(pkg);
-        await remove(pkg, { dev, lockfile: "ignore" });
-    }
-    await checkIntegrity(lockfile);
-}
-var ignore2 = [
-    "**/node_modules/**",
-    "**/.vessel/**",
-    "**/.git/**",
-    "**/.mops/**"
-];
-var mocPath2 = "";
-function getMocPath() {
-    if (!mocPath2) {
-        mocPath2 = process.env.DFX_MOC_PATH || "";
-    }
-    if (!mocPath2) {
-        try {
-            mocPath2 = execSync4("dfx cache show").toString().trim() + "/moc";
-        }
-        catch {
-        }
-    }
-    if (!mocPath2) {
-        mocPath2 = "moc";
-    }
-    return mocPath2;
-}
-async function getUsedPackages() {
-    let rootDir = getRootDir();
-    let files = globSync3("**/*.mo", {
-        cwd: rootDir,
-        nocase: true,
-        ignore: ignore2
-    });
-    let packages = /* @__PURE__ */ new Set();
-    for (let file of files) {
-        let deps = execSync4(`${getMocPath()} --print-deps ${path16.join(rootDir, file)}`).toString().trim().split("\n");
-        for (let dep of deps) {
-            if (dep.startsWith("mo:") && !dep.startsWith("mo:prim") && !dep.startsWith("mo:\u26D4")) {
-                packages.add(dep.replace(/^mo:([^/]+).*$/, "$1"));
-            }
-        }
-    }
-    return [...packages];
-}
-async function getMissingPackages() {
-    let config = readConfig();
-    let allDeps = [...Object.keys(config.dependencies || {}), ...Object.keys(config["dev-dependencies"] || {})];
-    let missing = new Set(await getUsedPackages());
-    for (let pkg of allDeps) {
-        missing.delete(pkg);
-    }
-    return [...missing];
-}
-async function getUnusedPackages() {
-    let config = readConfig();
-    let allDeps = /* @__PURE__ */ new Set([...Object.keys(config.dependencies || {}), ...Object.keys(config["dev-dependencies"] || {})]);
-    let used = await getUsedPackages();
-    for (let pkg of used) {
-        allDeps.delete(pkg);
-    }
-    return [...allDeps];
-}
-// dist/commands/outdated.js
-import chalk25 from "chalk";
-// dist/commands/available-updates.js
-import chalk24 from "chalk";
-async function getAvailableUpdates(config, pkg) {
-    let deps = Object.values(config.dependencies || {});
-    let devDeps = Object.values(config["dev-dependencies"] || {});
-    let allDeps = [...deps, ...devDeps].filter((dep) => dep.version);
-    let depsToUpdate = pkg ? allDeps.filter((dep) => dep.name === pkg) : allDeps;
-    let getCurrentVersion = (pkg2) => {
-        for (let dep of allDeps) {
-            if (dep.name === pkg2 && dep.version) {
-                return dep.version;
-            }
-        }
-        return "";
-    };
-    let actor = await mainActor();
-    let res = await actor.getHighestSemverBatch(depsToUpdate.map((dep) => [dep.name, dep.version || "", { major: null }]));
-    if ("err" in res) {
-        console.log(chalk24.red("Error:"), res.err);
-        process.exit(1);
-    }
-    return res.ok.filter((dep) => dep[1] !== getCurrentVersion(dep[0])).map((dep) => [dep[0], getCurrentVersion(dep[0]), dep[1]]);
-}
-// dist/commands/outdated.js
-async function outdated() {
-    if (!checkConfigFile()) {
-        return;
-    }
-    let config = readConfig();
-    let available = await getAvailableUpdates(config);
-    if (available.length === 0) {
-        console.log(chalk25.green("All dependencies are up to date!"));
-    }
-    else {
-        console.log("Available updates:");
-        for (let dep of available) {
-            console.log(`${dep[0]} ${chalk25.yellow(dep[1])} -> ${chalk25.green(dep[2])}`);
-        }
-    }
-}
-// dist/commands/update.js
-import chalk26 from "chalk";
-async function update(pkg, { lockfile } = {}) {
-    var _a, _b, _c, _d;
-    if (!checkConfigFile()) {
-        return;
-    }
-    let config = readConfig();
-    if (pkg && !((_a = config.dependencies) == null ? void 0 : _a[pkg]) && !((_b = config["dev-dependencies"]) == null ? void 0 : _b[pkg])) {
-        console.log(chalk26.red(`Package "${pkg}" is not installed!`));
-        return;
-    }
-    let deps = Object.values(config.dependencies || {});
-    let devDeps = Object.values(config["dev-dependencies"] || {});
-    let githubDeps = [...deps, ...devDeps].filter((dep) => dep.repo);
-    if (pkg) {
-        githubDeps = githubDeps.filter((dep) => dep.name === pkg);
-    }
-    for (let dep of githubDeps) {
-        let { org, gitName, branch, commitHash } = parseGithubURL(dep.repo || "");
-        let dev = !!((_c = config["dev-dependencies"]) == null ? void 0 : _c[dep.name]);
-        let commit = await getGithubCommit(`${org}/${gitName}`, branch);
-        if (commit.sha !== commitHash) {
-            await add(`https://github.com/${org}/${gitName}#${branch}@${commit.sha}`, { dev }, dep.name);
-        }
-    }
-    let available = await getAvailableUpdates(config, pkg);
-    if (available.length === 0) {
-        if (pkg) {
-            console.log(chalk26.green(`Package "${pkg}" is up to date!`));
-        }
-        else {
-            console.log(chalk26.green("All dependencies are up to date!"));
-        }
-    }
-    else {
-        for (let dep of available) {
-            let dev = !!((_d = config["dev-dependencies"]) == null ? void 0 : _d[dep[0]]);
-            await add(`${dep[0]}@${dep[2]}`, { dev });
-        }
-    }
-    await checkIntegrity(lockfile);
-}
-// dist/commands/bench.js
-import { execSync as execSync8 } from "node:child_process";
-import path17 from "node:path";
-import fs13 from "node:fs";
-import os2 from "node:os";
-import chalk27 from "chalk";
-import { globSync as globSync4 } from "glob";
-import { markdownTable } from "markdown-table";
-import logUpdate7 from "log-update";
-// dist/declarations/bench/index.js
-import { Actor as Actor4, HttpAgent as HttpAgent4 } from "@dfinity/agent";
-// dist/declarations/bench/bench.did.js
-var idlFactory3 = ({ IDL }) => {
-    const BenchSchema = IDL.Record({
-        "cols": IDL.Vec(IDL.Text),
-        "name": IDL.Text,
-        "rows": IDL.Vec(IDL.Text),
-        "description": IDL.Text
-    });
-    const BenchResult = IDL.Record({
-        "instructions": IDL.Int,
-        "rts_memory_size": IDL.Int,
-        "rts_total_allocation": IDL.Int,
-        "rts_collector_instructions": IDL.Int,
-        "rts_mutator_instructions": IDL.Int,
-        "rts_heap_size": IDL.Int
-    });
-    const anon_class_10_1 = IDL.Service({
-        "getSchema": IDL.Func([], [BenchSchema], ["query"]),
-        "getStats": IDL.Func([], [BenchResult], ["query"]),
-        "init": IDL.Func([], [BenchSchema], []),
-        "runCellQuery": IDL.Func([IDL.Nat, IDL.Nat], [BenchResult], ["query"]),
-        "runCellUpdate": IDL.Func([IDL.Nat, IDL.Nat], [BenchResult], []),
-        "runCellUpdateAwait": IDL.Func([IDL.Nat, IDL.Nat], [BenchResult], [])
-    });
-    return anon_class_10_1;
-};
-// dist/declarations/bench/index.js
-var canisterId2 = process.env.CANISTER_ID_BENCH || process.env.BENCH_CANISTER_ID;
-var createActor = (canisterId3, options = {}) => {
-    const agent = options.agent || new HttpAgent4({ ...options.agentOptions });
-    if (options.agent && options.agentOptions) {
-        console.warn("Detected both agent and agentOptions passed to createActor. Ignoring agentOptions and proceeding with the provided agent.");
-    }
-    if (process.env.DFX_NETWORK !== "ic") {
-        agent.fetchRootKey().catch((err) => {
-            console.warn("Unable to fetch root key. Check to ensure that your local replica is running");
-            console.error(err);
-        });
-    }
-    return Actor4.createActor(idlFactory3, {
-        agent,
-        canisterId: canisterId3,
-        ...options.actorOptions
-    });
-};
-// dist/helpers/get-moc-version.js
-import { execSync as execSync6 } from "node:child_process";
-// dist/helpers/get-moc-path.js
-import { execSync as execSync5 } from "node:child_process";
-function getMocPath2() {
-    let mocPath3 = process.env.DFX_MOC_PATH;
-    if (!mocPath3) {
-        mocPath3 = execSync5("dfx cache show").toString().trim() + "/moc";
-    }
-    if (!mocPath3) {
-        mocPath3 = "moc";
-    }
-    return mocPath3;
-}
-// dist/helpers/get-moc-version.js
-function getMocVersion() {
-    let mocPath3 = getMocPath2();
-    let match = execSync6(mocPath3).toString().trim().match(/Motoko compiler ([^\s]+) .*/);
-    return (match == null ? void 0 : match[1]) || "";
-}
-// dist/helpers/get-dfx-version.js
-import { execSync as execSync7 } from "node:child_process";
-function getDfxVersion() {
-    try {
-        let res = execSync7("dfx --version").toString();
-        return res.trim().split("dfx ")[1] || "";
-    }
-    catch {
-    }
-    return "";
-}
-// dist/commands/bench.js
-import { execaCommand as execaCommand2 } from "execa";
-var ignore3 = [
-    "**/node_modules/**",
-    "**/.mops/**",
-    "**/.vessel/**",
-    "**/.git/**"
-];
-var globConfig2 = {
-    nocase: true,
-    ignore: ignore3
-};
-async function bench(filter = "", options = {}) {
-    let defaultOptions = {
-        moc: getMocVersion(),
-        dfx: getDfxVersion(),
-        gc: "incremental",
-        forceGc: true,
-        save: false,
-        compare: false,
-        verbose: false
-    };
-    options = { ...defaultOptions, ...options };
-    options.verbose && console.log(options);
-    let rootDir = getRootDir();
-    let globStr = "**/bench?(mark)/**/*.bench.mo";
-    if (filter) {
-        globStr = `**/bench?(mark)/**/*${filter}*.mo`;
-    }
-    let files = globSync4(path17.join(rootDir, globStr), globConfig2);
-    if (!files.length) {
-        if (filter) {
-            console.log(`No benchmark files found for filter '${filter}'`);
-            return false;
-        }
-        console.log("No *.bench.mo files found");
-        console.log("Put your benchmark code in 'bench' directory in *.bench.mo files");
-        return false;
-    }
-    files.sort();
-    let benchDir = `${getRootDir()}/.mops/.bench/`;
-    fs13.rmSync(benchDir, { recursive: true, force: true });
-    fs13.mkdirSync(benchDir, { recursive: true });
-    console.log("Benchmark files:");
-    for (let file of files) {
-        console.log(chalk27.gray(`\u2022 ${absToRel(file)}`));
-    }
-    console.log("");
-    console.log("=".repeat(50));
-    console.log("");
-    console.log("Starting dfx replica...");
-    startDfx(options.verbose);
-    console.log("Deploying canisters...");
-    await parallel(os2.cpus().length, files, async (file) => {
-        try {
-            await deployBenchFile(file, options);
-        }
-        catch (err) {
-            console.error("Unexpected error. Stopping dfx replica...");
-            stopDfx(options.verbose);
-            throw err;
-        }
-    });
-    await parallel(1, files, async (file) => {
-        console.log("\n" + "\u2014".repeat(50));
-        console.log(`
-Running ${chalk27.gray(absToRel(file))}...`);
-        console.log("");
-        try {
-            await runBenchFile(file, options);
-        }
-        catch (err) {
-            console.error("Unexpected error. Stopping dfx replica...");
-            stopDfx(options.verbose);
-            throw err;
-        }
-    });
-    console.log("Stopping dfx replica...");
-    stopDfx(options.verbose);
-    fs13.rmSync(benchDir, { recursive: true, force: true });
-    return true;
-}
-function getMocArgs(options) {
-    let args = "";
-    if (options.forceGc) {
-        args += " --force-gc";
-    }
-    if (options.gc) {
-        args += ` --${options.gc}-gc`;
-    }
-    return args;
-}
-function dfxJson(canisterName, options = {}) {
-    options || console.log(options);
-    let canisters = {};
-    if (canisterName) {
-        canisters[canisterName] = {
-            type: "custom",
-            wasm: "canister.wasm",
-            candid: "canister.did"
-        };
-    }
-    return {
-        version: 1,
-        canisters,
-        defaults: {
-            build: {
-                packtool: "mops sources"
-            }
-        },
-        networks: {
-            local: {
-                type: "ephemeral",
-                bind: "127.0.0.1:4944"
-            }
-        }
-    };
-}
-function startDfx(verbose = false) {
-    stopDfx(verbose);
-    let dir = path17.join(getRootDir(), ".mops/.bench");
-    fs13.writeFileSync(path17.join(dir, "dfx.json"), JSON.stringify(dfxJson(""), null, 2));
-    execSync8("dfx start --background --clean --artificial-delay 0" + (verbose ? "" : " -qqqq"), { cwd: dir, stdio: ["inherit", verbose ? "inherit" : "ignore", "inherit"] });
-}
-function stopDfx(verbose = false) {
-    let dir = path17.join(getRootDir(), ".mops/.bench");
-    execSync8("dfx stop" + (verbose ? "" : " -qqqq"), { cwd: dir, stdio: ["pipe", verbose ? "inherit" : "ignore", "pipe"] });
-}
-async function deployBenchFile(file, options = {}) {
-    let rootDir = getRootDir();
-    let tempDir = path17.join(rootDir, ".mops/.bench/", path17.parse(file).name);
-    let canisterName = path17.parse(file).name;
-    fs13.mkdirSync(tempDir, { recursive: true });
-    fs13.writeFileSync(path17.join(tempDir, "dfx.json"), JSON.stringify(dfxJson(canisterName, options), null, 2));
-    let benchCanisterData = fs13.readFileSync(new URL("./bench/bench-canister.mo", import.meta.url), "utf8");
-    benchCanisterData = benchCanisterData.replace("./user-bench", path17.relative(tempDir, file).replace(/.mo$/g, ""));
-    fs13.writeFileSync(path17.join(tempDir, "canister.mo"), benchCanisterData);
-    let mocPath3 = getMocPath2();
-    let mocArgs = getMocArgs(options);
-    options.verbose && console.time(`build ${canisterName}`);
-    await execaCommand2(`${mocPath3} -c --idl canister.mo ${mocArgs} ${(await sources({ cwd: tempDir })).join(" ")}`, { cwd: tempDir, stdio: options.verbose ? "pipe" : ["pipe", "ignore", "pipe"] });
-    options.verbose && console.timeEnd(`build ${canisterName}`);
-    options.verbose && console.time(`deploy ${canisterName}`);
-    await execaCommand2(`dfx deploy ${canisterName} --mode reinstall --yes --identity anonymous`, { cwd: tempDir, stdio: options.verbose ? "pipe" : ["pipe", "ignore", "pipe"] });
-    options.verbose && console.timeEnd(`deploy ${canisterName}`);
-    options.verbose && console.time(`init ${canisterName}`);
-    let canisterId3 = execSync8(`dfx canister id ${canisterName}`, { cwd: tempDir }).toString().trim();
-    let actor = await createActor(canisterId3, {
-        agentOptions: {
-            host: "http://127.0.0.1:4944"
-        }
-    });
-    await actor.init();
-    options.verbose && console.timeEnd(`init ${canisterName}`);
-}
-async function runBenchFile(file, options = {}) {
-    let rootDir = getRootDir();
-    let tempDir = path17.join(rootDir, ".mops/.bench/", path17.parse(file).name);
-    let canisterName = path17.parse(file).name;
-    let canisterId3 = execSync8(`dfx canister id ${canisterName}`, { cwd: tempDir }).toString().trim();
-    let actor = await createActor(canisterId3, {
-        agentOptions: {
-            host: "http://127.0.0.1:4944"
-        }
-    });
-    let schema = await actor.getSchema();
-    let prevResults;
-    let resultsJsonFile = path17.join(rootDir, ".bench", `${path17.parse(file).name}.json`);
-    if (options.compare) {
-        if (fs13.existsSync(resultsJsonFile)) {
-            let prevResultsJson = JSON.parse(fs13.readFileSync(resultsJsonFile).toString());
-            prevResults = new Map(prevResultsJson.results);
-        }
-        else {
-            console.log(chalk27.yellow(`No previous results found "${resultsJsonFile}"`));
-        }
-    }
-    let results = /* @__PURE__ */ new Map();
-    let formatNumber = (n) => {
-        return n.toLocaleString("en-US").replaceAll(",", "_");
-    };
-    let getTable = (prop) => {
-        let resArr = [["", ...schema.cols]];
-        for (let [_rowIndex, row] of schema.rows.entries()) {
-            let curRow = [row];
-            for (let [_colIndex, col] of schema.cols.entries()) {
-                let res = results.get(`${row}:${col}`);
-                if (res) {
-                    let diff = "";
-                    if (options.compare && prevResults) {
-                        let prevRes = prevResults.get(`${row}:${col}`);
-                        if (prevRes) {
-                            let percent = (Number(res[prop]) - Number(prevRes[prop])) / Number(prevRes[prop]) * 100;
-                            let sign = percent > 0 ? "+" : "";
-                            let percentText = percent == 0 ? "0%" : sign + percent.toFixed(2) + "%";
-                            diff = " (" + percentText + ")";
-                        }
-                        else {
-                            diff = chalk27.yellow(" (no previous results)");
-                        }
-                    }
-                    curRow.push(formatNumber(res[prop]) + diff);
-                }
-                else {
-                    curRow.push("");
-                }
-            }
-            resArr.push(curRow);
-        }
-        return markdownTable(resArr, { align: ["l", ..."r".repeat(schema.cols.length)] });
-    };
-    let printResults = () => {
-        logUpdate7(`
-			
-${chalk27.bold(schema.name)}
-			${schema.description ? "\n" + chalk27.gray(schema.description) : ""}
-			
-
-${chalk27.blue("Instructions")}
-
-${getTable("instructions")}
-			
-
-${chalk27.blue("Heap")}
-
-${getTable("rts_heap_size")}
-		`);
-    };
-    printResults();
-    for (let [rowIndex, row] of schema.rows.entries()) {
-        for (let [colIndex, col] of schema.cols.entries()) {
-            let res = await actor.runCellUpdateAwait(BigInt(rowIndex), BigInt(colIndex));
-            results.set(`${row}:${col}`, res);
-            printResults();
-        }
-    }
-    logUpdate7.done();
-    if (options.save) {
-        console.log(`Saving results to ${chalk27.gray(absToRel(resultsJsonFile))}`);
-        let json = {
-            version: 1,
-            moc: options.moc,
-            dfx: options.dfx,
-            gc: options.gc,
-            forceGc: options.forceGc,
-            results: Array.from(results.entries())
-        };
-        fs13.mkdirSync(path17.dirname(resultsJsonFile), { recursive: true });
-        fs13.writeFileSync(resultsJsonFile, JSON.stringify(json, (_, val) => {
-            if (typeof val === "bigint") {
-                return Number(val);
-            }
-            else {
-                return val;
-            }
-        }, 2));
-    }
-    return { schema, results };
-}
-// dist/commands/transfer-ownership.js
-import chalk28 from "chalk";
-import { Principal } from "@dfinity/principal";
-import prompts7 from "prompts";
-async function transferOwnership(toPrincipal) {
-    var _a, _b;
-    if (!checkConfigFile()) {
-        return;
-    }
-    let config = readConfig();
-    let principal = Principal.fromText(toPrincipal);
-    let promptsConfig = {
-        onCancel() {
-            console.log("aborted");
-            process.exit(0);
-        }
-    };
-    console.log(chalk28.red("Warning: ") + "This action cannot be undone!");
-    let { confirm } = await prompts7({
-        type: "confirm",
-        name: "confirm",
-        message: `Are you sure you want to transfer ownership of ${chalk28.yellow((_a = config.package) == null ? void 0 : _a.name)} to ${chalk28.yellow(toPrincipal)}?`,
-        initial: false
-    }, promptsConfig);
-    if (!confirm) {
-        return;
-    }
-    let identity = await getIdentity();
-    let actor = await mainActor(identity);
-    let res = await actor.transferOwnership(((_b = config.package) == null ? void 0 : _b.name) || "", principal);
-    if ("ok" in res) {
-        console.log(chalk28.green("Success!"));
-    }
-    else {
-        console.log(chalk28.red("Error: ") + res.err);
-    }
-}
-// dist/cli.js
-var networkFile = getNetworkFile();
-if (fs14.existsSync(networkFile)) {
-    globalThis.MOPS_NETWORK = fs14.readFileSync(networkFile).toString() || "ic";
-}
-program.name("mops");
-var packageJson = JSON.parse(fs14.readFileSync(new URL("package.json", import.meta.url)).toString());
-program.version(`CLI ${packageJson.version}
-API ${apiVersion}`, "-v --version");
-program.command("init").description("Initialize a new project or package in the current directory").option("-y, --yes", "Accept all defaults").action(async (options) => {
-    await init(options);
-});
-program.command("add <pkg>").description("Install the package and save it to mops.toml").option("--dev").option("--verbose").addOption(new Option("--lockfile <lockfile>", "Lockfile action").choices(["save", "ignore"])).action(async (pkg, options) => {
-    if (!checkConfigFile()) {
-        process.exit(1);
-    }
-    await add(pkg, options);
-});
-program.command("remove <pkg>").alias("rm").description("Remove package and update mops.toml").option("--dev", "Remove from dev-dependencies instead of dependencies").option("--verbose", "Show more information").option("--dry-run", "Do not actually remove anything").addOption(new Option("--lockfile <lockfile>", "Lockfile action").choices(["save", "ignore"])).action(async (pkg, options) => {
-    if (!checkConfigFile()) {
-        process.exit(1);
-    }
-    await remove(pkg, options);
-});
-program.command("install [pkg]").alias("i").description("Install all dependencies specified in mops.toml").option("--verbose").addOption(new Option("--lockfile <lockfile>", "Lockfile action").choices(["save", "check", "ignore"])).action(async (pkg, options) => {
-    if (!checkConfigFile()) {
-        process.exit(1);
-    }
-    let compatible = await checkApiCompatibility();
-    if (!compatible) {
-        return;
-    }
-    if (pkg) {
-        console.log(chalk29.yellow("Consider using the 'mops add' command to install a specific package."));
-        await add(pkg, options);
-    }
-    else {
-        await installAll(options);
-    }
-});
-program.command("publish").description("Publish package to the mops registry").option("--no-docs", "Do not generate docs").option("--no-test", "Do not run tests").action(async (options) => {
-    if (!checkConfigFile()) {
-        process.exit(1);
-    }
-    let compatible = await checkApiCompatibility();
-    if (compatible) {
-        await publish(options);
-    }
-});
-program.command("set-network <network>").alias("sn").description("Set network local|staging|ic").action(async (network) => {
-    await setNetwork(network);
-    console.log(`Selected '${network}' network`);
-});
-program.command("get-network").alias("gn").description("Get network").action(async () => {
-    console.log(getNetwork());
-});
-program.command("import-identity <data>").description("Import .pem file data to use as identity").addOption(new Option("--no-encrypt", "Do not ask for a password to encrypt identity")).action(async (data, options) => {
-    await importPem(data, options);
-    await whoami();
-});
-program.command("sources").description("for dfx packtool").option("--verbose").action(async (options) => {
-    if (!checkConfigFile()) {
-        process.exit(1);
-    }
-    await installAll({ silent: true, lockfile: "ignore" });
-    let sourcesArr = await sources(options);
-    console.log(sourcesArr.join("\n"));
-});
-program.command("whoami").description("Print your principal").action(async () => {
-    await whoami();
-});
-program.command("search <text>").description("Search for packages").action(async (text) => {
-    await search(text);
-});
-program.command("cache").description("Manage cache").addArgument(new Argument("<sub>").choices(["size", "clean"])).action(async (sub) => {
-    if (sub == "clean") {
-        await cleanCache();
-        console.log("Cache cleaned");
-    }
-    else if (sub == "size") {
-        let size = await cacheSize();
-        console.log("Cache size is " + size);
-    }
-});
-program.command("test [filter]").description("Run tests").addOption(new Option("-r, --reporter <reporter>", "Test reporter").choices(["verbose", "compact", "files", "silent"]).default("verbose")).addOption(new Option("--mode <mode>", "Test mode").choices(["interpreter", "wasi"]).default("interpreter")).option("-w, --watch", "Enable watch mode").action(async (filter, options) => {
-    await installAll({ silent: true, lockfile: "ignore" });
-    await test(filter, options);
-});
-program.command("bench [filter]").description("Run benchmarks").addOption(new Option("--save", "Save benchmark results to .bench/<filename>.json")).addOption(new Option("--compare", "Run benchmark and compare results with .bench/<filename>.json")).addOption(new Option("--gc <gc>", "Garbage collector").choices(["copying", "compacting", "generational", "incremental"]).default("incremental")).addOption(new Option("--verbose", "Show more information")).action(async (filter, options) => {
-    await installAll({ silent: true, lockfile: "ignore" });
-    await bench(filter, options);
-});
-program.command("template").description("Apply template").action(async () => {
-    if (!checkConfigFile()) {
-        process.exit(1);
-    }
-    await template();
-});
-program.command("self-update").description("Update mops CLI to the latest version").option("--detached").option("--force").action(async (options) => {
-    if (options.force) {
-        selfUpdate(options);
-    }
-    else {
-        console.log("Please run 'npm i -g ic-mops'");
-    }
-});
-program.command("user").addArgument(new Argument("<sub>").choices(["set", "get"])).addArgument(new Argument("<prop>").choices(["name", "site", "email", "github", "twitter"])).addArgument(new Argument("[value]")).description("User settings").action(async (sub, prop, value) => {
-    if (sub == "get") {
-        await getUserProp(prop);
-    }
-    else if (sub == "set") {
-        if (!value) {
-            console.log('error: missing required argument "value"');
-            return;
-        }
-        await setUserProp(prop, value);
-    }
-});
-program.command("airdrop <check|claim> [canister]").action(async (sub, canister) => {
-    let identity = await getIdentity();
-    let main = await mainActor(identity);
-    if (sub === "check") {
-        let amount = await main.getAirdropAmount();
-        if (amount === 0n) {
-            console.log("No airdrop available");
-            return;
-        }
-        console.log(`You can claim ${Number(amount) / 1e12} TCycles`);
-    }
-    else if (sub === "claim") {
-        let principal;
-        try {
-            principal = Principal2.fromText(canister);
-        }
-        catch (err) {
-            console.log("Invalid canister id");
-            console.log(err);
-            return;
-        }
-        console.log("Sending cycles to the canister " + canister);
-        let res = await main.claimAirdrop(principal);
-        console.log(res);
-    }
-    else {
-        console.log("Unknown sub command. Available sub commands: check, claim");
-    }
-});
-program.command("bump [major|minor|patch]").description("Bump current package version").action(async (part) => {
-    await bump(part);
-});
-program.command("sync").description("Add missing packages and remove unused packages").addOption(new Option("--lockfile <lockfile>", "Lockfile action").choices(["save", "ignore"])).action(async (options) => {
-    await sync(options);
-});
-program.command("outdated").description("Print outdated dependencies specified in mops.toml").action(async () => {
-    await outdated();
-});
-program.command("update [pkg]").description("Update dependencies specified in mops.toml").addOption(new Option("--lockfile <lockfile>", "Lockfile action").choices(["save", "ignore"])).action(async (pkg, options) => {
-    await update(pkg, options);
-});
-program.command("transfer-ownership [to-principal]").description("Transfer ownership of the current package to another principal").action(async (toPrincipal) => {
-    await transferOwnership(toPrincipal);
-});
-program.parse();