@elementspanel/epanel-plugin-config 0.0.0-stage → 1.0.0

package/panel/backend/index.cjs

@@ -0,0 +1,2520 @@
+/******/ (() => { // webpackBootstrap
+/******/ 	"use strict";
+/******/ 	var __webpack_modules__ = ({
+
+/***/ "../common/src/array.ts"
+(__unused_webpack_module, exports) {
+
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.arrayUnique = arrayUnique;
+function arrayUnique(arr, felidName) {
+    if (!felidName)
+        return Array.from(new Set(arr));
+    const map = new Map();
+    return arr.filter((v) => !map.has(v[felidName]) && map.set(v[felidName], v));
+}
+
+
+/***/ },
+
+/***/ "../common/src/docker_utils.ts"
+(__unused_webpack_module, exports) {
+
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.normalizeDockerArchitecture = normalizeDockerArchitecture;
+exports.normalizeDockerOS = normalizeDockerOS;
+exports.normalizeDockerPlatform = normalizeDockerPlatform;
+/**
+ * Normalizes Docker platform architecture names to standard format
+ * @param architecture The architecture string from Docker manifest
+ * @returns Normalized architecture string (amd64, arm64, arm, or original if not recognized)
+ */
+function normalizeDockerArchitecture(architecture) {
+    if (!architecture) {
+        return "amd64"; // default fallback
+    }
+    // Return original if not one of the standard architectures
+    return architecture;
+}
+/**
+ * Normalizes Docker platform OS name
+ * @param os The OS string from Docker manifest
+ * @returns Normalized OS string (defaults to "linux" if not provided)
+ */
+function normalizeDockerOS(os) {
+    return os || "linux";
+}
+/**
+ * Normalizes a Docker platform from manifest format to standard platform string
+ * @param platform Platform object from Docker manifest with os and architecture
+ * @returns Normalized platform string in format "os/arch" (e.g., "linux/amd64")
+ */
+function normalizeDockerPlatform(platform) {
+    const os = normalizeDockerOS(platform.os);
+    const arch = normalizeDockerArchitecture(platform.architecture);
+    return `${os}/${arch}`;
+}
+
+
+/***/ },
+
+/***/ "../common/src/global_variable.ts"
+(__unused_webpack_module, exports) {
+
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+class GlobalVariable {
+    static set(k, v) {
+        GlobalVariable.map.set(k, v);
+    }
+    static get(k, def) {
+        if (GlobalVariable.map.has(k)) {
+            return GlobalVariable.map.get(k);
+        }
+        else {
+            return def;
+        }
+    }
+    static del(k) {
+        return GlobalVariable.map.delete(k);
+    }
+}
+GlobalVariable.map = new Map();
+exports["default"] = GlobalVariable;
+
+
+/***/ },
+
+/***/ "../common/src/index.ts"
+(__unused_webpack_module, exports, __webpack_require__) {
+
+
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.StorageSubsystem = exports.MCServerStatus = exports.InstanceStreamListener = exports.GlobalVariable = exports.normalizeDockerPlatform = exports.normalizeDockerOS = exports.normalizeDockerArchitecture = exports.removeTrail = exports.uninstallNpmPlugin = exports.npmPluginRoots = exports.listNpmPlugins = exports.installNpmPlugin = exports.currentProjectRoot = exports.currentPackageRoot = exports.sortPlugins = exports.resolvePluginEntry = exports.readPluginManifest = exports.createFrontendPluginMetadata = exports.discoverPluginsFromRoots = exports.discoverPlugins = exports.arrayUnique = exports.toText = exports.toNumber = exports.toBoolean = exports.supposeValue = exports.isEmpty = exports.configureEntityParams = exports.systemInfo = exports.QueryWrapper = exports.QueryMapWrapper = exports.MySqlSource = exports.LocalFileSource = exports.killProcess = exports.ProcessWrapper = void 0;
+const global_variable_1 = __importDefault(__webpack_require__("../common/src/global_variable.ts"));
+exports.GlobalVariable = global_variable_1.default;
+const instance_stream_1 = __importDefault(__webpack_require__("../common/src/instance_stream.ts"));
+exports.InstanceStreamListener = instance_stream_1.default;
+const system_storage_1 = __importDefault(__webpack_require__("../common/src/system_storage.ts"));
+exports.StorageSubsystem = system_storage_1.default;
+const mcping_1 = __importDefault(__webpack_require__("../common/src/mcping.ts"));
+exports.MCServerStatus = mcping_1.default;
+var process_tools_1 = __webpack_require__("../common/src/process_tools.ts");
+Object.defineProperty(exports, "ProcessWrapper", ({ enumerable: true, get: function () { return process_tools_1.ProcessWrapper; } }));
+Object.defineProperty(exports, "killProcess", ({ enumerable: true, get: function () { return process_tools_1.killProcess; } }));
+var query_wrapper_1 = __webpack_require__("../common/src/query_wrapper.ts");
+Object.defineProperty(exports, "LocalFileSource", ({ enumerable: true, get: function () { return query_wrapper_1.LocalFileSource; } }));
+Object.defineProperty(exports, "MySqlSource", ({ enumerable: true, get: function () { return query_wrapper_1.MySqlSource; } }));
+Object.defineProperty(exports, "QueryMapWrapper", ({ enumerable: true, get: function () { return query_wrapper_1.QueryMapWrapper; } }));
+Object.defineProperty(exports, "QueryWrapper", ({ enumerable: true, get: function () { return query_wrapper_1.QueryWrapper; } }));
+var system_info_1 = __webpack_require__("../common/src/system_info.ts");
+Object.defineProperty(exports, "systemInfo", ({ enumerable: true, get: function () { return system_info_1.systemInfo; } }));
+var typecheck_1 = __webpack_require__("../common/src/typecheck.ts");
+Object.defineProperty(exports, "configureEntityParams", ({ enumerable: true, get: function () { return typecheck_1.configureEntityParams; } }));
+Object.defineProperty(exports, "isEmpty", ({ enumerable: true, get: function () { return typecheck_1.isEmpty; } }));
+Object.defineProperty(exports, "supposeValue", ({ enumerable: true, get: function () { return typecheck_1.supposeValue; } }));
+Object.defineProperty(exports, "toBoolean", ({ enumerable: true, get: function () { return typecheck_1.toBoolean; } }));
+Object.defineProperty(exports, "toNumber", ({ enumerable: true, get: function () { return typecheck_1.toNumber; } }));
+Object.defineProperty(exports, "toText", ({ enumerable: true, get: function () { return typecheck_1.toText; } }));
+var array_1 = __webpack_require__("../common/src/array.ts");
+Object.defineProperty(exports, "arrayUnique", ({ enumerable: true, get: function () { return array_1.arrayUnique; } }));
+__exportStar(__webpack_require__("../common/src/plugin_contract.ts"), exports);
+__exportStar(__webpack_require__("../common/src/plugin_overrides.ts"), exports);
+__exportStar(__webpack_require__("../common/src/plugin_lifecycle.ts"), exports);
+__exportStar(__webpack_require__("../common/src/plugin_revision.ts"), exports);
+__exportStar(__webpack_require__("../common/src/runtime_paths.ts"), exports);
+var plugin_manifest_1 = __webpack_require__("../common/src/plugin_manifest.ts");
+Object.defineProperty(exports, "discoverPlugins", ({ enumerable: true, get: function () { return plugin_manifest_1.discoverPlugins; } }));
+Object.defineProperty(exports, "discoverPluginsFromRoots", ({ enumerable: true, get: function () { return plugin_manifest_1.discoverPluginsFromRoots; } }));
+Object.defineProperty(exports, "createFrontendPluginMetadata", ({ enumerable: true, get: function () { return plugin_manifest_1.createFrontendPluginMetadata; } }));
+Object.defineProperty(exports, "readPluginManifest", ({ enumerable: true, get: function () { return plugin_manifest_1.readPluginManifest; } }));
+Object.defineProperty(exports, "resolvePluginEntry", ({ enumerable: true, get: function () { return plugin_manifest_1.resolvePluginEntry; } }));
+Object.defineProperty(exports, "sortPlugins", ({ enumerable: true, get: function () { return plugin_manifest_1.sortPlugins; } }));
+var plugin_npm_1 = __webpack_require__("../common/src/plugin_npm.ts");
+Object.defineProperty(exports, "currentPackageRoot", ({ enumerable: true, get: function () { return plugin_npm_1.currentPackageRoot; } }));
+Object.defineProperty(exports, "currentProjectRoot", ({ enumerable: true, get: function () { return plugin_npm_1.currentProjectRoot; } }));
+Object.defineProperty(exports, "installNpmPlugin", ({ enumerable: true, get: function () { return plugin_npm_1.installNpmPlugin; } }));
+Object.defineProperty(exports, "listNpmPlugins", ({ enumerable: true, get: function () { return plugin_npm_1.listNpmPlugins; } }));
+Object.defineProperty(exports, "npmPluginRoots", ({ enumerable: true, get: function () { return plugin_npm_1.npmPluginRoots; } }));
+Object.defineProperty(exports, "uninstallNpmPlugin", ({ enumerable: true, get: function () { return plugin_npm_1.uninstallNpmPlugin; } }));
+var string_utils_1 = __webpack_require__("../common/src/string_utils.ts");
+Object.defineProperty(exports, "removeTrail", ({ enumerable: true, get: function () { return string_utils_1.removeTrail; } }));
+var docker_utils_1 = __webpack_require__("../common/src/docker_utils.ts");
+Object.defineProperty(exports, "normalizeDockerArchitecture", ({ enumerable: true, get: function () { return docker_utils_1.normalizeDockerArchitecture; } }));
+Object.defineProperty(exports, "normalizeDockerOS", ({ enumerable: true, get: function () { return docker_utils_1.normalizeDockerOS; } }));
+Object.defineProperty(exports, "normalizeDockerPlatform", ({ enumerable: true, get: function () { return docker_utils_1.normalizeDockerPlatform; } }));
+
+
+/***/ },
+
+/***/ "../common/src/instance_stream.ts"
+(__unused_webpack_module, exports) {
+
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+// Application instance data stream forwarding adapter
+class InstanceStreamListener {
+    constructor() {
+        this.listenMap = new Map();
+        this.disconnectHandlers = new Map();
+    }
+    requestForward(socket, instanceUuid) {
+        var _a;
+        const sockets = (_a = this.listenMap.get(instanceUuid)) !== null && _a !== void 0 ? _a : [];
+        if (sockets.some((listener) => listener.id === socket.id))
+            return;
+        sockets.push(socket);
+        this.listenMap.set(instanceUuid, sockets);
+        if (!this.disconnectHandlers.has(socket)) {
+            const disconnect = () => {
+                for (const uuid of this.listenMap.keys())
+                    this.cannelForward(socket, uuid);
+            };
+            this.disconnectHandlers.set(socket, disconnect);
+            socket.once("disconnect", disconnect);
+        }
+    }
+    cannelForward(socket, instanceUuid) {
+        var _a;
+        const remaining = (_a = this.listenMap
+            .get(instanceUuid)) === null || _a === void 0 ? void 0 : _a.filter((listener) => listener.id !== socket.id);
+        if (remaining === null || remaining === void 0 ? void 0 : remaining.length)
+            this.listenMap.set(instanceUuid, remaining);
+        else
+            this.listenMap.delete(instanceUuid);
+        if (![...this.listenMap.values()].some((sockets) => sockets.includes(socket))) {
+            const disconnect = this.disconnectHandlers.get(socket);
+            if (disconnect)
+                socket.off("disconnect", disconnect);
+            this.disconnectHandlers.delete(socket);
+        }
+    }
+    forward(instanceUuid, data) {
+        this.forwardViaCallback(instanceUuid, (socket) => socket.emit("instance/stdout", data));
+    }
+    forwardViaCallback(instanceUuid, callback) {
+        var _a;
+        for (const socket of (_a = this.listenMap.get(instanceUuid)) !== null && _a !== void 0 ? _a : []) {
+            if (socket.connected)
+                callback(socket);
+            else
+                this.cannelForward(socket, instanceUuid);
+        }
+    }
+    hasListenInstance(instanceUuid) {
+        var _a, _b;
+        return (_b = (_a = this.listenMap.get(instanceUuid)) === null || _a === void 0 ? void 0 : _a.some((socket) => socket.connected)) !== null && _b !== void 0 ? _b : false;
+    }
+}
+exports["default"] = InstanceStreamListener;
+
+
+/***/ },
+
+/***/ "../common/src/mcping.ts"
+(__unused_webpack_module, exports, __webpack_require__) {
+
+
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+const net_1 = __importDefault(__webpack_require__("net"));
+class PingMinecraftServer {
+    constructor(port, host) {
+        this.port = port;
+        this.host = host;
+        this.status = this.offlineStatus();
+    }
+    offlineStatus() {
+        return {
+            online: false,
+            host: this.host,
+            port: this.port,
+            version: "",
+            motd: "",
+            current_players: 0,
+            max_players: 0,
+            latency: 0
+        };
+    }
+    getStatus() {
+        if (this.pending)
+            return this.pending;
+        this.status = this.offlineStatus();
+        this.pending = new Promise((resolve, reject) => {
+            const startedAt = Date.now();
+            const client = net_1.default.connect({ host: this.host, port: this.port });
+            this.client = client;
+            let received = Buffer.alloc(0);
+            let settled = false;
+            const finish = (error) => {
+                if (settled)
+                    return;
+                settled = true;
+                clearTimeout(timeout);
+                client.destroy();
+                this.client = undefined;
+                if (error)
+                    reject(error);
+                else
+                    resolve(this.status);
+            };
+            const timeout = setTimeout(() => finish(new Error("Minecraft status request timed out")), 15000);
+            client.once("connect", () => client.write(Buffer.from([0xfe, 0x01])));
+            client.on("data", (chunk) => {
+                if (settled)
+                    return;
+                try {
+                    received = Buffer.concat([received, chunk]);
+                    // Legacy status packets contain an unsigned UTF-16 character count.
+                    if (received.length > 3 + 0xffff * 2)
+                        throw new Error("Minecraft status response is too large");
+                    if (received.length < 3)
+                        return;
+                    if (received[0] !== 0xff)
+                        throw new Error("Invalid Minecraft status packet");
+                    const length = 3 + received.readUInt16BE(1) * 2;
+                    if (received.length < length)
+                        return;
+                    const fields = Buffer.from(received.subarray(3, length))
+                        .swap16()
+                        .toString("utf16le")
+                        .split("\0");
+                    if (fields.length !== 6 ||
+                        fields[0] !== "§1" ||
+                        !/^\d+$/.test(fields[4]) ||
+                        !/^\d+$/.test(fields[5])) {
+                        throw new Error("Invalid Minecraft status response");
+                    }
+                    const currentPlayers = Number(fields[4]);
+                    const maxPlayers = Number(fields[5]);
+                    if (!Number.isSafeInteger(currentPlayers) || !Number.isSafeInteger(maxPlayers)) {
+                        throw new Error("Invalid Minecraft player count");
+                    }
+                    this.status = {
+                        host: this.host,
+                        port: this.port,
+                        online: true,
+                        version: fields[2],
+                        motd: fields[3],
+                        current_players: currentPlayers,
+                        max_players: maxPlayers,
+                        latency: Date.now() - startedAt
+                    };
+                    finish();
+                }
+                catch (error) {
+                    finish(error instanceof Error ? error : new Error(String(error)));
+                }
+            });
+            client.once("error", finish);
+            client.once("close", () => finish(received.length ? new Error("Incomplete Minecraft status response") : undefined));
+        }).finally(() => {
+            this.pending = undefined;
+        });
+        return this.pending;
+    }
+    asyncStatus() {
+        return this.getStatus();
+    }
+}
+exports["default"] = PingMinecraftServer;
+
+
+/***/ },
+
+/***/ "../common/src/plugin_contract.ts"
+(__unused_webpack_module, exports) {
+
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.PLUGIN_SDK_VERSION = exports.PLUGIN_API_VERSION = void 0;
+exports.validatePluginCompatibility = validatePluginCompatibility;
+exports.resolvePluginDependencyOrder = resolvePluginDependencyOrder;
+exports.createPluginQueue = createPluginQueue;
+exports.validatePluginSettings = validatePluginSettings;
+/** Versioned contract shared by the host, plugin compiler and package registry. */
+exports.PLUGIN_API_VERSION = 1;
+exports.PLUGIN_SDK_VERSION = "1.0.0";
+/** Omitted metadata denotes a legacy package. Unknown versions never execute. */
+function validatePluginCompatibility(value) {
+    if (value === undefined)
+        return;
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        throw new Error("Invalid ElementsPanel plugin compatibility metadata.");
+    const contract = value;
+    if (contract.api !== exports.PLUGIN_API_VERSION || (contract.sdk !== undefined && contract.sdk !== 1))
+        throw new Error(`Unsupported ElementsPanel plugin API/SDK: ${JSON.stringify(value)}`);
+}
+/**
+ * Stable topological ordering shared by plugin hosts.
+ *
+ * Invalid nodes are kept out of `ordered`: direct missing dependencies are
+ * reported first, then anything depending on an invalid node, and finally
+ * cycles (plus nodes blocked behind a cycle). Independent nodes retain the
+ * caller's priority/id comparator.
+ */
+function resolvePluginDependencyOrder(items, options) {
+    const sorted = [...items].sort(options.compare);
+    const byId = new Map(sorted.map((item) => [options.id(item), item]));
+    const dependencies = new Map(sorted.map((item) => [
+        options.id(item),
+        [...new Set(options.dependencies(item) || [])].filter(Boolean)
+    ]));
+    const issues = new Map();
+    for (const item of sorted) {
+        const id = options.id(item);
+        const missing = dependencies.get(id).filter((dependency) => !byId.has(dependency));
+        if (!missing.length)
+            continue;
+        issues.set(id, {
+            type: "missing-dependency",
+            dependencies: missing,
+            message: `Missing frontend plugin dependencies: ${missing.join(", ")}`
+        });
+    }
+    const markUnavailable = () => {
+        let changed = false;
+        for (const item of sorted) {
+            const id = options.id(item);
+            if (issues.has(id))
+                continue;
+            const unavailable = dependencies.get(id).filter((dependency) => issues.has(dependency));
+            if (!unavailable.length)
+                continue;
+            issues.set(id, {
+                type: "dependency-unavailable",
+                dependencies: unavailable,
+                message: `Frontend plugin dependencies are unavailable: ${unavailable.join(", ")}`
+            });
+            changed = true;
+        }
+        return changed;
+    };
+    while (markUnavailable()) {
+        // Propagate direct graph failures before sorting the remaining nodes.
+    }
+    const candidates = sorted.filter((item) => !issues.has(options.id(item)));
+    const candidateIds = new Set(candidates.map(options.id));
+    const indegree = new Map(candidates.map((item) => [options.id(item), 0]));
+    const dependents = new Map();
+    for (const item of candidates) {
+        const id = options.id(item);
+        for (const dependency of dependencies.get(id)) {
+            if (!candidateIds.has(dependency))
+                continue;
+            indegree.set(id, indegree.get(id) + 1);
+            const bucket = dependents.get(dependency) || [];
+            bucket.push(item);
+            dependents.set(dependency, bucket);
+        }
+    }
+    const ready = candidates.filter((item) => indegree.get(options.id(item)) === 0);
+    ready.sort(options.compare);
+    const ordered = [];
+    while (ready.length) {
+        const item = ready.shift();
+        const id = options.id(item);
+        ordered.push(item);
+        for (const dependent of dependents.get(id) || []) {
+            const dependentId = options.id(dependent);
+            const next = indegree.get(dependentId) - 1;
+            indegree.set(dependentId, next);
+            if (next === 0) {
+                ready.push(dependent);
+                ready.sort(options.compare);
+            }
+        }
+    }
+    const unresolved = candidates.filter((item) => !ordered.includes(item));
+    if (unresolved.length) {
+        const unresolvedIds = new Set(unresolved.map(options.id));
+        for (const item of unresolved) {
+            const id = options.id(item);
+            const blockedBy = dependencies.get(id).filter((dependency) => unresolvedIds.has(dependency));
+            issues.set(id, {
+                type: "dependency-cycle",
+                dependencies: blockedBy,
+                message: `Frontend plugin dependency cycle: ${[id, ...blockedBy].join(" -> ")}`
+            });
+        }
+    }
+    return { ordered, issues };
+}
+/** A queue survives failures, so a failed change cannot block subsequent repairs. */
+function createPluginQueue() {
+    let tail = Promise.resolve();
+    return (operation) => {
+        const next = tail.then(operation);
+        tail = next.catch(() => undefined);
+        return next;
+    };
+}
+/** Validate the form contract on the server before invoking plugin-owned validation. */
+function validatePluginSettings(fields, values) {
+    var _a, _b;
+    if (!values || typeof values !== "object" || Array.isArray(values))
+        throw new Error("Invalid plugin settings.");
+    const input = values;
+    for (const field of fields) {
+        if (!field.key || field.type === "link")
+            continue;
+        const value = input[field.key];
+        if (value === undefined || value === null) {
+            if (field.required)
+                throw new Error(`${field.title || field.key}: required`);
+            continue;
+        }
+        if (field.type === "list") {
+            if (!Array.isArray(value) || value.length > ((_a = field.maxItems) !== null && _a !== void 0 ? _a : 100))
+                throw new Error(`${field.title || field.key}: invalid list`);
+            for (const item of value)
+                validatePluginSettings(field.fields || [], item);
+            continue;
+        }
+        const valid = field.type === "number"
+            ? typeof value === "number" &&
+                Number.isFinite(value) &&
+                (field.min === undefined || value >= field.min) &&
+                (field.max === undefined || value <= field.max)
+            : field.type === "boolean"
+                ? typeof value === "boolean"
+                : field.type === "select"
+                    ? (_b = field.options) === null || _b === void 0 ? void 0 : _b.some((option) => option.value === value)
+                    : typeof value === "string";
+        if (!valid)
+            throw new Error(`${field.title || field.key}: invalid value`);
+    }
+}
+
+
+/***/ },
+
+/***/ "../common/src/plugin_lifecycle.ts"
+(__unused_webpack_module, exports) {
+
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.trackPluginDisposal = trackPluginDisposal;
+/** Cordis 3 starts async disposers without awaiting them. Track them per host. */
+function trackPluginDisposal(ctx) {
+    const pending = new Set();
+    const failures = [];
+    const tracked = new WeakSet();
+    const scopes = new WeakSet();
+    const observe = (scope) => {
+        if (scopes.has(scope))
+            return;
+        scopes.add(scope);
+        const reset = scope.reset;
+        scope.reset = function () {
+            this.disposables = this.disposables.map((dispose) => {
+                if (tracked.has(dispose))
+                    return dispose;
+                const wrapper = (...args) => {
+                    let result;
+                    try {
+                        result = dispose(...args);
+                    }
+                    catch (error) {
+                        failures.push(error);
+                        throw error;
+                    }
+                    if (result && typeof result.then === "function") {
+                        const task = Promise.resolve(result)
+                            .catch((error) => {
+                            failures.push(error);
+                        })
+                            .finally(() => pending.delete(task));
+                        pending.add(task);
+                    }
+                    return result;
+                };
+                // Cordis marks persistent disposers with a symbol; preserve its semantics.
+                for (const key of Object.getOwnPropertySymbols(dispose))
+                    Object.defineProperty(wrapper, key, Object.getOwnPropertyDescriptor(dispose, key));
+                tracked.add(wrapper);
+                return wrapper;
+            });
+            return reset.call(this);
+        };
+    };
+    ctx.on("internal/runtime", observe);
+    ctx.on("internal/fork", observe);
+    return async () => {
+        do {
+            await ctx.events.flush();
+            await Promise.all([...pending]);
+        } while (pending.size);
+        if (failures.length) {
+            const errors = failures.splice(0);
+            throw new Error(`Plugin cleanup failed: ${errors.map(String).join("; ")}`);
+        }
+    };
+}
+
+
+/***/ },
+
+/***/ "../common/src/plugin_manifest.ts"
+(__unused_webpack_module, exports, __webpack_require__) {
+
+
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.createFrontendPluginMetadata = createFrontendPluginMetadata;
+exports.readPluginManifest = readPluginManifest;
+exports.resolvePluginEntry = resolvePluginEntry;
+exports.discoverPlugins = discoverPlugins;
+exports.discoverPluginsFromRoots = discoverPluginsFromRoots;
+exports.sortPlugins = sortPlugins;
+const node_fs_1 = __importDefault(__webpack_require__("node:fs"));
+const node_path_1 = __importDefault(__webpack_require__("node:path"));
+function stringArray(value) {
+    if (!Array.isArray(value))
+        return undefined;
+    const result = value.filter((item) => typeof item === "string" && !!item.trim());
+    return result.length ? [...new Set(result.map((item) => item.trim()))] : undefined;
+}
+/**
+ * Redacts a full plugin manifest to the fields a browser is allowed to see.
+ * Backend `config` may contain credentials, so only `frontendConfig` crosses
+ * this boundary.
+ */
+function createFrontendPluginMetadata(manifest, extras = {}) {
+    const frontendInject = stringArray(manifest.frontendInject);
+    return {
+        id: manifest.id,
+        ...(manifest.version === undefined ? {} : { version: manifest.version }),
+        ...(manifest.description === undefined ? {} : { description: manifest.description }),
+        ...(manifest.priority === undefined ? {} : { priority: manifest.priority }),
+        ...(manifest.elements === undefined ? {} : { elements: manifest.elements }),
+        ...(frontendInject === undefined ? {} : { frontendInject }),
+        ...(manifest.frontendImmediate === undefined
+            ? {}
+            : { frontendImmediate: Boolean(manifest.frontendImmediate) }),
+        ...(manifest.frontendRequired === undefined
+            ? {}
+            : { frontendRequired: Boolean(manifest.frontendRequired) }),
+        ...(manifest.frontendConfig === undefined ? {} : { config: manifest.frontendConfig }),
+        ...(extras.restartRequired === undefined ? {} : extras)
+    };
+}
+const MANIFEST_FILES = ["plugin.json", "manifest.json", "package.json"];
+/** Reads the manifest of one plugin directory, or null if it has none. */
+function readPluginManifest(directory, onWarning, fallbackId = node_path_1.default.basename(directory)) {
+    for (const file of MANIFEST_FILES) {
+        const filePath = node_path_1.default.join(directory, file);
+        if (!node_fs_1.default.existsSync(filePath))
+            continue;
+        try {
+            const value = JSON.parse(node_fs_1.default.readFileSync(filePath, "utf8"));
+            if (!value || typeof value !== "object" || Array.isArray(value))
+                return null;
+            const id = typeof value.id === "string" ? value.id : fallbackId;
+            if (!id.trim())
+                return null;
+            return { ...value, id: id.trim() };
+        }
+        catch (error) {
+            onWarning === null || onWarning === void 0 ? void 0 : onWarning(`Failed to read plugin manifest: ${filePath}`, error);
+            return null;
+        }
+    }
+    return null;
+}
+/**
+ * Resolves one plugin's entry module. Returns null when the manifest names an
+ * entry that does not exist, or when none of the fallback candidates is present.
+ * Paths that would escape the plugin directory are rejected.
+ */
+function resolvePluginEntry(directory, manifest, options) {
+    var _a;
+    const configured = options.entryFields
+        .map((field) => manifest[field])
+        .find((entry) => typeof entry === "string" && entry.length > 0);
+    const candidates = configured ? [configured] : (_a = options.entryCandidates) !== null && _a !== void 0 ? _a : [];
+    const root = node_path_1.default.resolve(directory);
+    for (const candidate of candidates) {
+        const entry = node_path_1.default.resolve(directory, candidate);
+        if (entry.startsWith(`${root}${node_path_1.default.sep}`) && node_fs_1.default.existsSync(entry))
+            return entry;
+    }
+    return null;
+}
+function discoverPluginDirectory(directory, options, folder = node_path_1.default.basename(directory)) {
+    var _a;
+    // Npm packages expose a side directory; its name is not the public plugin id.
+    const manifest = readPluginManifest(directory, options.onWarning, folder);
+    if (!manifest)
+        return null;
+    if (manifest.enabled === false && !options.includeDisabled)
+        return null;
+    const entry = resolvePluginEntry(directory, manifest, options);
+    if (!entry && options.entryFields.some((field) => typeof manifest[field] === "string")) {
+        (_a = options.onWarning) === null || _a === void 0 ? void 0 : _a.call(options, `Plugin "${manifest.id}" has no valid entry module.`);
+        return null;
+    }
+    return { manifest, directory, folder, entry: entry !== null && entry !== void 0 ? entry : undefined };
+}
+/**
+ * Lists the usable plugins below `root`, in load order: ascending `priority`,
+ * then by id so the order is stable. Duplicate ids are dropped, and disabled
+ * ones too unless `includeDisabled` says otherwise. A plugin whose manifest names an entry that cannot be resolved is
+ * dropped too; one that names none keeps `entry` undefined, because a plugin may
+ * legitimately contribute to only one side of the panel.
+ */
+function discoverPlugins(root, options) {
+    var _a;
+    if (!node_fs_1.default.existsSync(root))
+        return [];
+    const plugins = [];
+    const seenIds = new Set();
+    for (const item of node_fs_1.default.readdirSync(root, { withFileTypes: true })) {
+        if (!item.isDirectory())
+            continue;
+        const directory = node_path_1.default.join(root, item.name);
+        const plugin = discoverPluginDirectory(directory, options, item.name);
+        if (!plugin || seenIds.has(plugin.manifest.id)) {
+            if (plugin && seenIds.has(plugin.manifest.id)) {
+                (_a = options.onWarning) === null || _a === void 0 ? void 0 : _a.call(options, `Ignoring duplicate plugin id: ${plugin.manifest.id}`);
+            }
+            continue;
+        }
+        seenIds.add(plugin.manifest.id);
+        plugins.push(plugin);
+    }
+    return sortPlugins(plugins);
+}
+/**
+ * Discovers plugins from several roots while keeping the first root's plugin
+ * when ids collide. The built-in root is intentionally passed first by the
+ * panel and daemon loaders, so an installed market plugin cannot shadow a
+ * built-in npm dependency. A root can also force an installed project plugin
+ * into the disabled state; the user-owned override layer may enable it later.
+ */
+function discoverPluginsFromRoots(roots, options) {
+    var _a;
+    const discovered = [];
+    const seenIds = new Set();
+    for (const root of roots) {
+        const isDirectPlugin = MANIFEST_FILES.some((file) => node_fs_1.default.existsSync(node_path_1.default.join(root.directory, file)));
+        const plugins = isDirectPlugin
+            ? [discoverPluginDirectory(root.directory, options, root.folder)]
+            : discoverPlugins(root.directory, options);
+        for (const plugin of plugins) {
+            if (!plugin)
+                continue;
+            const manifest = root.defaultEnabled === false ? { ...plugin.manifest, enabled: false } : plugin.manifest;
+            if (manifest.enabled === false && !options.includeDisabled)
+                continue;
+            if (seenIds.has(plugin.manifest.id)) {
+                (_a = options.onWarning) === null || _a === void 0 ? void 0 : _a.call(options, `Ignoring duplicate plugin id: ${plugin.manifest.id}`);
+                continue;
+            }
+            seenIds.add(plugin.manifest.id);
+            discovered.push({
+                ...plugin,
+                manifest,
+                ...(root.folder ? { folder: root.folder } : {})
+            });
+        }
+    }
+    return sortPlugins(discovered);
+}
+/** Load order: ascending `priority`, then by id so it never depends on the filesystem. */
+function sortPlugins(plugins) {
+    return plugins.sort((a, b) => (Number(a.manifest.priority) || 0) - (Number(b.manifest.priority) || 0) ||
+        a.manifest.id.localeCompare(b.manifest.id));
+}
+
+
+/***/ },
+
+/***/ "../common/src/plugin_npm.ts"
+(__unused_webpack_module, exports, __webpack_require__) {
+
+
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.currentPackageRoot = currentPackageRoot;
+exports.currentProjectRoot = currentProjectRoot;
+exports.npmPluginRoots = npmPluginRoots;
+exports.listNpmPlugins = listNpmPlugins;
+exports.installNpmPlugin = installNpmPlugin;
+exports.uninstallNpmPlugin = uninstallNpmPlugin;
+const child_process_1 = __webpack_require__("child_process");
+const fs_extra_1 = __importDefault(__webpack_require__("fs-extra"));
+const path_1 = __importDefault(__webpack_require__("path"));
+const module_1 = __webpack_require__("module");
+const PLUGIN_ID = /^[a-z][a-z0-9_-]{1,63}$/;
+const PACKAGE_NAME = /^(?:@[a-z0-9_.-]+\/)?epanel-plugin-[a-z0-9_.-]+$/;
+const VERSION = /^[0-9][^\s/]{0,63}$/;
+function readJson(filename) {
+    try {
+        const parsed = JSON.parse(fs_extra_1.default.readFileSync(filename, "utf8"));
+        return parsed && typeof parsed === "object" && !Array.isArray(parsed)
+            ? parsed
+            : null;
+    }
+    catch (error) {
+        if ((error === null || error === void 0 ? void 0 : error.code) === "ENOENT")
+            return null;
+        throw error;
+    }
+}
+function objectValue(value) {
+    return value && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : undefined;
+}
+function stringValue(value) {
+    return typeof value === "string" ? value : "";
+}
+function currentPackageRoot() {
+    return path_1.default.resolve(process.env.EPANEL_PACKAGE_ROOT || process.cwd());
+}
+function currentProjectRoot(packageRoot = currentPackageRoot()) {
+    // The npm worker sets EPANEL_PROJECT_ROOT to the installation directory. In a
+    // development checkout the runtime package sits directly under the project.
+    if (process.env.EPANEL_PROJECT_ROOT)
+        return path_1.default.resolve(process.env.EPANEL_PROJECT_ROOT);
+    const scope = path_1.default.resolve(packageRoot, "..");
+    const nodeModules = path_1.default.dirname(scope);
+    if (path_1.default.basename(nodeModules) === "node_modules" && path_1.default.basename(scope).startsWith("@"))
+        return path_1.default.dirname(nodeModules);
+    return scope;
+}
+function npmPluginRoots(options = {}) {
+    var _a, _b;
+    const packageRoot = path_1.default.resolve((_a = options.packageRoot) !== null && _a !== void 0 ? _a : currentPackageRoot());
+    return {
+        packageRoot,
+        projectRoot: path_1.default.resolve((_b = options.projectRoot) !== null && _b !== void 0 ? _b : currentProjectRoot(packageRoot))
+    };
+}
+function projectManifestFile(projectRoot) {
+    return path_1.default.join(projectRoot, "package.json");
+}
+function readProjectManifest(projectRoot) {
+    var _a;
+    return ((_a = readJson(projectManifestFile(projectRoot))) !== null && _a !== void 0 ? _a : {
+        private: true,
+        dependencies: {},
+        elementspanel: { plugins: {} }
+    });
+}
+function writeProjectManifest(projectRoot, manifest) {
+    fs_extra_1.default.writeFileSync(projectManifestFile(projectRoot), `${JSON.stringify(manifest, null, 2)}\n`);
+}
+function dependenciesOf(manifest) {
+    var _a;
+    return (_a = objectValue(manifest === null || manifest === void 0 ? void 0 : manifest.dependencies)) !== null && _a !== void 0 ? _a : {};
+}
+function mappingsOf(manifest) {
+    var _a, _b;
+    return (_b = objectValue((_a = objectValue(manifest === null || manifest === void 0 ? void 0 : manifest.elementspanel)) === null || _a === void 0 ? void 0 : _a.plugins)) !== null && _b !== void 0 ? _b : {};
+}
+function pluginRecord(pluginId, name, source, packageRoot, directory, folder, version) {
+    return { pluginId, name, version, sides: [], directory, folder, packageRoot, source };
+}
+function readPackageEntry(packageRoot, name) {
+    const hostRequire = (0, module_1.createRequire)(path_1.default.join(packageRoot, "package.json"));
+    const manifestPath = hostRequire.resolve(`${name}/package.json`);
+    const metadata = readJson(manifestPath);
+    if (!metadata)
+        throw new Error(`Missing package metadata for ${name}.`);
+    return { root: path_1.default.dirname(manifestPath), metadata };
+}
+function sideDirectory(packageRoot, metadata, side) {
+    const elements = objectValue(metadata.elementspanel);
+    const definition = objectValue(elements === null || elements === void 0 ? void 0 : elements[side]);
+    const directory = stringValue(definition === null || definition === void 0 ? void 0 : definition.directory);
+    if (!definition || !directory)
+        return undefined;
+    const target = path_1.default.resolve(packageRoot, directory);
+    const relative = path_1.default.relative(packageRoot, target);
+    if (relative === "" || relative.startsWith(`..${path_1.default.sep}`) || path_1.default.isAbsolute(relative))
+        return undefined;
+    return target;
+}
+function recordFromPackage(pluginId, name, source, packageRoot, metadata, side) {
+    var _a;
+    const elements = objectValue(metadata.elementspanel);
+    if (!elements || elements.id !== pluginId)
+        return undefined;
+    const version = stringValue(metadata.version);
+    const sides = ["panel", "daemon"].filter((item) => Boolean(sideDirectory(packageRoot, metadata, item)));
+    if (!sides.length)
+        return undefined;
+    const target = side !== null && side !== void 0 ? side : sides[0];
+    if (!sides.includes(target))
+        return undefined;
+    const directory = sideDirectory(packageRoot, metadata, target);
+    const folder = stringValue((_a = objectValue(elements[target])) === null || _a === void 0 ? void 0 : _a.folder);
+    if (!directory || !folder)
+        return undefined;
+    return {
+        ...pluginRecord(pluginId, name, source, packageRoot, directory, folder, version),
+        sides
+    };
+}
+/**
+ * Every npm plugin the runtime can load for a side, built-in and project-installed.
+ *
+ * Built-in mappings win over a project mapping for the same id: a third-party
+ * package must not shadow a plugin that ships with the runtime. A project package
+ * that does not describe the requested side is skipped instead of failing, which
+ * is what lets a two-sided project share one dependency list between sides.
+ */
+function listNpmPlugins(side, options = {}) {
+    var _a;
+    const { packageRoot, projectRoot } = npmPluginRoots(options);
+    const host = readJson(path_1.default.join(packageRoot, "package.json"));
+    if (!host)
+        throw new Error(`Missing runtime package metadata: ${packageRoot}`);
+    const project = path_1.default.resolve(projectRoot) === path_1.default.resolve(packageRoot) ? null : readProjectManifest(projectRoot);
+    const hostMappings = mappingsOf(host);
+    const projectMappings = mappingsOf(project);
+    const mappings = new Map();
+    for (const [pluginId, name] of Object.entries(projectMappings)) {
+        if (!PLUGIN_ID.test(pluginId) || typeof name !== "string" || !PACKAGE_NAME.test(name))
+            continue;
+        mappings.set(pluginId, { name, source: "project" });
+    }
+    for (const [pluginId, name] of Object.entries(hostMappings)) {
+        if (!PLUGIN_ID.test(pluginId) || typeof name !== "string" || !PACKAGE_NAME.test(name))
+            continue;
+        mappings.set(pluginId, { name, source: "bundled" });
+    }
+    const hostDependencies = dependenciesOf(host);
+    const projectDependencies = dependenciesOf(project);
+    const folders = new Set();
+    const records = [];
+    for (const [pluginId, mapping] of mappings) {
+        const declared = (_a = hostDependencies[mapping.name]) !== null && _a !== void 0 ? _a : projectDependencies[mapping.name];
+        if (declared === undefined) {
+            if (options.skipInvalid)
+                continue;
+            throw new Error(`Missing npm plugin dependency: ${mapping.name}. Run npm install in the project directory.`);
+        }
+        let entry;
+        try {
+            entry = readPackageEntry(packageRoot, mapping.name);
+        }
+        catch (error) {
+            if (options.skipInvalid)
+                continue;
+            throw error;
+        }
+        const record = recordFromPackage(pluginId, mapping.name, mapping.source, entry.root, entry.metadata, side);
+        if (!record) {
+            if (options.skipInvalid || mapping.source === "project")
+                continue;
+            throw new Error(`Invalid ${side !== null && side !== void 0 ? side : "plugin"} entry in npm plugin ${mapping.name}.`);
+        }
+        const folder = record.folder;
+        if (folders.has(folder)) {
+            if (options.skipInvalid)
+                continue;
+            throw new Error(`Duplicate npm plugin asset directory: ${folder}.`);
+        }
+        folders.add(folder);
+        records.push(record);
+    }
+    return records;
+}
+function runNpm(args, cwd) {
+    return new Promise((resolve, reject) => {
+        var _a, _b, _c;
+        const npmCLI = process.env.npm_execpath;
+        const invocation = npmCLI && /npm(?:-cli)?\.(?:c?js|mjs)$/.test(npmCLI)
+            ? { command: process.execPath, args: [npmCLI, ...args], shell: false }
+            : process.platform === "win32"
+                ? {
+                    command: process.env.ComSpec || "cmd.exe",
+                    args: ["/d", "/s", "/c", `npm ${args.map((item) => `"${item.replace(/"/g, '""')}"`).join(" ")}`],
+                    shell: false
+                }
+                : { command: "npm", args, shell: false };
+        const child = (0, child_process_1.spawn)(invocation.command, invocation.args, {
+            cwd,
+            shell: invocation.shell,
+            windowsHide: true,
+            stdio: ["ignore", "pipe", "pipe"],
+            env: { ...process.env, npm_config_update_notifier: "false" }
+        });
+        let output = "";
+        const append = (data) => {
+            output += data.toString();
+            if (output.length > 16000)
+                output = output.slice(-16000);
+        };
+        (_a = child.stdout) === null || _a === void 0 ? void 0 : _a.on("data", append);
+        (_b = child.stderr) === null || _b === void 0 ? void 0 : _b.on("data", append);
+        const timer = setTimeout(() => {
+            var _a;
+            child.kill("SIGKILL");
+            reject(new Error(`npm ${(_a = args[0]) !== null && _a !== void 0 ? _a : ""} timed out.`));
+        }, 10 * 60 * 1000);
+        (_c = timer.unref) === null || _c === void 0 ? void 0 : _c.call(timer);
+        child.once("error", (error) => {
+            clearTimeout(timer);
+            reject(error);
+        });
+        child.once("close", (code) => {
+            var _a;
+            clearTimeout(timer);
+            if (code === 0)
+                return resolve(output);
+            reject(new Error(`npm ${(_a = args[0]) !== null && _a !== void 0 ? _a : ""} failed (${code}): ${output.trim()}`));
+        });
+    });
+}
+const operations = new Map();
+function withProjectLock(projectRoot, operation) {
+    var _a;
+    const key = process.platform === "win32" ? projectRoot.toLowerCase() : projectRoot;
+    const previous = (_a = operations.get(key)) !== null && _a !== void 0 ? _a : Promise.resolve();
+    const result = previous.then(operation);
+    const settled = result.then(() => { }, () => { });
+    operations.set(key, settled);
+    return result.finally(() => {
+        if (operations.get(key) === settled)
+            operations.delete(key);
+    });
+}
+/**
+ * Installs (or updates) one npm plugin as a project dependency.
+ *
+ * The version is pinned with `--save-exact`: the panel performs updates, so a
+ * later bare `npm install` must not silently move the plugin to another release.
+ */
+async function installNpmPlugin(options) {
+    const { name, pluginId, version, side } = options;
+    if (!PLUGIN_ID.test(pluginId))
+        throw new Error(`Invalid plugin id: ${pluginId}`);
+    if (!PACKAGE_NAME.test(name))
+        throw new Error(`Invalid npm plugin package: ${name}`);
+    if (!VERSION.test(version))
+        throw new Error(`Invalid plugin version: ${version}`);
+    const { packageRoot, projectRoot } = npmPluginRoots(options);
+    return withProjectLock(projectRoot, async () => {
+        var _a;
+        const host = readJson(path_1.default.join(packageRoot, "package.json"));
+        if (!host)
+            throw new Error(`Missing runtime package metadata: ${packageRoot}`);
+        if (mappingsOf(host)[pluginId] !== undefined)
+            throw new Error(`BUNDLED:${pluginId}`);
+        const existing = mappingsOf(readProjectManifest(projectRoot))[pluginId];
+        if (existing !== undefined && existing !== name)
+            throw new Error(`Plugin id ${pluginId} is already installed as ${String(existing)}.`);
+        await fs_extra_1.default.ensureDir(projectRoot);
+        await runNpm(["install", `${name}@${version}`, "--save", "--save-exact", "--no-fund", "--no-audit", "--ignore-scripts"], projectRoot);
+        let entry;
+        try {
+            entry = readPackageEntry(packageRoot, name);
+        }
+        catch (error) {
+            await runNpm(["uninstall", name, "--no-fund", "--no-audit", "--ignore-scripts"], projectRoot).catch(() => { });
+            throw error;
+        }
+        const record = recordFromPackage(pluginId, name, "project", entry.root, entry.metadata, side);
+        if (!record) {
+            await runNpm(["uninstall", name, "--no-fund", "--no-audit", "--ignore-scripts"], projectRoot).catch(() => { });
+            throw new Error(`The package ${name} does not provide a ${side} plugin named ${pluginId}.`);
+        }
+        if (record.version !== version) {
+            await runNpm(["uninstall", name, "--no-fund", "--no-audit", "--ignore-scripts"], projectRoot).catch(() => { });
+            throw new Error(`The installed package ${name} is ${record.version}, expected ${version}.`);
+        }
+        const manifest = readProjectManifest(projectRoot);
+        const dependencies = { ...dependenciesOf(manifest), [name]: version };
+        const elementspanel = { ...((_a = objectValue(manifest.elementspanel)) !== null && _a !== void 0 ? _a : {}) };
+        const plugins = { ...mappingsOf(manifest), [pluginId]: name };
+        manifest.dependencies = dependencies;
+        manifest.elementspanel = { ...elementspanel, plugins };
+        writeProjectManifest(projectRoot, manifest);
+        return record;
+    });
+}
+/** Removes one project-installed npm plugin. Built-in packages are left alone. */
+async function uninstallNpmPlugin(pluginId, options = {}) {
+    if (!PLUGIN_ID.test(pluginId))
+        throw new Error(`Invalid plugin id: ${pluginId}`);
+    const { packageRoot, projectRoot } = npmPluginRoots(options);
+    return withProjectLock(projectRoot, async () => {
+        var _a;
+        const host = readJson(path_1.default.join(packageRoot, "package.json"));
+        if (host && mappingsOf(host)[pluginId] !== undefined)
+            throw new Error(`BUNDLED:${pluginId}`);
+        const manifest = readProjectManifest(projectRoot);
+        const name = mappingsOf(manifest)[pluginId];
+        if (typeof name !== "string" || !PACKAGE_NAME.test(name))
+            return null;
+        const record = listNpmPlugins(undefined, { packageRoot, projectRoot, skipInvalid: true }).find((item) => item.pluginId === pluginId);
+        await runNpm(["uninstall", name, "--no-fund", "--no-audit", "--ignore-scripts"], projectRoot);
+        const plugins = { ...mappingsOf(manifest) };
+        delete plugins[pluginId];
+        const elementspanel = { ...((_a = objectValue(manifest.elementspanel)) !== null && _a !== void 0 ? _a : {}) };
+        if (Object.keys(plugins).length)
+            elementspanel.plugins = plugins;
+        else
+            delete elementspanel.plugins;
+        manifest.elementspanel = elementspanel;
+        writeProjectManifest(projectRoot, manifest);
+        return record !== null && record !== void 0 ? record : null;
+    });
+}
+
+
+/***/ },
+
+/***/ "../common/src/plugin_overrides.ts"
+(__unused_webpack_module, exports, __webpack_require__) {
+
+
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.pluginOverridesPath = pluginOverridesPath;
+exports.readPluginOverrides = readPluginOverrides;
+exports.validatePluginOverride = validatePluginOverride;
+exports.applyPluginOverrides = applyPluginOverrides;
+exports.writePluginOverride = writePluginOverride;
+const node_fs_1 = __importDefault(__webpack_require__("node:fs"));
+const node_path_1 = __importDefault(__webpack_require__("node:path"));
+const node_crypto_1 = __webpack_require__("node:crypto");
+function pluginOverridesPath() {
+    return node_path_1.default.resolve(process.cwd(), "data", "plugin-overrides.json");
+}
+/** Package defaults stay immutable; only the user's last layer lives in data. */
+function readPluginOverrides(filename = pluginOverridesPath()) {
+    let raw;
+    try {
+        raw = node_fs_1.default.readFileSync(filename, "utf8");
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return { version: 1, plugins: {} };
+        throw error;
+    }
+    const data = JSON.parse(raw);
+    if ((data === null || data === void 0 ? void 0 : data.version) !== 1 ||
+        !data.plugins ||
+        typeof data.plugins !== "object" ||
+        Array.isArray(data.plugins))
+        throw new Error("Invalid plugin-overrides.json");
+    for (const entry of Object.values(data.plugins))
+        validatePluginOverride(entry);
+    return data;
+}
+function validatePluginOverride(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        throw new Error("Invalid plugin override.");
+    const entry = value;
+    if (entry.enabled !== undefined && typeof entry.enabled !== "boolean")
+        throw new Error("Invalid plugin enablement.");
+    if (entry.config !== undefined &&
+        (!entry.config || typeof entry.config !== "object" || Array.isArray(entry.config)))
+        throw new Error("Plugin config must be an object.");
+    if (Object.keys(value).some((key) => !["enabled", "config"].includes(key)))
+        throw new Error("Unknown plugin override field.");
+}
+function applyPluginOverrides(plugins, filename = pluginOverridesPath()) {
+    const overrides = readPluginOverrides(filename).plugins;
+    return plugins.map((plugin) => ({
+        ...plugin,
+        manifest: {
+            ...plugin.manifest,
+            ...(Object.prototype.hasOwnProperty.call(overrides, plugin.manifest.id)
+                ? overrides[plugin.manifest.id]
+                : {})
+        }
+    }));
+}
+/** Call inside the host's change queue; rename keeps readers off partial JSON. */
+function writePluginOverride(id, patch, filename = pluginOverridesPath()) {
+    validatePluginOverride(patch);
+    if (!id || ["__proto__", "constructor", "prototype"].includes(id))
+        throw new Error("Invalid plugin id.");
+    const data = readPluginOverrides(filename);
+    data.plugins[id] = {
+        ...(Object.prototype.hasOwnProperty.call(data.plugins, id) ? data.plugins[id] : {}),
+        ...patch
+    };
+    node_fs_1.default.mkdirSync(node_path_1.default.dirname(filename), { recursive: true });
+    const temporary = `${filename}.${(0, node_crypto_1.randomBytes)(8).toString("hex")}.tmp`;
+    try {
+        node_fs_1.default.writeFileSync(temporary, `${JSON.stringify(data, null, 2)}\n`, { mode: 0o600, flag: "wx" });
+        node_fs_1.default.renameSync(temporary, filename);
+    }
+    finally {
+        node_fs_1.default.rmSync(temporary, { force: true });
+    }
+}
+
+
+/***/ },
+
+/***/ "../common/src/plugin_revision.ts"
+(__unused_webpack_module, exports, __webpack_require__) {
+
+
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.pluginDirectoryRevision = pluginDirectoryRevision;
+const node_fs_1 = __importDefault(__webpack_require__("node:fs"));
+const node_path_1 = __importDefault(__webpack_require__("node:path"));
+const node_crypto_1 = __webpack_require__("node:crypto");
+const cache = new Map();
+/** One revision addresses the complete module graph, including CSS and nested chunks. */
+function pluginDirectoryRevision(directory) {
+    const files = [];
+    const walk = (root) => {
+        if (!node_fs_1.default.existsSync(root))
+            return;
+        for (const item of node_fs_1.default
+            .readdirSync(root, { withFileTypes: true })
+            .sort((a, b) => a.name.localeCompare(b.name))) {
+            const absolute = node_path_1.default.join(root, item.name);
+            if (item.isDirectory())
+                walk(absolute);
+            else if (item.isFile())
+                files.push({
+                    relative: node_path_1.default.relative(directory, absolute),
+                    absolute,
+                    stat: node_fs_1.default.statSync(absolute)
+                });
+        }
+    };
+    walk(directory);
+    const signature = JSON.stringify(files.map(({ relative, stat }) => [relative, stat.size, stat.mtimeMs, stat.ctimeMs]));
+    const previous = cache.get(directory);
+    if ((previous === null || previous === void 0 ? void 0 : previous.signature) === signature)
+        return previous.revision;
+    const hash = (0, node_crypto_1.createHash)("sha256");
+    for (const file of files)
+        hash
+            .update(file.relative)
+            .update("\0")
+            .update(new Uint8Array(node_fs_1.default.readFileSync(file.absolute)))
+            .update("\0");
+    const revision = hash.digest("hex").slice(0, 24);
+    if (cache.size > 1024)
+        cache.clear();
+    cache.set(directory, { signature, revision });
+    return revision;
+}
+
+
+/***/ },
+
+/***/ "../common/src/process_tools.ts"
+(__unused_webpack_module, exports, __webpack_require__) {
+
+
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.ProcessWrapper = exports.StartError = void 0;
+exports.killProcess = killProcess;
+const child_process_1 = __webpack_require__("child_process");
+const os_1 = __importDefault(__webpack_require__("os"));
+const child_process_2 = __importDefault(__webpack_require__("child_process"));
+const path_1 = __importDefault(__webpack_require__("path"));
+const events_1 = __importDefault(__webpack_require__("events"));
+const iconv_lite_1 = __importDefault(__webpack_require__("iconv-lite"));
+const process_1 = __importDefault(__webpack_require__("process"));
+class StartError extends Error {
+}
+exports.StartError = StartError;
+class ProcessWrapper extends events_1.default {
+    constructor(file, args, cwd, timeout = 0, code = "utf-8", option = {}) {
+        super();
+        this.file = file;
+        this.args = args;
+        this.cwd = cwd;
+        this.timeout = timeout;
+        this.code = code;
+        this.option = option;
+        this.completed = false;
+        this.errMsg = {
+            timeoutErr: "task timeout!",
+            exitErr: "task error!",
+            startErr: "task start error!"
+        };
+    }
+    setErrMsg(errMsg) {
+        this.errMsg = errMsg;
+    }
+    start() {
+        if (this.process)
+            return Promise.reject(new Error("The process is already running"));
+        return new Promise((resolve, reject) => {
+            const stdoutDecoder = iconv_lite_1.default.decodeStream(this.code);
+            const stderrDecoder = iconv_lite_1.default.decodeStream(this.code);
+            let timeTask;
+            let settled = false;
+            let spawned = false;
+            const settle = (error) => {
+                if (settled)
+                    return;
+                settled = true;
+                if (timeTask)
+                    clearTimeout(timeTask);
+                if (error)
+                    reject(error);
+                else
+                    resolve(true);
+            };
+            const subProcess = child_process_2.default.spawn(this.file, this.args, {
+                stdio: "pipe",
+                windowsHide: true,
+                cwd: path_1.default.normalize(this.cwd),
+                ...this.option
+            });
+            this.process = subProcess;
+            this.pid = subProcess.pid;
+            this.lastExitCode = undefined;
+            this.completed = false;
+            const fail = (error) => {
+                if (settled)
+                    return;
+                settle(error);
+                if (subProcess.pid && subProcess.exitCode === null && subProcess.signalCode === null) {
+                    try {
+                        killProcess(subProcess.pid, subProcess);
+                    }
+                    catch (error) {
+                        console.error("[ProcessWrapper kill error]", error);
+                    }
+                }
+            };
+            subProcess.once("spawn", () => {
+                spawned = true;
+                this.emit("start", subProcess.pid);
+            });
+            for (const [source, decoder] of [
+                [subProcess.stdout, stdoutDecoder],
+                [subProcess.stderr, stderrDecoder]
+            ]) {
+                decoder.on("data", (text) => this.emit("data", text));
+                decoder.on("error", fail);
+                source.on("error", fail);
+                source.pipe(decoder);
+            }
+            subProcess.stdin.on("error", fail);
+            subProcess.once("error", (error) => {
+                fail(new Error(`${spawned ? this.errMsg.exitErr : this.errMsg.startErr} ${error.message}`));
+            });
+            subProcess.once("exit", (code) => {
+                this.lastExitCode = code;
+                this.emit("exit", code);
+            });
+            // `close` follows the final stdout/stderr data and also follows a failed spawn.
+            subProcess.once("close", (code) => {
+                this.lastExitCode = code;
+                this.completed = true;
+                this.process = undefined;
+                settle(code === 0 ? undefined : new Error(this.errMsg.exitErr));
+            });
+            if (this.timeout > 0) {
+                timeTask = setTimeout(() => {
+                    fail(new Error(this.errMsg.timeoutErr));
+                }, 1000 * this.timeout);
+            }
+        });
+    }
+    getPid() {
+        var _a;
+        return (_a = this.process) === null || _a === void 0 ? void 0 : _a.pid;
+    }
+    write(data) {
+        var _a, _b;
+        return (_b = (_a = this.process) === null || _a === void 0 ? void 0 : _a.stdin) === null || _b === void 0 ? void 0 : _b.write(iconv_lite_1.default.encode(data, this.code));
+    }
+    kill() {
+        var _a, _b;
+        if ((_a = this.process) === null || _a === void 0 ? void 0 : _a.pid)
+            killProcess((_b = this.process) === null || _b === void 0 ? void 0 : _b.pid, this.process);
+    }
+    status() {
+        return this.completed;
+    }
+    exitCode() {
+        var _a, _b;
+        return (_b = (_a = this.process) === null || _a === void 0 ? void 0 : _a.exitCode) !== null && _b !== void 0 ? _b : this.lastExitCode;
+    }
+}
+exports.ProcessWrapper = ProcessWrapper;
+function killProcess(pid, process, signal) {
+    const numericPid = Number(pid);
+    if (!Number.isSafeInteger(numericPid) || numericPid <= 0) {
+        throw new Error("Invalid process ID");
+    }
+    try {
+        if (os_1.default.platform() === "win32") {
+            (0, child_process_1.execFileSync)("taskkill", ["/PID", String(numericPid), "/T", "/F"], { windowsHide: true });
+            return true;
+        }
+        return process_1.default.kill(numericPid, signal || "SIGKILL");
+    }
+    catch (err) {
+        return signal ? process.kill(signal) : process.kill("SIGKILL");
+    }
+}
+
+
+/***/ },
+
+/***/ "../common/src/query_wrapper.ts"
+(__unused_webpack_module, exports) {
+
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.QueryWrapper = exports.LocalFileSource = exports.MySqlSource = exports.QueryMapWrapper = void 0;
+function paginate(data, page, pageSize) {
+    if (!Number.isSafeInteger(page) || page < 1 || !Number.isSafeInteger(pageSize) || pageSize < 1) {
+        throw new RangeError("page and pageSize must be positive integers");
+    }
+    const start = (page - 1) * pageSize;
+    return {
+        page,
+        pageSize,
+        maxPage: Math.ceil(data.length / pageSize),
+        total: data.length,
+        data: data.slice(start, start + pageSize)
+    };
+}
+// Provide the MAP query interface used by the routing layer
+class QueryMapWrapper {
+    constructor(map) {
+        this.map = map;
+    }
+    select(condition) {
+        const result = [];
+        this.map.forEach((v) => {
+            if (condition(v))
+                result.push(v);
+        });
+        return result;
+    }
+    page(data, page = 1, pageSize = 10) {
+        return paginate(data, page, pageSize);
+    }
+}
+exports.QueryMapWrapper = QueryMapWrapper;
+// MYSQL data source
+class MySqlSource {
+    constructor(data) {
+        this.data = data;
+    }
+    selectPage(condition, page, pageSize) {
+        return {
+            page,
+            pageSize,
+            maxPage: 0,
+            total: 0,
+            data: []
+        };
+    }
+    select(condition) {
+        return [];
+    }
+    update(condition, data) { }
+    delete(condition) { }
+    insert(data) { }
+}
+exports.MySqlSource = MySqlSource;
+// local file data source (embedded microdatabase)
+class LocalFileSource {
+    constructor(data) {
+        this.data = data;
+    }
+    selectPage(condition, page = 1, pageSize = 10) {
+        return this.page(this.select(condition), page, pageSize);
+    }
+    page(data, page = 1, pageSize = 10) {
+        return paginate(data, page, pageSize);
+    }
+    select(condition = {}) {
+        const result = [];
+        const entries = Object.entries(condition);
+        this.data.forEach((v) => {
+            for (const [key, targetValue] of entries) {
+                const dataValue = v[key];
+                if (typeof targetValue === "string" &&
+                    targetValue.startsWith("%") &&
+                    targetValue.endsWith("%")) {
+                    if (typeof dataValue !== "string" || !dataValue.includes(targetValue.slice(1, -1)))
+                        return;
+                }
+                else if (targetValue !== dataValue) {
+                    return;
+                }
+            }
+            result.push(v);
+        });
+        return result;
+    }
+    update(condition, data) { }
+    delete(condition) { }
+    insert(data) { }
+}
+exports.LocalFileSource = LocalFileSource;
+// Provide the unified data query interface used by the routing layer
+class QueryWrapper {
+    constructor(dataSource) {
+        this.dataSource = dataSource;
+    }
+    selectPage(condition, page = 1, pageSize = 10) {
+        return this.dataSource.selectPage(condition, page, pageSize);
+    }
+}
+exports.QueryWrapper = QueryWrapper;
+
+
+/***/ },
+
+/***/ "../common/src/runtime_paths.ts"
+(__unused_webpack_module, exports, __webpack_require__) {
+
+
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.isPackagedRuntime = isPackagedRuntime;
+exports.packagePath = packagePath;
+exports.packagePluginRoots = packagePluginRoots;
+exports.isPackagePlugin = isPackagePlugin;
+exports.bundledToolPath = bundledToolPath;
+exports.ensureExecutable = ensureExecutable;
+const node_fs_1 = __importDefault(__webpack_require__("node:fs"));
+const node_os_1 = __importDefault(__webpack_require__("node:os"));
+const node_path_1 = __importDefault(__webpack_require__("node:path"));
+/** Set by the npm worker before any application module is loaded. */
+function isPackagedRuntime() {
+    return Boolean(process.env.EPANEL_PACKAGE_ROOT);
+}
+/** Code and bundled assets belong to the package; cwd always belongs to the user. */
+function packagePath(...parts) {
+    return node_path_1.default.resolve(process.env.EPANEL_PACKAGE_ROOT || process.cwd(), ...parts);
+}
+function npmPluginRoots(side) {
+    // The same resolver is used by the CLI before the bundled application starts.
+    // A development checkout keeps it in the repository, beside the side packages,
+    // so project-installed npm plugins work there as well.
+    const runtimeRequire = eval("require");
+    const resolver = isPackagedRuntime()
+        ? packagePath("runtime/npm-plugins.cjs")
+        : node_path_1.default.resolve(packagePath(), "..", "scripts", "runtime", "npm-plugins.cjs");
+    // A development process may run from a fixture directory without a runtime
+    // package; there is nothing to resolve in that case.
+    if (!node_fs_1.default.existsSync(node_path_1.default.join(packagePath(), "package.json")))
+        return [];
+    if (!isPackagedRuntime() && !node_fs_1.default.existsSync(resolver))
+        return [];
+    const { resolveNpmPlugins } = runtimeRequire(resolver);
+    return resolveNpmPlugins(packagePath(), side, { skipInvalid: true }).map((record) => ({
+        directory: record.directory,
+        ...(record.folder ? { folder: record.folder } : {}),
+        // Built-in packages are part of the runtime's default configuration. A
+        // project dependency is installed but remains dormant until the user
+        // enables it through the plugin configuration service.
+        defaultEnabled: record.defaultEnabled !== false
+    }));
+}
+function packagePluginRoots(side) {
+    const roots = isPackagedRuntime()
+        ? []
+        : [{ directory: packagePath("plugins"), defaultEnabled: true }];
+    // Project-installed npm plugins load in development too: they are dependencies
+    // of the development project, not of the published runtime package.
+    roots.push(...npmPluginRoots(side));
+    return roots;
+}
+function isPackagePlugin(directory) {
+    return npmPluginRoots().some((root) => {
+        const relative = node_path_1.default.relative(root.directory, node_path_1.default.resolve(directory));
+        return (relative === "" ||
+            (!relative.startsWith(`..${node_path_1.default.sep}`) && relative !== ".." && !node_path_1.default.isAbsolute(relative)));
+    });
+}
+function bundledToolPath(name) {
+    const platform = node_os_1.default.platform();
+    const arch = node_os_1.default.arch();
+    const suffix = platform === "win32" ? ".exe" : "";
+    const filename = `${name}_${platform}_${arch}${suffix}`;
+    // Published daemon packages download native tools into the installation's
+    // writable lib directory on first start. Development checkouts use the same
+    // repository-local sibling of data and logs.
+    const root = isPackagedRuntime() ? node_path_1.default.resolve(process.cwd(), "lib") : packagePath("lib");
+    const primary = node_path_1.default.join(root, filename);
+    // Zip-Tools names its Intel macOS binary "amd64", while Node reports "x64".
+    if (!node_fs_1.default.existsSync(primary) && name === "file_zip" && platform === "darwin" && arch === "x64") {
+        const alternate = node_path_1.default.join(root, "file_zip_darwin_amd64");
+        if (node_fs_1.default.existsSync(alternate))
+            return alternate;
+    }
+    return primary;
+}
+/** Published binaries already carry executable permissions, including in read-only installs. */
+function ensureExecutable(filename) {
+    if (node_os_1.default.platform() === "win32")
+        return;
+    try {
+        node_fs_1.default.accessSync(filename, node_fs_1.default.constants.X_OK);
+    }
+    catch (_a) {
+        node_fs_1.default.chmodSync(filename, 0o755);
+    }
+}
+
+
+/***/ },
+
+/***/ "../common/src/string_utils.ts"
+(__unused_webpack_module, exports) {
+
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.removeTrail = removeTrail;
+function removeTrail(origin, trail) {
+    if (origin.endsWith(trail)) {
+        return origin.slice(0, origin.length - trail.length);
+    }
+    else {
+        return origin;
+    }
+}
+
+
+/***/ },
+
+/***/ "../common/src/system_info.ts"
+(__unused_webpack_module, exports, __webpack_require__) {
+
+
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.systemInfo = systemInfo;
+const os_1 = __importDefault(__webpack_require__("os"));
+const os_utils_1 = __importDefault(__webpack_require__("os-utils"));
+const fs_1 = __importDefault(__webpack_require__("fs"));
+// System details are updated every time
+const info = {
+    type: os_1.default.type(),
+    hostname: os_1.default.hostname(),
+    platform: os_1.default.platform(),
+    release: os_1.default.release(),
+    uptime: os_1.default.uptime(),
+    cwd: process.cwd(),
+    loadavg: os_1.default.loadavg(),
+    freemem: 0,
+    cpuUsage: 0,
+    memUsage: 0,
+    totalmem: 0,
+    processCpu: 0,
+    processMem: 0
+};
+let previousCpu = process.cpuUsage();
+let previousTime = process.hrtime.bigint();
+// periodically refresh the cache
+function refresh() {
+    const now = process.hrtime.bigint();
+    const cpu = process.cpuUsage();
+    const elapsed = Number(now - previousTime) / 1000;
+    info.processCpu =
+        elapsed > 0 ? (cpu.user - previousCpu.user + cpu.system - previousCpu.system) / elapsed : 0;
+    previousCpu = cpu;
+    previousTime = now;
+    info.uptime = os_1.default.uptime();
+    info.loadavg = os_1.default.loadavg();
+    info.processMem = process.memoryUsage().rss;
+    if (os_1.default.platform() === "linux") {
+        return setLinuxSystemInfo();
+    }
+    return otherSystemInfo();
+}
+refresh();
+setInterval(refresh, 3000).unref();
+function otherSystemInfo() {
+    info.freemem = os_1.default.freemem();
+    info.totalmem = os_1.default.totalmem();
+    info.memUsage = (os_1.default.totalmem() - os_1.default.freemem()) / os_1.default.totalmem();
+    os_utils_1.default.cpuUsage((p) => (info.cpuUsage = p));
+}
+function setLinuxSystemInfo() {
+    var _a;
+    try {
+        // read memory data based on /proc/meminfo
+        const data = fs_1.default.readFileSync("/proc/meminfo", { encoding: "utf-8" });
+        const list = data.split("\n");
+        const infoTable = {};
+        list.forEach((line) => {
+            const kv = line.split(":");
+            if (kv.length === 2) {
+                const k = kv[0].replace(/ /gim, "").replace(/\t/gim, "").trim().toLowerCase();
+                let v = kv[1].replace(/ /gim, "").replace(/\t/gim, "").trim().toLowerCase();
+                v = v.replace(/kb/gim, "").replace(/mb/gim, "").replace(/gb/gim, "");
+                let vNumber = parseInt(v);
+                if (isNaN(vNumber))
+                    vNumber = 0;
+                infoTable[k] = vNumber;
+            }
+        });
+        const memAvailable = (_a = infoTable["memavailable"]) !== null && _a !== void 0 ? _a : infoTable["memfree"];
+        const memTotal = infoTable["memtotal"];
+        info.freemem = memAvailable * 1024;
+        info.totalmem = memTotal * 1024;
+        info.memUsage = (info.totalmem - info.freemem) / info.totalmem;
+        os_utils_1.default.cpuUsage((p) => (info.cpuUsage = p));
+    }
+    catch (error) {
+        // If the reading is wrong, the default general reading method is automatically used
+        otherSystemInfo();
+    }
+}
+function systemInfo() {
+    return info;
+}
+
+
+/***/ },
+
+/***/ "../common/src/system_storage.ts"
+(__unused_webpack_module, exports, __webpack_require__) {
+
+
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+const crypto_1 = __webpack_require__("crypto");
+const path_1 = __importDefault(__webpack_require__("path"));
+const fs_extra_1 = __importDefault(__webpack_require__("fs-extra"));
+class StorageSubsystem {
+    resolvePath(name) {
+        if (typeof name !== "string" ||
+            !name ||
+            /[\0:]/.test(name) ||
+            path_1.default.isAbsolute(name) ||
+            path_1.default.win32.isAbsolute(name)) {
+            throw new Error(`Invalid storage path: ${name}`);
+        }
+        const target = path_1.default.resolve(StorageSubsystem.DATA_PATH, name);
+        const relative = path_1.default.relative(StorageSubsystem.DATA_PATH, target);
+        if (!relative ||
+            relative === ".." ||
+            relative.startsWith(`..${path_1.default.sep}`) ||
+            path_1.default.isAbsolute(relative)) {
+            throw new Error(`Invalid storage path: ${name}`);
+        }
+        const realRelative = path_1.default.relative(this.realPath(StorageSubsystem.DATA_PATH), this.realPath(target));
+        if (realRelative === ".." ||
+            realRelative.startsWith(`..${path_1.default.sep}`) ||
+            path_1.default.isAbsolute(realRelative)) {
+            throw new Error(`Invalid storage path: ${name}`);
+        }
+        return target;
+    }
+    realPath(target) {
+        if (fs_extra_1.default.existsSync(target))
+            return fs_extra_1.default.realpathSync(target);
+        const parent = path_1.default.dirname(target);
+        return parent === target ? target : path_1.default.join(this.realPath(parent), path_1.default.basename(target));
+    }
+    entityPath(category, uuid) {
+        if (typeof uuid !== "string" || !uuid || /[\\/\0:]/.test(uuid) || uuid.includes("..")) {
+            throw new Error(`UUID ${uuid} does not conform to specification`);
+        }
+        this.resolvePath(category);
+        return path_1.default.join(category, `${uuid}.json`);
+    }
+    writeFile(name, data) {
+        const targetPath = this.resolvePath(name);
+        fs_extra_1.default.ensureDirSync(path_1.default.dirname(targetPath));
+        const temporaryPath = `${targetPath}.${(0, crypto_1.randomUUID)()}.tmp`;
+        const mode = fs_extra_1.default.existsSync(targetPath) ? fs_extra_1.default.statSync(targetPath).mode : 0o600;
+        try {
+            fs_extra_1.default.writeFileSync(temporaryPath, data, { encoding: "utf8", flag: "wx", mode });
+            fs_extra_1.default.renameSync(temporaryPath, targetPath);
+        }
+        finally {
+            if (fs_extra_1.default.existsSync(temporaryPath))
+                fs_extra_1.default.unlinkSync(temporaryPath);
+        }
+    }
+    readFile(name) {
+        return fs_extra_1.default.readFileSync(this.resolvePath(name), "utf8");
+    }
+    readDir(dirName) {
+        const targetPath = this.resolvePath(dirName);
+        if (!fs_extra_1.default.existsSync(targetPath))
+            return [];
+        return fs_extra_1.default.readdirSync(targetPath).map((name) => path_1.default.join(dirName, name));
+    }
+    deleteFile(name) {
+        fs_extra_1.default.removeSync(this.resolvePath(name));
+    }
+    fileExists(name) {
+        return fs_extra_1.default.existsSync(this.resolvePath(name));
+    }
+    store(category, uuid, object) {
+        this.writeFile(this.entityPath(category, uuid), JSON.stringify(object, null, 4));
+    }
+    // Restore declared fields while keeping defaults for fields absent in older data.
+    defineAttr(target, object) {
+        for (const key of Object.keys(target)) {
+            if (!Object.prototype.hasOwnProperty.call(object, key) || object[key] === undefined)
+                continue;
+            const value = object[key];
+            if (value !== null &&
+                typeof value === "object" &&
+                !Array.isArray(value) &&
+                target[key] !== null &&
+                typeof target[key] === "object" &&
+                !Array.isArray(target[key])) {
+                this.defineAttr(target[key], value);
+            }
+            else {
+                target[key] = value;
+            }
+        }
+        return target;
+    }
+    load(category, classz, uuid) {
+        const file = this.entityPath(category, uuid);
+        if (!this.fileExists(file))
+            return null;
+        const object = JSON.parse(this.readFile(file));
+        if (!object || typeof object !== "object" || Array.isArray(object)) {
+            throw new Error(`Invalid stored entity: ${file}`);
+        }
+        return this.defineAttr(new classz(), object);
+    }
+    list(category) {
+        const directory = this.resolvePath(category);
+        if (!fs_extra_1.default.existsSync(directory))
+            return [];
+        return fs_extra_1.default
+            .readdirSync(directory, { withFileTypes: true })
+            .filter((entry) => entry.isFile() && entry.name.endsWith(".json"))
+            .map((entry) => entry.name.slice(0, -5));
+    }
+    delete(category, uuid) {
+        this.deleteFile(this.entityPath(category, uuid));
+    }
+}
+StorageSubsystem.DATA_PATH = path_1.default.resolve(process.cwd(), "data");
+StorageSubsystem.INDEX_PATH = path_1.default.join(StorageSubsystem.DATA_PATH, "Index");
+exports["default"] = StorageSubsystem;
+
+
+/***/ },
+
+/***/ "../common/src/typecheck.ts"
+(__unused_webpack_module, exports) {
+
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.configureEntityParams = configureEntityParams;
+exports.toText = toText;
+exports.toNumber = toNumber;
+exports.toBoolean = toBoolean;
+exports.isEmpty = isEmpty;
+exports.supposeValue = supposeValue;
+function configureEntityParams(self, args, key, typeFn) {
+    var _a;
+    const selfDefaultValue = (_a = self[key]) !== null && _a !== void 0 ? _a : null;
+    const v = args[key] != null ? args[key] : selfDefaultValue;
+    if (typeFn === Number) {
+        if (v === "" || v == null) {
+            self[key] = null;
+        }
+        else {
+            if (isNaN(Number(v)))
+                throw new Error(`ConfigureEntityParams Error: Expected type to be Number, but got ${typeof v}`);
+            self[key] = Number(v);
+        }
+        return;
+    }
+    if (typeFn === String) {
+        if (v == null) {
+            self[key] = null;
+        }
+        else {
+            self[key] = String(v);
+        }
+        return;
+    }
+    if (typeFn === Boolean) {
+        if (v == null) {
+            self[key] = false;
+        }
+        else {
+            self[key] = Boolean(v);
+        }
+        return;
+    }
+    if (typeFn) {
+        self[key] = typeFn(v);
+    }
+    else {
+        self[key] = v;
+    }
+}
+function toText(v) {
+    if (isEmpty(v))
+        return null;
+    return String(v);
+}
+function toNumber(v) {
+    if (isEmpty(v))
+        return null;
+    if (isNaN(Number(v)))
+        return null;
+    return Number(v);
+}
+function toBoolean(v) {
+    if (isEmpty(v))
+        return null;
+    return Boolean(v);
+}
+function isEmpty(v) {
+    return v === null || v === undefined;
+}
+function supposeValue(v, def) {
+    if (isEmpty(v))
+        return def;
+    return v;
+}
+
+
+/***/ },
+
+/***/ "./plugins/config/src/backend/settings.ts"
+(__unused_webpack_module, exports, __webpack_require__) {
+
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.SettingsFormService = void 0;
+const mcsmanager_common_1 = __webpack_require__("../common/src/index.ts");
+const cordis_1 = __webpack_require__("cordis");
+const cosmokit_1 = __webpack_require__("cosmokit");
+/**
+ * The configuration registry belongs to the config plugin. A declaration is
+ * scoped to the plugin that made it, so unloading that plugin removes its form
+ * without leaving stale entries in the settings page.
+ */
+class SettingsFormService extends cordis_1.Service {
+    constructor(ctx) {
+        super(ctx, "settingsForm", true);
+        this.declarations = [];
+    }
+    declare(declaration) {
+        const entry = { id: this.ctx.name, declaration };
+        return this.ctx.effect(() => {
+            this.declarations.push(entry);
+            return () => (0, cosmokit_1.remove)(this.declarations, entry);
+        });
+    }
+    declared() {
+        return this.declarations.map((entry) => entry.id);
+    }
+    async read(id) {
+        const entry = this.declarations.find((item) => item.id === id);
+        if (!entry) {
+            const schema = this.ctx.plugins.configuration(id);
+            return schema.fields.length ? schema : null;
+        }
+        return {
+            id,
+            fields: entry.declaration.fields(),
+            values: await entry.declaration.read()
+        };
+    }
+    async write(id, values) {
+        const entry = this.declarations.find((item) => item.id === id);
+        if (!entry)
+            return (await this.ctx.plugins.configure(id, values)).result;
+        return this.ctx.plugins.runExclusive(async () => {
+            (0, mcsmanager_common_1.validatePluginSettings)(entry.declaration.fields(), values);
+            await entry.declaration.write(values);
+            return {
+                saved: true,
+                application: entry.declaration.restartRequired ? "restart-required" : "applied"
+            };
+        });
+    }
+}
+exports.SettingsFormService = SettingsFormService;
+
+
+/***/ },
+
+/***/ "./plugins/config/src/i18n/index.ts"
+(__unused_webpack_module, exports, __webpack_require__) {
+
+
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.localeMessages = void 0;
+const de_DE_json_1 = __importDefault(__webpack_require__("./plugins/config/src/i18n/de_DE.json"));
+const en_US_json_1 = __importDefault(__webpack_require__("./plugins/config/src/i18n/en_US.json"));
+const es_ES_json_1 = __importDefault(__webpack_require__("./plugins/config/src/i18n/es_ES.json"));
+const fr_FR_json_1 = __importDefault(__webpack_require__("./plugins/config/src/i18n/fr_FR.json"));
+const ja_JP_json_1 = __importDefault(__webpack_require__("./plugins/config/src/i18n/ja_JP.json"));
+const ko_KR_json_1 = __importDefault(__webpack_require__("./plugins/config/src/i18n/ko_KR.json"));
+const pt_BR_json_1 = __importDefault(__webpack_require__("./plugins/config/src/i18n/pt_BR.json"));
+const ru_RU_json_1 = __importDefault(__webpack_require__("./plugins/config/src/i18n/ru_RU.json"));
+const th_TH_json_1 = __importDefault(__webpack_require__("./plugins/config/src/i18n/th_TH.json"));
+const tr_TR_json_1 = __importDefault(__webpack_require__("./plugins/config/src/i18n/tr_TR.json"));
+const zh_CN_json_1 = __importDefault(__webpack_require__("./plugins/config/src/i18n/zh_CN.json"));
+const zh_TW_json_1 = __importDefault(__webpack_require__("./plugins/config/src/i18n/zh_TW.json"));
+exports.localeMessages = {
+    de_de: de_DE_json_1.default,
+    en_us: en_US_json_1.default,
+    es_es: es_ES_json_1.default,
+    fr_fr: fr_FR_json_1.default,
+    ja_jp: ja_JP_json_1.default,
+    ko_kr: ko_KR_json_1.default,
+    pt_br: pt_BR_json_1.default,
+    ru_ru: ru_RU_json_1.default,
+    th_th: th_TH_json_1.default,
+    tr_tr: tr_TR_json_1.default,
+    zh_cn: zh_CN_json_1.default,
+    zh_tw: zh_TW_json_1.default
+};
+
+
+/***/ },
+
+/***/ "crypto"
+(module) {
+
+module.exports = require("crypto");
+
+/***/ },
+
+/***/ "events"
+(module) {
+
+module.exports = require("events");
+
+/***/ },
+
+/***/ "fs-extra"
+(module) {
+
+module.exports = require("fs-extra");
+
+/***/ },
+
+/***/ "iconv-lite"
+(module) {
+
+module.exports = require("iconv-lite");
+
+/***/ },
+
+/***/ "os-utils"
+(module) {
+
+module.exports = require("os-utils");
+
+/***/ },
+
+/***/ "cordis"
+(module) {
+
+module.exports = require("cordis");
+
+/***/ },
+
+/***/ "cosmokit"
+(module) {
+
+module.exports = require("cosmokit");
+
+/***/ },
+
+/***/ "child_process"
+(module) {
+
+module.exports = require("child_process");
+
+/***/ },
+
+/***/ "fs"
+(module) {
+
+module.exports = require("fs");
+
+/***/ },
+
+/***/ "module"
+(module) {
+
+module.exports = require("module");
+
+/***/ },
+
+/***/ "net"
+(module) {
+
+module.exports = require("net");
+
+/***/ },
+
+/***/ "node:crypto"
+(module) {
+
+module.exports = require("node:crypto");
+
+/***/ },
+
+/***/ "node:fs"
+(module) {
+
+module.exports = require("node:fs");
+
+/***/ },
+
+/***/ "node:os"
+(module) {
+
+module.exports = require("node:os");
+
+/***/ },
+
+/***/ "node:path"
+(module) {
+
+module.exports = require("node:path");
+
+/***/ },
+
+/***/ "os"
+(module) {
+
+module.exports = require("os");
+
+/***/ },
+
+/***/ "path"
+(module) {
+
+module.exports = require("path");
+
+/***/ },
+
+/***/ "process"
+(module) {
+
+module.exports = require("process");
+
+/***/ },
+
+/***/ "./plugins/config/src/i18n/de_DE.json"
+(module) {
+
+module.exports = /*#__PURE__*/JSON.parse('{"TXT_CODE_PLUGIN_NODE_DISABLE_CONFIRM":"Möchtest du das entsprechende Plugin auch auf den folgenden Knoten deaktivieren? Wähle die gewünschten Knoten aus.","TXT_CODE_PLUGIN_NODE_DELETE_CONFIRM":"Möchtest du das entsprechende Plugin auch von den folgenden Knoten entfernen? Wähle die gewünschten Knoten aus.","TXT_CODE_PLUGIN_NODE_CHECK_FAILED":"Die Plugins auf diesen Knoten konnten nicht geprüft werden: {nodes}.","TXT_CODE_PLUGIN_NODE_ACTION_FAILED":"Die Plugin-Aktion wurde auf diesen Knoten nicht abgeschlossen: {nodes}","TXT_CODE_PLUGIN_CONFIG":"Plugin-Konfiguration","TXT_CODE_PLUGIN_CANCEL":"Abbrechen","TXT_CODE_PLUGIN_DELETE":"Entfernen","TXT_CODE_PLUGIN_DELETE_CONFIRM":"Die Plugin-Dateien und gespeicherten Einstellungen werden dauerhaft entfernt.","TXT_CODE_PLUGIN_DELETE_CONFIRM_TITLE":"{name} entfernen?","TXT_CODE_PLUGIN_DELETE_UNAVAILABLE":"Plugins are installed as npm dependencies; remove them with npm.","TXT_CODE_PLUGIN_DELETED":"Plugin entfernt","TXT_CODE_PLUGIN_SAVE_SETTINGS":"Einstellungen speichern","TXT_CODE_PLUGIN_SAVE_REMINDER":"Denke daran, deine Einstellungen zu speichern!","TXT_CODE_PLUGIN_DISABLE":"Deaktivieren","TXT_CODE_PLUGIN_DISABLED":"Plugin deaktiviert","TXT_CODE_PLUGIN_DISABLE_CONFIRM":"Alles, was dieses Plugin bereitstellt, wird sofort entfernt.","TXT_CODE_PLUGIN_DISABLE_CONFIRM_TITLE":"{name} deaktivieren?","TXT_CODE_PLUGIN_ENABLE":"Aktivieren","TXT_CODE_PLUGIN_ENABLED":"Plugin aktiviert","TXT_CODE_PLUGIN_ESSENTIAL_DISABLE":"Der Webserver kann nicht über das Panel deaktiviert werden, das er selbst bereitstellt. Setze stattdessen enabled auf false in seiner plugin.json.","TXT_CODE_PLUGIN_IS_DISABLED":"Dieses Plugin ist deaktiviert. Seine Seiten, Routen und API sind erst nach dem Aktivieren wieder verfügbar.","TXT_CODE_PLUGIN_LOAD_FAILED":"Dieses Plugin konnte nicht geladen werden","TXT_CODE_PLUGIN_NODE_LIST_FAILED":"Die Plugins dieses Knotens konnten nicht aufgelistet werden.","TXT_CODE_PLUGIN_NODE_NOT_FOUND":"Dieser Knoten existiert nicht.","TXT_CODE_PLUGIN_NODE_OFFLINE":"nicht verbunden","TXT_CODE_PLUGIN_NODE_SELECT":"Knoten auswählen","TXT_CODE_PLUGIN_NO_CONFIG":"Dieses Plugin hat keine konfigurierbaren Optionen.","TXT_CODE_PLUGIN_GROUP_UNASSIGNED":"Nicht zugeordnet","TXT_CODE_PLUGIN_GROUP_ADD":"Gruppe hinzufügen","TXT_CODE_PLUGIN_GROUP_EDIT":"Plugin-Gruppe bearbeiten","TXT_CODE_PLUGIN_GROUP_RENAME":"Gruppe umbenennen","TXT_CODE_PLUGIN_GROUP_DELETE":"Gruppe löschen","TXT_CODE_PLUGIN_GROUP_DELETE_CONFIRM_TITLE":"Gruppe {name} löschen?","TXT_CODE_PLUGIN_GROUP_DELETE_CONFIRM":"Die Gruppe und ihre Plugin-Zuordnungen werden entfernt. Die Plugins selbst werden nicht gelöscht.","TXT_CODE_PLUGIN_GROUP_NAME":"Gruppenname","TXT_CODE_PLUGIN_SCOPE_NODE":"Knoten","TXT_CODE_PLUGIN_SCOPE_PANEL":"Panel","TXT_CODE_PLUGIN_SELF_DISABLE":"Die Plugin-Verwaltung kann sich nicht selbst deaktivieren. Setze stattdessen enabled auf false in ihrer plugin.json.","TXT_CODE_PLUGIN_STATE_PENDING":"Wartet auf Abhängigkeiten","TXT_CODE_PLUGIN_STATE_DISABLED":"Deaktiviert","TXT_CODE_PLUGIN_STATE_LOADING":"Wird geladen","TXT_CODE_PLUGIN_STATE_ACTIVE":"Aktiv","TXT_CODE_PLUGIN_STATE_UNLOADING":"Wird entladen","TXT_CODE_PLUGIN_RESTART_REQUIRED":"Starten Sie den Dienst neu, um die Änderung anzuwenden.","TXT_CODE_PLUGIN_SAVED_PENDING":"Gespeichert; wartet auf Plugin-Abhängigkeiten.","TXT_CODE_PLUGIN_FRONTEND_FAILED":"Browser-Plugin fehlgeschlagen","TXT_CODE_PLUGIN_REFRESH_REQUIRED":"Laden Sie die Seite neu, um die aktualisierte Browser-Laufzeit zu laden."}');
+
+/***/ },
+
+/***/ "./plugins/config/src/i18n/en_US.json"
+(module) {
+
+module.exports = /*#__PURE__*/JSON.parse('{"TXT_CODE_PLUGIN_NODE_DISABLE_CONFIRM":"Also disable the matching plugin on the following nodes? Select the nodes to include.","TXT_CODE_PLUGIN_NODE_DELETE_CONFIRM":"Also remove the matching plugin from the following nodes? Select the nodes to include.","TXT_CODE_PLUGIN_NODE_CHECK_FAILED":"Could not check the plugins on these nodes: {nodes}.","TXT_CODE_PLUGIN_NODE_ACTION_FAILED":"The plugin action did not complete on these nodes: {nodes}","TXT_CODE_PLUGIN_CONFIG":"Plugin Configuration","TXT_CODE_PLUGIN_CANCEL":"Cancel","TXT_CODE_PLUGIN_DELETE":"Remove","TXT_CODE_PLUGIN_DELETE_CONFIRM":"The plugin files and saved configuration will be permanently removed.","TXT_CODE_PLUGIN_DELETE_CONFIRM_TITLE":"Remove {name}?","TXT_CODE_PLUGIN_DELETE_UNAVAILABLE":"Plugins are installed as npm dependencies; remove them with npm.","TXT_CODE_PLUGIN_DELETED":"Plugin removed","TXT_CODE_PLUGIN_SAVE_SETTINGS":"Save settings","TXT_CODE_PLUGIN_SAVE_REMINDER":"Remember to save your settings!","TXT_CODE_PLUGIN_DISABLE":"Disable","TXT_CODE_PLUGIN_DISABLED":"Plugin disabled","TXT_CODE_PLUGIN_DISABLE_CONFIRM":"Everything this plugin provides is removed at once.","TXT_CODE_PLUGIN_DISABLE_CONFIRM_TITLE":"Disable {name}?","TXT_CODE_PLUGIN_ENABLE":"Enable","TXT_CODE_PLUGIN_ENABLED":"Plugin enabled","TXT_CODE_PLUGIN_ESSENTIAL_DISABLE":"The web server cannot be disabled from the panel it serves. Set enabled to false in its plugin.json instead.","TXT_CODE_PLUGIN_IS_DISABLED":"This plugin is disabled. Its pages, routes and API are unavailable until it is enabled again.","TXT_CODE_PLUGIN_LOAD_FAILED":"This plugin failed to load","TXT_CODE_PLUGIN_NODE_LIST_FAILED":"This node\'s plugins could not be listed.","TXT_CODE_PLUGIN_NODE_NOT_FOUND":"That node does not exist.","TXT_CODE_PLUGIN_NODE_OFFLINE":"not connected","TXT_CODE_PLUGIN_NODE_SELECT":"Select a node","TXT_CODE_PLUGIN_NO_CONFIG":"This plugin has no configurable options.","TXT_CODE_PLUGIN_GROUP_UNASSIGNED":"Unassigned","TXT_CODE_PLUGIN_GROUP_ADD":"Add group","TXT_CODE_PLUGIN_GROUP_EDIT":"Edit plugin group","TXT_CODE_PLUGIN_GROUP_RENAME":"Rename group","TXT_CODE_PLUGIN_GROUP_DELETE":"Delete group","TXT_CODE_PLUGIN_GROUP_DELETE_CONFIRM_TITLE":"Delete group {name}?","TXT_CODE_PLUGIN_GROUP_DELETE_CONFIRM":"The group and its plugin assignments will be removed. The plugins themselves will not be deleted.","TXT_CODE_PLUGIN_GROUP_NAME":"Group name","TXT_CODE_PLUGIN_SCOPE_NODE":"Nodes","TXT_CODE_PLUGIN_SCOPE_PANEL":"Panel","TXT_CODE_PLUGIN_SELF_DISABLE":"The plugin manager cannot disable itself. Set enabled to false in its plugin.json instead.","TXT_CODE_PLUGIN_STATE_PENDING":"Waiting for dependencies","TXT_CODE_PLUGIN_STATE_DISABLED":"Disabled","TXT_CODE_PLUGIN_STATE_LOADING":"Loading","TXT_CODE_PLUGIN_STATE_ACTIVE":"Running","TXT_CODE_PLUGIN_STATE_UNLOADING":"Unloading","TXT_CODE_PLUGIN_RESTART_REQUIRED":"Restart the service to apply this change.","TXT_CODE_PLUGIN_SAVED_PENDING":"Saved; waiting for plugin dependencies.","TXT_CODE_PLUGIN_FRONTEND_FAILED":"Browser plugin failed","TXT_CODE_PLUGIN_REFRESH_REQUIRED":"Refresh the page to load the updated browser runtime."}');
+
+/***/ },
+
+/***/ "./plugins/config/src/i18n/es_ES.json"
+(module) {
+
+module.exports = /*#__PURE__*/JSON.parse('{"TXT_CODE_PLUGIN_NODE_DISABLE_CONFIRM":"¿Quieres desactivar también el complemento correspondiente en los siguientes nodos? Selecciona los nodos que quieras incluir.","TXT_CODE_PLUGIN_NODE_DELETE_CONFIRM":"¿Quieres eliminar también el complemento correspondiente de los siguientes nodos? Selecciona los nodos que quieras incluir.","TXT_CODE_PLUGIN_NODE_CHECK_FAILED":"No se pudieron comprobar los complementos de estos nodos: {nodes}.","TXT_CODE_PLUGIN_NODE_ACTION_FAILED":"La operación del complemento no se completó en estos nodos: {nodes}","TXT_CODE_PLUGIN_CONFIG":"Configuracion de plugins","TXT_CODE_PLUGIN_CANCEL":"Cancelar","TXT_CODE_PLUGIN_DELETE":"Eliminar","TXT_CODE_PLUGIN_DELETE_CONFIRM":"Los archivos del complemento y su configuración guardada se eliminarán permanentemente.","TXT_CODE_PLUGIN_DELETE_CONFIRM_TITLE":"¿Eliminar {name}?","TXT_CODE_PLUGIN_DELETE_UNAVAILABLE":"Plugins are installed as npm dependencies; remove them with npm.","TXT_CODE_PLUGIN_DELETED":"Complemento eliminado","TXT_CODE_PLUGIN_SAVE_SETTINGS":"Guardar configuración","TXT_CODE_PLUGIN_SAVE_REMINDER":"¡Recuerda guardar la configuración!","TXT_CODE_PLUGIN_DISABLE":"Desactivar","TXT_CODE_PLUGIN_DISABLED":"Complemento desactivado","TXT_CODE_PLUGIN_DISABLE_CONFIRM":"Todo lo que aporta este complemento se elimina de inmediato.","TXT_CODE_PLUGIN_DISABLE_CONFIRM_TITLE":"¿Desactivar {name}?","TXT_CODE_PLUGIN_ENABLE":"Activar","TXT_CODE_PLUGIN_ENABLED":"Complemento activado","TXT_CODE_PLUGIN_ESSENTIAL_DISABLE":"El servidor web no puede desactivarse desde el panel que él mismo sirve. Establece enabled en false en su plugin.json.","TXT_CODE_PLUGIN_IS_DISABLED":"Este complemento está desactivado. Sus páginas, rutas y API no están disponibles hasta que se vuelva a activar.","TXT_CODE_PLUGIN_LOAD_FAILED":"No se pudo cargar este complemento","TXT_CODE_PLUGIN_NODE_LIST_FAILED":"No se pudieron listar los complementos de este nodo.","TXT_CODE_PLUGIN_NODE_NOT_FOUND":"Ese nodo no existe.","TXT_CODE_PLUGIN_NODE_OFFLINE":"sin conexión","TXT_CODE_PLUGIN_NODE_SELECT":"Seleccionar un nodo","TXT_CODE_PLUGIN_NO_CONFIG":"Este plugin no tiene opciones configurables.","TXT_CODE_PLUGIN_GROUP_UNASSIGNED":"Sin asignar","TXT_CODE_PLUGIN_GROUP_ADD":"Añadir grupo","TXT_CODE_PLUGIN_GROUP_EDIT":"Editar grupo de plugins","TXT_CODE_PLUGIN_GROUP_RENAME":"Cambiar nombre del grupo","TXT_CODE_PLUGIN_GROUP_DELETE":"Eliminar grupo","TXT_CODE_PLUGIN_GROUP_DELETE_CONFIRM_TITLE":"¿Eliminar el grupo {name}?","TXT_CODE_PLUGIN_GROUP_DELETE_CONFIRM":"Se eliminarán el grupo y sus asignaciones de plugins. Los plugins no se eliminarán.","TXT_CODE_PLUGIN_GROUP_NAME":"Nombre del grupo","TXT_CODE_PLUGIN_SCOPE_NODE":"Nodos","TXT_CODE_PLUGIN_SCOPE_PANEL":"Panel","TXT_CODE_PLUGIN_SELF_DISABLE":"El gestor de complementos no puede desactivarse a sí mismo. Establece enabled en false en su plugin.json.","TXT_CODE_PLUGIN_STATE_PENDING":"Esperando dependencias","TXT_CODE_PLUGIN_STATE_DISABLED":"Desactivado","TXT_CODE_PLUGIN_STATE_LOADING":"Cargando","TXT_CODE_PLUGIN_STATE_ACTIVE":"En ejecución","TXT_CODE_PLUGIN_STATE_UNLOADING":"Descargando","TXT_CODE_PLUGIN_RESTART_REQUIRED":"Reinicia el servicio para aplicar el cambio.","TXT_CODE_PLUGIN_SAVED_PENDING":"Guardado; esperando dependencias del complemento.","TXT_CODE_PLUGIN_FRONTEND_FAILED":"Error del complemento del navegador","TXT_CODE_PLUGIN_REFRESH_REQUIRED":"Recarga la página para cargar el entorno actualizado del navegador."}');
+
+/***/ },
+
+/***/ "./plugins/config/src/i18n/fr_FR.json"
+(module) {
+
+module.exports = /*#__PURE__*/JSON.parse('{"TXT_CODE_PLUGIN_NODE_DISABLE_CONFIRM":"Voulez-vous aussi désactiver le plugin correspondant sur les nœuds suivants ? Sélectionnez les nœuds à inclure.","TXT_CODE_PLUGIN_NODE_DELETE_CONFIRM":"Voulez-vous aussi supprimer le plugin correspondant des nœuds suivants ? Sélectionnez les nœuds à inclure.","TXT_CODE_PLUGIN_NODE_CHECK_FAILED":"Impossible de vérifier les plugins sur ces nœuds : {nodes}.","TXT_CODE_PLUGIN_NODE_ACTION_FAILED":"L’opération sur le plugin n’a pas abouti sur ces nœuds : {nodes}","TXT_CODE_PLUGIN_CONFIG":"Configuration des plugins","TXT_CODE_PLUGIN_CANCEL":"Annuler","TXT_CODE_PLUGIN_DELETE":"Supprimer","TXT_CODE_PLUGIN_DELETE_CONFIRM":"Les fichiers du plugin et sa configuration enregistrée seront supprimés définitivement.","TXT_CODE_PLUGIN_DELETE_CONFIRM_TITLE":"Supprimer {name} ?","TXT_CODE_PLUGIN_DELETE_UNAVAILABLE":"Plugins are installed as npm dependencies; remove them with npm.","TXT_CODE_PLUGIN_DELETED":"Plugin supprimé","TXT_CODE_PLUGIN_SAVE_SETTINGS":"Enregistrer la configuration","TXT_CODE_PLUGIN_SAVE_REMINDER":"Pensez à enregistrer la configuration !","TXT_CODE_PLUGIN_DISABLE":"Désactiver","TXT_CODE_PLUGIN_DISABLED":"Extension désactivée","TXT_CODE_PLUGIN_DISABLE_CONFIRM":"Tout ce que cette extension fournit est retiré immédiatement.","TXT_CODE_PLUGIN_DISABLE_CONFIRM_TITLE":"Désactiver {name} ?","TXT_CODE_PLUGIN_ENABLE":"Activer","TXT_CODE_PLUGIN_ENABLED":"Extension activée","TXT_CODE_PLUGIN_ESSENTIAL_DISABLE":"Le serveur web ne peut pas être désactivé depuis le panneau qu il sert lui-même. Définissez plutôt enabled à false dans son plugin.json.","TXT_CODE_PLUGIN_IS_DISABLED":"Cette extension est désactivée. Ses pages, routes et API ne sont pas disponibles avant sa réactivation.","TXT_CODE_PLUGIN_LOAD_FAILED":"Le chargement de cette extension a échoué","TXT_CODE_PLUGIN_NODE_LIST_FAILED":"Impossible de lister les extensions de ce nœud.","TXT_CODE_PLUGIN_NODE_NOT_FOUND":"Ce nœud n existe pas.","TXT_CODE_PLUGIN_NODE_OFFLINE":"non connecté","TXT_CODE_PLUGIN_NODE_SELECT":"Sélectionner un nœud","TXT_CODE_PLUGIN_NO_CONFIG":"Ce plugin ne comporte aucune option configurable.","TXT_CODE_PLUGIN_GROUP_UNASSIGNED":"Non attribués","TXT_CODE_PLUGIN_GROUP_ADD":"Ajouter un groupe","TXT_CODE_PLUGIN_GROUP_EDIT":"Modifier le groupe de plugins","TXT_CODE_PLUGIN_GROUP_RENAME":"Renommer le groupe","TXT_CODE_PLUGIN_GROUP_DELETE":"Supprimer le groupe","TXT_CODE_PLUGIN_GROUP_DELETE_CONFIRM_TITLE":"Supprimer le groupe {name} ?","TXT_CODE_PLUGIN_GROUP_DELETE_CONFIRM":"Le groupe et ses affectations de plugins seront supprimés. Les plugins eux-mêmes ne seront pas supprimés.","TXT_CODE_PLUGIN_GROUP_NAME":"Nom du groupe","TXT_CODE_PLUGIN_SCOPE_NODE":"Nœuds","TXT_CODE_PLUGIN_SCOPE_PANEL":"Panneau","TXT_CODE_PLUGIN_SELF_DISABLE":"Le gestionnaire d extensions ne peut pas se désactiver lui-même. Définissez plutôt enabled à false dans son plugin.json.","TXT_CODE_PLUGIN_STATE_PENDING":"En attente des dépendances","TXT_CODE_PLUGIN_STATE_DISABLED":"Désactivé","TXT_CODE_PLUGIN_STATE_LOADING":"Chargement","TXT_CODE_PLUGIN_STATE_ACTIVE":"Actif","TXT_CODE_PLUGIN_STATE_UNLOADING":"Déchargement","TXT_CODE_PLUGIN_RESTART_REQUIRED":"Redémarrez le service pour appliquer cette modification.","TXT_CODE_PLUGIN_SAVED_PENDING":"Enregistré ; en attente des dépendances du plugin.","TXT_CODE_PLUGIN_FRONTEND_FAILED":"Échec du plugin du navigateur","TXT_CODE_PLUGIN_REFRESH_REQUIRED":"Actualisez la page pour charger le nouvel environnement du navigateur."}');
+
+/***/ },
+
+/***/ "./plugins/config/src/i18n/ja_JP.json"
+(module) {
+
+module.exports = /*#__PURE__*/JSON.parse('{"TXT_CODE_PLUGIN_NODE_DISABLE_CONFIRM":"以下のノードにある同じプラグインも無効にしますか？対象のノードを選択してください。","TXT_CODE_PLUGIN_NODE_DELETE_CONFIRM":"以下のノードにある同じプラグインも削除しますか？対象のノードを選択してください。","TXT_CODE_PLUGIN_NODE_CHECK_FAILED":"以下のノードのプラグインを確認できませんでした：{nodes}。","TXT_CODE_PLUGIN_NODE_ACTION_FAILED":"以下のノードでプラグインの操作が完了しませんでした：{nodes}","TXT_CODE_PLUGIN_CONFIG":"プラグイン設定","TXT_CODE_PLUGIN_CANCEL":"キャンセル","TXT_CODE_PLUGIN_DELETE":"削除","TXT_CODE_PLUGIN_DELETE_CONFIRM":"プラグインファイルと保存済みの設定が完全に削除されます。","TXT_CODE_PLUGIN_DELETE_CONFIRM_TITLE":"{name} を削除しますか？","TXT_CODE_PLUGIN_DELETE_UNAVAILABLE":"Plugins are installed as npm dependencies; remove them with npm.","TXT_CODE_PLUGIN_DELETED":"プラグインを削除しました","TXT_CODE_PLUGIN_SAVE_SETTINGS":"設定を保存","TXT_CODE_PLUGIN_SAVE_REMINDER":"設定の保存をお忘れなく！","TXT_CODE_PLUGIN_DISABLE":"無効化","TXT_CODE_PLUGIN_DISABLED":"プラグインを無効にしました","TXT_CODE_PLUGIN_DISABLE_CONFIRM":"このプラグインが提供するすべての要素が即座に削除されます。","TXT_CODE_PLUGIN_DISABLE_CONFIRM_TITLE":"{name} を無効にしますか？","TXT_CODE_PLUGIN_ENABLE":"有効化","TXT_CODE_PLUGIN_ENABLED":"プラグインを有効にしました","TXT_CODE_PLUGIN_ESSENTIAL_DISABLE":"Web サーバーは、それ自身が配信しているパネルからは無効にできません。plugin.json で enabled を false に設定してください。","TXT_CODE_PLUGIN_IS_DISABLED":"このプラグインは無効です。再度有効にするまで、ページ・ルート・API は利用できません。","TXT_CODE_PLUGIN_LOAD_FAILED":"このプラグインの読み込みに失敗しました","TXT_CODE_PLUGIN_NODE_LIST_FAILED":"このノードのプラグイン一覧を取得できませんでした。","TXT_CODE_PLUGIN_NODE_NOT_FOUND":"そのノードは存在しません。","TXT_CODE_PLUGIN_NODE_OFFLINE":"未接続","TXT_CODE_PLUGIN_NODE_SELECT":"ノードを選択","TXT_CODE_PLUGIN_NO_CONFIG":"このプラグインには設定可能な項目がありません。","TXT_CODE_PLUGIN_GROUP_UNASSIGNED":"未分類","TXT_CODE_PLUGIN_GROUP_ADD":"グループを追加","TXT_CODE_PLUGIN_GROUP_EDIT":"プラグイン グループを編集","TXT_CODE_PLUGIN_GROUP_RENAME":"グループ名を変更","TXT_CODE_PLUGIN_GROUP_DELETE":"グループを削除","TXT_CODE_PLUGIN_GROUP_DELETE_CONFIRM_TITLE":"グループ「{name}」を削除しますか？","TXT_CODE_PLUGIN_GROUP_DELETE_CONFIRM":"グループとプラグインの割り当てを削除します。プラグイン自体は削除されません。","TXT_CODE_PLUGIN_GROUP_NAME":"グループ名","TXT_CODE_PLUGIN_SCOPE_NODE":"ノード","TXT_CODE_PLUGIN_SCOPE_PANEL":"パネル","TXT_CODE_PLUGIN_SELF_DISABLE":"プラグイン管理自身は無効にできません。plugin.json で enabled を false に設定してください。","TXT_CODE_PLUGIN_STATE_PENDING":"依存関係を待機中","TXT_CODE_PLUGIN_STATE_DISABLED":"無効","TXT_CODE_PLUGIN_STATE_LOADING":"読み込み中","TXT_CODE_PLUGIN_STATE_ACTIVE":"実行中","TXT_CODE_PLUGIN_STATE_UNLOADING":"アンロード中","TXT_CODE_PLUGIN_RESTART_REQUIRED":"変更を適用するにはサービスを再起動してください。","TXT_CODE_PLUGIN_SAVED_PENDING":"保存しました。プラグインの依存関係を待機しています。","TXT_CODE_PLUGIN_FRONTEND_FAILED":"ブラウザープラグインの読み込みに失敗しました","TXT_CODE_PLUGIN_REFRESH_REQUIRED":"更新されたブラウザーランタイムを読み込むにはページを再読み込みしてください。"}');
+
+/***/ },
+
+/***/ "./plugins/config/src/i18n/ko_KR.json"
+(module) {
+
+module.exports = /*#__PURE__*/JSON.parse('{"TXT_CODE_PLUGIN_NODE_DISABLE_CONFIRM":"다음 노드의 동일한 플러그인도 비활성화할까요? 함께 처리할 노드를 선택하세요.","TXT_CODE_PLUGIN_NODE_DELETE_CONFIRM":"다음 노드의 동일한 플러그인도 삭제할까요? 함께 처리할 노드를 선택하세요.","TXT_CODE_PLUGIN_NODE_CHECK_FAILED":"다음 노드의 플러그인을 확인할 수 없습니다: {nodes}.","TXT_CODE_PLUGIN_NODE_ACTION_FAILED":"다음 노드에서 플러그인 작업이 완료되지 않았습니다: {nodes}","TXT_CODE_PLUGIN_CONFIG":"플러그인 설정","TXT_CODE_PLUGIN_CANCEL":"취소","TXT_CODE_PLUGIN_DELETE":"삭제","TXT_CODE_PLUGIN_DELETE_CONFIRM":"플러그인 파일과 저장된 설정이 영구적으로 삭제됩니다.","TXT_CODE_PLUGIN_DELETE_CONFIRM_TITLE":"{name} 플러그인을 삭제할까요?","TXT_CODE_PLUGIN_DELETE_UNAVAILABLE":"Plugins are installed as npm dependencies; remove them with npm.","TXT_CODE_PLUGIN_DELETED":"플러그인을 삭제했습니다","TXT_CODE_PLUGIN_SAVE_SETTINGS":"설정 저장","TXT_CODE_PLUGIN_SAVE_REMINDER":"설정을 저장하는 것을 잊지 마세요!","TXT_CODE_PLUGIN_DISABLE":"비활성화","TXT_CODE_PLUGIN_DISABLED":"플러그인을 비활성화했습니다","TXT_CODE_PLUGIN_DISABLE_CONFIRM":"이 플러그인이 제공하는 모든 구성 요소가 즉시 제거됩니다.","TXT_CODE_PLUGIN_DISABLE_CONFIRM_TITLE":"{name}을(를) 비활성화할까요?","TXT_CODE_PLUGIN_ENABLE":"활성화","TXT_CODE_PLUGIN_ENABLED":"플러그인을 활성화했습니다","TXT_CODE_PLUGIN_ESSENTIAL_DISABLE":"웹 서버는 자신이 제공하는 패널에서 비활성화할 수 없습니다. plugin.json에서 enabled 를 false 로 설정하세요.","TXT_CODE_PLUGIN_IS_DISABLED":"이 플러그인은 비활성화되어 있습니다. 다시 활성화할 때까지 페이지, 경로, API를 사용할 수 없습니다.","TXT_CODE_PLUGIN_LOAD_FAILED":"이 플러그인을 불러오지 못했습니다","TXT_CODE_PLUGIN_NODE_LIST_FAILED":"이 노드의 플러그인 목록을 가져올 수 없습니다.","TXT_CODE_PLUGIN_NODE_NOT_FOUND":"해당 노드가 존재하지 않습니다.","TXT_CODE_PLUGIN_NODE_OFFLINE":"연결되지 않음","TXT_CODE_PLUGIN_NODE_SELECT":"노드 선택","TXT_CODE_PLUGIN_NO_CONFIG":"이 플러그인에는 구성 가능한 옵션이 없습니다.","TXT_CODE_PLUGIN_GROUP_UNASSIGNED":"미분류","TXT_CODE_PLUGIN_GROUP_ADD":"그룹 추가","TXT_CODE_PLUGIN_GROUP_EDIT":"플러그인 그룹 편집","TXT_CODE_PLUGIN_GROUP_RENAME":"그룹 이름 변경","TXT_CODE_PLUGIN_GROUP_DELETE":"그룹 삭제","TXT_CODE_PLUGIN_GROUP_DELETE_CONFIRM_TITLE":"{name} 그룹을 삭제하시겠습니까?","TXT_CODE_PLUGIN_GROUP_DELETE_CONFIRM":"그룹과 플러그인 할당이 삭제됩니다. 플러그인 자체는 삭제되지 않습니다.","TXT_CODE_PLUGIN_GROUP_NAME":"그룹 이름","TXT_CODE_PLUGIN_SCOPE_NODE":"노드","TXT_CODE_PLUGIN_SCOPE_PANEL":"패널","TXT_CODE_PLUGIN_SELF_DISABLE":"플러그인 관리자는 자신을 비활성화할 수 없습니다. plugin.json에서 enabled 를 false 로 설정하세요.","TXT_CODE_PLUGIN_STATE_PENDING":"종속성 대기 중","TXT_CODE_PLUGIN_STATE_DISABLED":"비활성","TXT_CODE_PLUGIN_STATE_LOADING":"로드 중","TXT_CODE_PLUGIN_STATE_ACTIVE":"실행 중","TXT_CODE_PLUGIN_STATE_UNLOADING":"언로드 중","TXT_CODE_PLUGIN_RESTART_REQUIRED":"변경 사항을 적용하려면 서비스를 다시 시작하세요.","TXT_CODE_PLUGIN_SAVED_PENDING":"저장되었습니다. 플러그인 종속성을 기다리는 중입니다.","TXT_CODE_PLUGIN_FRONTEND_FAILED":"브라우저 플러그인 로드 실패","TXT_CODE_PLUGIN_REFRESH_REQUIRED":"업데이트된 브라우저 런타임을 로드하려면 페이지를 새로 고치세요."}');
+
+/***/ },
+
+/***/ "./plugins/config/src/i18n/pt_BR.json"
+(module) {
+
+module.exports = /*#__PURE__*/JSON.parse('{"TXT_CODE_PLUGIN_NODE_DISABLE_CONFIRM":"Desativar também o plugin correspondente nos seguintes nós? Selecione os nós que deseja incluir.","TXT_CODE_PLUGIN_NODE_DELETE_CONFIRM":"Remover também o plugin correspondente dos seguintes nós? Selecione os nós que deseja incluir.","TXT_CODE_PLUGIN_NODE_CHECK_FAILED":"Não foi possível verificar os plugins nestes nós: {nodes}.","TXT_CODE_PLUGIN_NODE_ACTION_FAILED":"A operação do plugin não foi concluída nestes nós: {nodes}","TXT_CODE_PLUGIN_CONFIG":"Configuracao de plugins","TXT_CODE_PLUGIN_CANCEL":"Cancelar","TXT_CODE_PLUGIN_DELETE":"Remover","TXT_CODE_PLUGIN_DELETE_CONFIRM":"Os arquivos do plugin e as configurações salvas serão removidos permanentemente.","TXT_CODE_PLUGIN_DELETE_CONFIRM_TITLE":"Remover {name}?","TXT_CODE_PLUGIN_DELETE_UNAVAILABLE":"Plugins are installed as npm dependencies; remove them with npm.","TXT_CODE_PLUGIN_DELETED":"Plugin removido","TXT_CODE_PLUGIN_SAVE_SETTINGS":"Salvar configurações","TXT_CODE_PLUGIN_SAVE_REMINDER":"Lembre-se de salvar as configurações!","TXT_CODE_PLUGIN_DISABLE":"Desativar","TXT_CODE_PLUGIN_DISABLED":"Plugin desativado","TXT_CODE_PLUGIN_DISABLE_CONFIRM":"Tudo o que este plugin fornece é removido de imediato.","TXT_CODE_PLUGIN_DISABLE_CONFIRM_TITLE":"Desativar {name}?","TXT_CODE_PLUGIN_ENABLE":"Ativar","TXT_CODE_PLUGIN_ENABLED":"Plugin ativado","TXT_CODE_PLUGIN_ESSENTIAL_DISABLE":"O servidor web não pode ser desativado pelo painel que ele mesmo serve. Defina enabled como false no plugin.json dele.","TXT_CODE_PLUGIN_IS_DISABLED":"Este plugin está desativado. Suas páginas, rotas e API ficam indisponíveis até ser ativado novamente.","TXT_CODE_PLUGIN_LOAD_FAILED":"Falha ao carregar este plugin","TXT_CODE_PLUGIN_NODE_LIST_FAILED":"Não foi possível listar os plugins deste nó.","TXT_CODE_PLUGIN_NODE_NOT_FOUND":"Esse nó não existe.","TXT_CODE_PLUGIN_NODE_OFFLINE":"não conectado","TXT_CODE_PLUGIN_NODE_SELECT":"Selecionar um nó","TXT_CODE_PLUGIN_NO_CONFIG":"Este plugin nao possui opcoes configuraveis.","TXT_CODE_PLUGIN_GROUP_UNASSIGNED":"Não atribuídos","TXT_CODE_PLUGIN_GROUP_ADD":"Adicionar grupo","TXT_CODE_PLUGIN_GROUP_EDIT":"Editar grupo de plugins","TXT_CODE_PLUGIN_GROUP_RENAME":"Renomear grupo","TXT_CODE_PLUGIN_GROUP_DELETE":"Excluir grupo","TXT_CODE_PLUGIN_GROUP_DELETE_CONFIRM_TITLE":"Excluir o grupo {name}?","TXT_CODE_PLUGIN_GROUP_DELETE_CONFIRM":"O grupo e suas associações de plugins serão removidos. Os plugins não serão excluídos.","TXT_CODE_PLUGIN_GROUP_NAME":"Nome do grupo","TXT_CODE_PLUGIN_SCOPE_NODE":"Nós","TXT_CODE_PLUGIN_SCOPE_PANEL":"Painel","TXT_CODE_PLUGIN_SELF_DISABLE":"O gerenciador de plugins não pode desativar a si mesmo. Defina enabled como false no plugin.json dele.","TXT_CODE_PLUGIN_STATE_PENDING":"Aguardando dependências","TXT_CODE_PLUGIN_STATE_DISABLED":"Desativado","TXT_CODE_PLUGIN_STATE_LOADING":"Carregando","TXT_CODE_PLUGIN_STATE_ACTIVE":"Em execução","TXT_CODE_PLUGIN_STATE_UNLOADING":"Descarregando","TXT_CODE_PLUGIN_RESTART_REQUIRED":"Reinicie o serviço para aplicar a alteração.","TXT_CODE_PLUGIN_SAVED_PENDING":"Salvo; aguardando dependências do plugin.","TXT_CODE_PLUGIN_FRONTEND_FAILED":"Falha no plugin do navegador","TXT_CODE_PLUGIN_REFRESH_REQUIRED":"Atualize a página para carregar o novo ambiente do navegador."}');
+
+/***/ },
+
+/***/ "./plugins/config/src/i18n/ru_RU.json"
+(module) {
+
+module.exports = /*#__PURE__*/JSON.parse('{"TXT_CODE_PLUGIN_NODE_DISABLE_CONFIRM":"Отключить соответствующий плагин также на следующих узлах? Выберите нужные узлы.","TXT_CODE_PLUGIN_NODE_DELETE_CONFIRM":"Удалить соответствующий плагин также со следующих узлов? Выберите нужные узлы.","TXT_CODE_PLUGIN_NODE_CHECK_FAILED":"Не удалось проверить плагины на этих узлах: {nodes}.","TXT_CODE_PLUGIN_NODE_ACTION_FAILED":"Операция с плагином не завершена на этих узлах: {nodes}","TXT_CODE_PLUGIN_CONFIG":"Настройка плагинов","TXT_CODE_PLUGIN_CANCEL":"Отмена","TXT_CODE_PLUGIN_DELETE":"Удалить","TXT_CODE_PLUGIN_DELETE_CONFIRM":"Файлы плагина и сохранённые настройки будут удалены без возможности восстановления.","TXT_CODE_PLUGIN_DELETE_CONFIRM_TITLE":"Удалить {name}?","TXT_CODE_PLUGIN_DELETE_UNAVAILABLE":"Plugins are installed as npm dependencies; remove them with npm.","TXT_CODE_PLUGIN_DELETED":"Плагин удалён","TXT_CODE_PLUGIN_SAVE_SETTINGS":"Сохранить настройки","TXT_CODE_PLUGIN_SAVE_REMINDER":"Не забудьте сохранить настройки!","TXT_CODE_PLUGIN_DISABLE":"Отключить","TXT_CODE_PLUGIN_DISABLED":"Плагин отключён","TXT_CODE_PLUGIN_DISABLE_CONFIRM":"Всё, что предоставляет этот плагин, будет удалено сразу.","TXT_CODE_PLUGIN_DISABLE_CONFIRM_TITLE":"Отключить {name}?","TXT_CODE_PLUGIN_ENABLE":"Включить","TXT_CODE_PLUGIN_ENABLED":"Плагин включён","TXT_CODE_PLUGIN_ESSENTIAL_DISABLE":"Веб-сервер нельзя отключить из панели, которую он сам и обслуживает. Укажите enabled: false в его plugin.json.","TXT_CODE_PLUGIN_IS_DISABLED":"Этот плагин отключён. Его страницы, маршруты и API недоступны, пока он не будет включён снова.","TXT_CODE_PLUGIN_LOAD_FAILED":"Не удалось загрузить этот плагин","TXT_CODE_PLUGIN_NODE_LIST_FAILED":"Не удалось получить список плагинов этого узла.","TXT_CODE_PLUGIN_NODE_NOT_FOUND":"Такого узла не существует.","TXT_CODE_PLUGIN_NODE_OFFLINE":"не подключён","TXT_CODE_PLUGIN_NODE_SELECT":"Выберите узел","TXT_CODE_PLUGIN_NO_CONFIG":"У этого плагина нет настраиваемых параметров.","TXT_CODE_PLUGIN_GROUP_UNASSIGNED":"Без группы","TXT_CODE_PLUGIN_GROUP_ADD":"Добавить группу","TXT_CODE_PLUGIN_GROUP_EDIT":"Редактировать группу плагинов","TXT_CODE_PLUGIN_GROUP_RENAME":"Переименовать группу","TXT_CODE_PLUGIN_GROUP_DELETE":"Удалить группу","TXT_CODE_PLUGIN_GROUP_DELETE_CONFIRM_TITLE":"Удалить группу {name}?","TXT_CODE_PLUGIN_GROUP_DELETE_CONFIRM":"Группа и привязанные к ней плагины будут удалены из списка. Сами плагины удалены не будут.","TXT_CODE_PLUGIN_GROUP_NAME":"Название группы","TXT_CODE_PLUGIN_SCOPE_NODE":"Узлы","TXT_CODE_PLUGIN_SCOPE_PANEL":"Панель","TXT_CODE_PLUGIN_SELF_DISABLE":"Менеджер плагинов не может отключить сам себя. Укажите enabled: false в его plugin.json.","TXT_CODE_PLUGIN_STATE_PENDING":"Ожидание зависимостей","TXT_CODE_PLUGIN_STATE_DISABLED":"Отключён","TXT_CODE_PLUGIN_STATE_LOADING":"Загрузка","TXT_CODE_PLUGIN_STATE_ACTIVE":"Работает","TXT_CODE_PLUGIN_STATE_UNLOADING":"Выгрузка","TXT_CODE_PLUGIN_RESTART_REQUIRED":"Перезапустите службу, чтобы применить изменение.","TXT_CODE_PLUGIN_SAVED_PENDING":"Сохранено; ожидание зависимостей плагина.","TXT_CODE_PLUGIN_FRONTEND_FAILED":"Ошибка плагина браузера","TXT_CODE_PLUGIN_REFRESH_REQUIRED":"Обновите страницу для загрузки новой среды браузера."}');
+
+/***/ },
+
+/***/ "./plugins/config/src/i18n/th_TH.json"
+(module) {
+
+module.exports = /*#__PURE__*/JSON.parse('{"TXT_CODE_PLUGIN_NODE_DISABLE_CONFIRM":"ต้องการปิดใช้งานปลั๊กอินเดียวกันบนโหนดต่อไปนี้ด้วยหรือไม่? เลือกโหนดที่ต้องการดำเนินการด้วย","TXT_CODE_PLUGIN_NODE_DELETE_CONFIRM":"ต้องการลบปลั๊กอินเดียวกันออกจากโหนดต่อไปนี้ด้วยหรือไม่? เลือกโหนดที่ต้องการดำเนินการด้วย","TXT_CODE_PLUGIN_NODE_CHECK_FAILED":"ไม่สามารถตรวจสอบปลั๊กอินบนโหนดเหล่านี้ได้: {nodes}","TXT_CODE_PLUGIN_NODE_ACTION_FAILED":"การดำเนินการกับปลั๊กอินบนโหนดเหล่านี้ไม่สำเร็จ: {nodes}","TXT_CODE_PLUGIN_CONFIG":"การกำหนดค่าปลั๊กอิน","TXT_CODE_PLUGIN_CANCEL":"ยกเลิก","TXT_CODE_PLUGIN_DELETE":"ลบ","TXT_CODE_PLUGIN_DELETE_CONFIRM":"ไฟล์ปลั๊กอินและการตั้งค่าที่บันทึกไว้จะถูกลบอย่างถาวร","TXT_CODE_PLUGIN_DELETE_CONFIRM_TITLE":"ลบ {name} หรือไม่?","TXT_CODE_PLUGIN_DELETE_UNAVAILABLE":"Plugins are installed as npm dependencies; remove them with npm.","TXT_CODE_PLUGIN_DELETED":"ลบปลั๊กอินแล้ว","TXT_CODE_PLUGIN_SAVE_SETTINGS":"บันทึกการตั้งค่า","TXT_CODE_PLUGIN_SAVE_REMINDER":"อย่าลืมบันทึกการตั้งค่า!","TXT_CODE_PLUGIN_DISABLE":"ปิดใช้งาน","TXT_CODE_PLUGIN_DISABLED":"ปิดใช้งานปลั๊กอินแล้ว","TXT_CODE_PLUGIN_DISABLE_CONFIRM":"ทุกอย่างที่ปลั๊กอินนี้ให้มาจะถูกลบออกทันที","TXT_CODE_PLUGIN_DISABLE_CONFIRM_TITLE":"ปิดใช้งาน {name} หรือไม่?","TXT_CODE_PLUGIN_ENABLE":"เปิดใช้งาน","TXT_CODE_PLUGIN_ENABLED":"เปิดใช้งานปลั๊กอินแล้ว","TXT_CODE_PLUGIN_ESSENTIAL_DISABLE":"ไม่สามารถปิดใช้งานเว็บเซิร์ฟเวอร์จากแผงควบคุมที่ตัวมันเองให้บริการอยู่ กรุณาตั้ง enabled เป็น false ใน plugin.json ของมันแทน","TXT_CODE_PLUGIN_IS_DISABLED":"ปลั๊กอินนี้ถูกปิดใช้งาน หน้า เส้นทาง และ API จะใช้ไม่ได้จนกว่าจะเปิดใช้งานอีกครั้ง","TXT_CODE_PLUGIN_LOAD_FAILED":"โหลดปลั๊กอินนี้ไม่สำเร็จ","TXT_CODE_PLUGIN_NODE_LIST_FAILED":"ไม่สามารถแสดงรายการปลั๊กอินของโหนดนี้ได้","TXT_CODE_PLUGIN_NODE_NOT_FOUND":"ไม่มีโหนดนี้","TXT_CODE_PLUGIN_NODE_OFFLINE":"ไม่ได้เชื่อมต่อ","TXT_CODE_PLUGIN_NODE_SELECT":"เลือกโหนด","TXT_CODE_PLUGIN_NO_CONFIG":"ปลั๊กอินนี้ไม่มีตัวเลือกที่กำหนดค่าได้","TXT_CODE_PLUGIN_GROUP_UNASSIGNED":"ยังไม่ได้จัดกลุ่ม","TXT_CODE_PLUGIN_GROUP_ADD":"เพิ่มกลุ่ม","TXT_CODE_PLUGIN_GROUP_EDIT":"แก้ไขกลุ่มปลั๊กอิน","TXT_CODE_PLUGIN_GROUP_RENAME":"เปลี่ยนชื่อกลุ่ม","TXT_CODE_PLUGIN_GROUP_DELETE":"ลบกลุ่ม","TXT_CODE_PLUGIN_GROUP_DELETE_CONFIRM_TITLE":"ลบกลุ่ม {name} หรือไม่","TXT_CODE_PLUGIN_GROUP_DELETE_CONFIRM":"กลุ่มและการกำหนดปลั๊กอินจะถูกลบ ปลั๊กอินจะไม่ถูกลบ","TXT_CODE_PLUGIN_GROUP_NAME":"ชื่อกลุ่ม","TXT_CODE_PLUGIN_SCOPE_NODE":"โหนด","TXT_CODE_PLUGIN_SCOPE_PANEL":"แผงควบคุม","TXT_CODE_PLUGIN_SELF_DISABLE":"ตัวจัดการปลั๊กอินปิดใช้งานตัวเองไม่ได้ กรุณาตั้ง enabled เป็น false ใน plugin.json ของมันแทน","TXT_CODE_PLUGIN_STATE_PENDING":"กำลังรอส่วนที่ต้องพึ่งพา","TXT_CODE_PLUGIN_STATE_DISABLED":"ปิดใช้งาน","TXT_CODE_PLUGIN_STATE_LOADING":"กำลังโหลด","TXT_CODE_PLUGIN_STATE_ACTIVE":"กำลังทำงาน","TXT_CODE_PLUGIN_STATE_UNLOADING":"กำลังยกเลิกการโหลด","TXT_CODE_PLUGIN_RESTART_REQUIRED":"รีสตาร์ทบริการเพื่อใช้การเปลี่ยนแปลงนี้","TXT_CODE_PLUGIN_SAVED_PENDING":"บันทึกแล้ว กำลังรอส่วนที่ปลั๊กอินต้องพึ่งพา","TXT_CODE_PLUGIN_FRONTEND_FAILED":"ปลั๊กอินเบราว์เซอร์ล้มเหลว","TXT_CODE_PLUGIN_REFRESH_REQUIRED":"รีเฟรชหน้าเพื่อโหลดรันไทม์เบราว์เซอร์ที่อัปเดต"}');
+
+/***/ },
+
+/***/ "./plugins/config/src/i18n/tr_TR.json"
+(module) {
+
+module.exports = /*#__PURE__*/JSON.parse('{"TXT_CODE_PLUGIN_NODE_DISABLE_CONFIRM":"Aşağıdaki düğümlerdeki aynı eklenti de devre dışı bırakılsın mı? Dahil edilecek düğümleri seçin.","TXT_CODE_PLUGIN_NODE_DELETE_CONFIRM":"Aşağıdaki düğümlerdeki aynı eklenti de kaldırılsın mı? Dahil edilecek düğümleri seçin.","TXT_CODE_PLUGIN_NODE_CHECK_FAILED":"Bu düğümlerdeki eklentiler kontrol edilemedi: {nodes}.","TXT_CODE_PLUGIN_NODE_ACTION_FAILED":"Bu düğümlerde eklenti işlemi tamamlanamadı: {nodes}","TXT_CODE_PLUGIN_CONFIG":"Eklenti Yapilandirmasi","TXT_CODE_PLUGIN_CANCEL":"Iptal","TXT_CODE_PLUGIN_DELETE":"Kaldır","TXT_CODE_PLUGIN_DELETE_CONFIRM":"Eklenti dosyaları ve kaydedilmiş yapılandırması kalıcı olarak kaldırılacak.","TXT_CODE_PLUGIN_DELETE_CONFIRM_TITLE":"{name} kaldırılsın mı?","TXT_CODE_PLUGIN_DELETE_UNAVAILABLE":"Plugins are installed as npm dependencies; remove them with npm.","TXT_CODE_PLUGIN_DELETED":"Eklenti kaldırıldı","TXT_CODE_PLUGIN_SAVE_SETTINGS":"Ayarları kaydet","TXT_CODE_PLUGIN_SAVE_REMINDER":"Ayarları kaydetmeyi unutmayın!","TXT_CODE_PLUGIN_DISABLE":"Devre dışı bırak","TXT_CODE_PLUGIN_DISABLED":"Eklenti devre dışı bırakıldı","TXT_CODE_PLUGIN_DISABLE_CONFIRM":"Bu eklentinin sağladığı her şey hemen kaldırılır.","TXT_CODE_PLUGIN_DISABLE_CONFIRM_TITLE":"{name} devre dışı bırakılsın mı?","TXT_CODE_PLUGIN_ENABLE":"Etkinleştir","TXT_CODE_PLUGIN_ENABLED":"Eklenti etkinleştirildi","TXT_CODE_PLUGIN_ESSENTIAL_DISABLE":"Web sunucusu, kendisinin sunduğu panel üzerinden devre dışı bırakılamaz. Bunun yerine plugin.json dosyasında enabled değerini false yapın.","TXT_CODE_PLUGIN_IS_DISABLED":"Bu eklenti devre dışı. Yeniden etkinleştirilene kadar sayfaları, yolları ve API si kullanılamaz.","TXT_CODE_PLUGIN_LOAD_FAILED":"Bu eklenti yüklenemedi","TXT_CODE_PLUGIN_NODE_LIST_FAILED":"Bu düğümün eklentileri listelenemedi.","TXT_CODE_PLUGIN_NODE_NOT_FOUND":"Böyle bir düğüm yok.","TXT_CODE_PLUGIN_NODE_OFFLINE":"bağlı değil","TXT_CODE_PLUGIN_NODE_SELECT":"Bir düğüm seçin","TXT_CODE_PLUGIN_NO_CONFIG":"Bu eklentinin yapilandirilabilir secenegi yok.","TXT_CODE_PLUGIN_GROUP_UNASSIGNED":"Atanmamış","TXT_CODE_PLUGIN_GROUP_ADD":"Grup ekle","TXT_CODE_PLUGIN_GROUP_EDIT":"Eklenti grubunu düzenle","TXT_CODE_PLUGIN_GROUP_RENAME":"Grubu yeniden adlandır","TXT_CODE_PLUGIN_GROUP_DELETE":"Grubu sil","TXT_CODE_PLUGIN_GROUP_DELETE_CONFIRM_TITLE":"{name} grubu silinsin mi?","TXT_CODE_PLUGIN_GROUP_DELETE_CONFIRM":"Grup ve eklenti atamaları kaldırılacak. Eklentilerin kendisi silinmeyecek.","TXT_CODE_PLUGIN_GROUP_NAME":"Grup adı","TXT_CODE_PLUGIN_SCOPE_NODE":"Düğümler","TXT_CODE_PLUGIN_SCOPE_PANEL":"Panel","TXT_CODE_PLUGIN_SELF_DISABLE":"Eklenti yöneticisi kendisini devre dışı bırakamaz. Bunun yerine plugin.json dosyasında enabled değerini false yapın.","TXT_CODE_PLUGIN_STATE_PENDING":"Bağımlılıklar bekleniyor","TXT_CODE_PLUGIN_STATE_DISABLED":"Devre dışı","TXT_CODE_PLUGIN_STATE_LOADING":"Yükleniyor","TXT_CODE_PLUGIN_STATE_ACTIVE":"Çalışıyor","TXT_CODE_PLUGIN_STATE_UNLOADING":"Kaldırılıyor","TXT_CODE_PLUGIN_RESTART_REQUIRED":"Değişikliği uygulamak için hizmeti yeniden başlatın.","TXT_CODE_PLUGIN_SAVED_PENDING":"Kaydedildi; eklenti bağımlılıkları bekleniyor.","TXT_CODE_PLUGIN_FRONTEND_FAILED":"Tarayıcı eklentisi başarısız oldu","TXT_CODE_PLUGIN_REFRESH_REQUIRED":"Güncellenen tarayıcı çalışma zamanını yüklemek için sayfayı yenileyin."}');
+
+/***/ },
+
+/***/ "./plugins/config/src/i18n/zh_CN.json"
+(module) {
+
+module.exports = /*#__PURE__*/JSON.parse('{"TXT_CODE_PLUGIN_NODE_DISABLE_CONFIRM":"是否同时禁用以下节点上的对应插件？请勾选需要同步操作的节点。","TXT_CODE_PLUGIN_NODE_DELETE_CONFIRM":"是否同时删除以下节点上的对应插件？请勾选需要同步操作的节点。","TXT_CODE_PLUGIN_NODE_CHECK_FAILED":"无法检查以下节点的插件：{nodes}。","TXT_CODE_PLUGIN_NODE_ACTION_FAILED":"以下节点上的插件操作未完成：{nodes}","TXT_CODE_PLUGIN_CONFIG":"插件配置","TXT_CODE_PLUGIN_CANCEL":"取消","TXT_CODE_PLUGIN_DELETE":"删除插件","TXT_CODE_PLUGIN_DELETE_CONFIRM":"插件文件和已保存的配置将被永久删除。","TXT_CODE_PLUGIN_DELETE_CONFIRM_TITLE":"确定删除 {name}？","TXT_CODE_PLUGIN_DELETE_UNAVAILABLE":"插件以 npm 依赖形式安装，请使用 npm 卸载。","TXT_CODE_PLUGIN_DELETED":"插件已删除","TXT_CODE_PLUGIN_SAVE_SETTINGS":"保存配置","TXT_CODE_PLUGIN_SAVE_REMINDER":"记得保存配置！","TXT_CODE_PLUGIN_DISABLE":"禁用","TXT_CODE_PLUGIN_DISABLED":"插件已禁用","TXT_CODE_PLUGIN_DISABLE_CONFIRM":"该插件提供的所有组件都会被立即移除。","TXT_CODE_PLUGIN_DISABLE_CONFIRM_TITLE":"确定禁用 {name}？","TXT_CODE_PLUGIN_ENABLE":"启用","TXT_CODE_PLUGIN_ENABLED":"插件已启用","TXT_CODE_PLUGIN_ESSENTIAL_DISABLE":"Web 服务器无法从它自己提供的页面上禁用，请改为在其 plugin.json 中把 enabled 设为 false。","TXT_CODE_PLUGIN_IS_DISABLED":"此插件已禁用，重新启用前其页面、路由与接口均不可用。","TXT_CODE_PLUGIN_LOAD_FAILED":"此插件加载失败","TXT_CODE_PLUGIN_NODE_LIST_FAILED":"无法读取该节点的插件列表。","TXT_CODE_PLUGIN_NODE_NOT_FOUND":"该节点不存在。","TXT_CODE_PLUGIN_NODE_OFFLINE":"未连接","TXT_CODE_PLUGIN_NODE_SELECT":"选择节点","TXT_CODE_PLUGIN_NO_CONFIG":"此插件没有可配置项","TXT_CODE_PLUGIN_GROUP_UNASSIGNED":"未分组","TXT_CODE_PLUGIN_GROUP_ADD":"添加分组","TXT_CODE_PLUGIN_GROUP_EDIT":"编辑插件分组","TXT_CODE_PLUGIN_GROUP_RENAME":"重命名分组","TXT_CODE_PLUGIN_GROUP_DELETE":"删除分组","TXT_CODE_PLUGIN_GROUP_DELETE_CONFIRM_TITLE":"删除分组“{name}”？","TXT_CODE_PLUGIN_GROUP_DELETE_CONFIRM":"将删除该分组及其插件归属，插件本身不会被删除。","TXT_CODE_PLUGIN_GROUP_NAME":"分组名称","TXT_CODE_PLUGIN_SCOPE_NODE":"节点","TXT_CODE_PLUGIN_SCOPE_PANEL":"面板","TXT_CODE_PLUGIN_SELF_DISABLE":"插件管理自身无法被禁用，请改为在其 plugin.json 中把 enabled 设为 false。","TXT_CODE_PLUGIN_STATE_PENDING":"等待依赖","TXT_CODE_PLUGIN_STATE_DISABLED":"已禁用","TXT_CODE_PLUGIN_STATE_LOADING":"加载中","TXT_CODE_PLUGIN_STATE_ACTIVE":"运行中","TXT_CODE_PLUGIN_STATE_UNLOADING":"卸载中","TXT_CODE_PLUGIN_RESTART_REQUIRED":"需要重启服务才能应用此更改。","TXT_CODE_PLUGIN_SAVED_PENDING":"已保存，正在等待插件依赖。","TXT_CODE_PLUGIN_FRONTEND_FAILED":"浏览器插件加载失败","TXT_CODE_PLUGIN_REFRESH_REQUIRED":"需要刷新页面才能加载更新后的浏览器运行时。"}');
+
+/***/ },
+
+/***/ "./plugins/config/src/i18n/zh_TW.json"
+(module) {
+
+module.exports = /*#__PURE__*/JSON.parse('{"TXT_CODE_PLUGIN_NODE_DISABLE_CONFIRM":"是否同時停用以下節點上的對應外掛？請勾選需要同步操作的節點。","TXT_CODE_PLUGIN_NODE_DELETE_CONFIRM":"是否同時刪除以下節點上的對應外掛？請勾選需要同步操作的節點。","TXT_CODE_PLUGIN_NODE_CHECK_FAILED":"無法檢查以下節點的外掛：{nodes}。","TXT_CODE_PLUGIN_NODE_ACTION_FAILED":"以下節點上的外掛操作未完成：{nodes}","TXT_CODE_PLUGIN_CONFIG":"插件設定","TXT_CODE_PLUGIN_CANCEL":"取消","TXT_CODE_PLUGIN_DELETE":"刪除外掛","TXT_CODE_PLUGIN_DELETE_CONFIRM":"外掛檔案與已儲存的設定將會永久刪除。","TXT_CODE_PLUGIN_DELETE_CONFIRM_TITLE":"確定刪除 {name}？","TXT_CODE_PLUGIN_DELETE_UNAVAILABLE":"外掛以 npm 相依形式安裝，請使用 npm 解除安裝。","TXT_CODE_PLUGIN_DELETED":"外掛已刪除","TXT_CODE_PLUGIN_SAVE_SETTINGS":"儲存設定","TXT_CODE_PLUGIN_SAVE_REMINDER":"記得儲存設定！","TXT_CODE_PLUGIN_DISABLE":"停用","TXT_CODE_PLUGIN_DISABLED":"外掛已停用","TXT_CODE_PLUGIN_DISABLE_CONFIRM":"該外掛提供的所有元件都會被立即移除。","TXT_CODE_PLUGIN_DISABLE_CONFIRM_TITLE":"確定停用 {name}？","TXT_CODE_PLUGIN_ENABLE":"啟用","TXT_CODE_PLUGIN_ENABLED":"外掛已啟用","TXT_CODE_PLUGIN_ESSENTIAL_DISABLE":"Web 伺服器無法從它自己提供的頁面上停用，請改為在其 plugin.json 中把 enabled 設為 false。","TXT_CODE_PLUGIN_IS_DISABLED":"此外掛已停用，重新啟用前其頁面、路由與介面皆不可用。","TXT_CODE_PLUGIN_LOAD_FAILED":"此外掛載入失敗","TXT_CODE_PLUGIN_NODE_LIST_FAILED":"無法讀取該節點的外掛清單。","TXT_CODE_PLUGIN_NODE_NOT_FOUND":"該節點不存在。","TXT_CODE_PLUGIN_NODE_OFFLINE":"未連線","TXT_CODE_PLUGIN_NODE_SELECT":"選擇節點","TXT_CODE_PLUGIN_NO_CONFIG":"此插件沒有可設定項目","TXT_CODE_PLUGIN_GROUP_UNASSIGNED":"未分組","TXT_CODE_PLUGIN_GROUP_ADD":"新增分組","TXT_CODE_PLUGIN_GROUP_EDIT":"編輯外掛分組","TXT_CODE_PLUGIN_GROUP_RENAME":"重新命名分組","TXT_CODE_PLUGIN_GROUP_DELETE":"刪除分組","TXT_CODE_PLUGIN_GROUP_DELETE_CONFIRM_TITLE":"刪除分組「{name}」？","TXT_CODE_PLUGIN_GROUP_DELETE_CONFIRM":"將刪除該分組及其插件歸屬，插件本身不會被刪除。","TXT_CODE_PLUGIN_GROUP_NAME":"分組名稱","TXT_CODE_PLUGIN_SCOPE_NODE":"節點","TXT_CODE_PLUGIN_SCOPE_PANEL":"面板","TXT_CODE_PLUGIN_SELF_DISABLE":"外掛管理本身無法被停用，請改為在其 plugin.json 中把 enabled 設為 false。","TXT_CODE_PLUGIN_STATE_PENDING":"等待依賴","TXT_CODE_PLUGIN_STATE_DISABLED":"已停用","TXT_CODE_PLUGIN_STATE_LOADING":"載入中","TXT_CODE_PLUGIN_STATE_ACTIVE":"執行中","TXT_CODE_PLUGIN_STATE_UNLOADING":"卸載中","TXT_CODE_PLUGIN_RESTART_REQUIRED":"需要重新啟動服務才能套用此變更。","TXT_CODE_PLUGIN_SAVED_PENDING":"已儲存，正在等待外掛依賴。","TXT_CODE_PLUGIN_FRONTEND_FAILED":"瀏覽器外掛載入失敗","TXT_CODE_PLUGIN_REFRESH_REQUIRED":"需要重新整理頁面才能載入更新後的瀏覽器執行階段。"}');
+
+/***/ }
+
+/******/ 	});
+/************************************************************************/
+/******/ 	// The module cache
+/******/ 	var __webpack_module_cache__ = {};
+/******/ 	
+/******/ 	// The require function
+/******/ 	function __webpack_require__(moduleId) {
+/******/ 		// Check if module is in cache
+/******/ 		var cachedModule = __webpack_module_cache__[moduleId];
+/******/ 		if (cachedModule !== undefined) {
+/******/ 			return cachedModule.exports;
+/******/ 		}
+/******/ 		// Create a new module (and put it into the cache)
+/******/ 		var module = __webpack_module_cache__[moduleId] = {
+/******/ 			// no module.id needed
+/******/ 			// no module.loaded needed
+/******/ 			exports: {}
+/******/ 		};
+/******/ 	
+/******/ 		// Execute the module function
+/******/ 		__webpack_modules__[moduleId].call(module.exports, module, module.exports, __webpack_require__);
+/******/ 	
+/******/ 		// Return the exports of the module
+/******/ 		return module.exports;
+/******/ 	}
+/******/ 	
+/************************************************************************/
+var __webpack_exports__ = {};
+// This entry needs to be wrapped in an IIFE because it uses a non-standard name for the exports (exports).
+(() => {
+var exports = __webpack_exports__;
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.inject = void 0;
+exports.apply = apply;
+const i18n_1 = __webpack_require__("./plugins/config/src/i18n/index.ts");
+const settings_1 = __webpack_require__("./plugins/config/src/backend/settings.ts");
+// Panel side of the plugin manager page. The container owns the mechanism —
+// `ctx.plugins` lists what is installed and persists the enable switch — and this
+// plugin only exposes it over HTTP, because it owns the page that drives it.
+//
+// The same page administers each connected node's plugins. That half is a thin
+// proxy onto the daemon-side `config` plugin: the daemon decides what it will
+// switch off, and this plugin only carries the question there and the answer
+// back. It lives inside `ctx.inject(["remote"], ...)` so that a panel without
+// `plugins/node` still manages its own plugins.
+/** Turning this plugin off would remove the page the request came from. */
+const SELF = "config";
+/**
+ * Turning an essential plugin off would remove the interface or connection
+ * that is needed to turn it back on.
+ */
+const ESSENTIAL = new Set(["console", "i18n", "storage", "runtime", "server"]);
+const PLUGIN_GROUPS_CATEGORY = "PluginGroups";
+class StoredPluginGroups {
+    constructor() {
+        this.groups = [];
+    }
+}
+function normalizePluginGroups(input) {
+    if (!Array.isArray(input))
+        throw new Error("Plugin groups must be an array.");
+    if (input.length > 100)
+        throw new Error("Too many plugin groups.");
+    return input.map((value) => {
+        var _a, _b;
+        if (!value || typeof value !== "object")
+            throw new Error("Invalid plugin group.");
+        const group = value;
+        const id = String((_a = group.id) !== null && _a !== void 0 ? _a : "").trim();
+        const name = String((_b = group.name) !== null && _b !== void 0 ? _b : "").trim();
+        if (!id || id.length > 128 || !name || name.length > 200) {
+            throw new Error("Invalid plugin group.");
+        }
+        if (!Array.isArray(group.pluginIds) ||
+            group.pluginIds.length > 2000 ||
+            group.pluginIds.some((pluginId) => typeof pluginId !== "string")) {
+            throw new Error("Invalid plugin group plugins.");
+        }
+        return {
+            id,
+            name,
+            pluginIds: [...new Set(group.pluginIds.map((pluginId) => pluginId.trim()).filter(Boolean))]
+        };
+    });
+}
+exports.inject = [
+    "koa",
+    "i18n",
+    "middleware",
+    "roles",
+    "plugins",
+    "storage",
+    "settings",
+    "identity",
+    "operations"
+];
+function apply(ctx) {
+    ctx.i18n.define(i18n_1.localeMessages);
+    ctx.plugin(settings_1.SettingsFormService);
+    const settingsForm = ctx.get("settingsForm");
+    if (!settingsForm)
+        throw new Error("Panel settings form service is unavailable.");
+    const router = ctx.koa.router("/api/plugins");
+    const requireAdmin = ctx.middleware.permission({ level: ctx.roles.ADMIN });
+    // Remaining system settings are administered by this configuration plugin.
+    // Plugin-owned settings are declared by their own backend and handled by the
+    // generic routes below, so the core no longer mounts a settings router.
+    const settingsRouter = ctx.koa.router("/api/overview");
+    settingsRouter.get("/setting", requireAdmin, async (requestCtx) => {
+        requestCtx.body = ctx.settings.config;
+    });
+    settingsRouter.put("/setting", requireAdmin, async (requestCtx) => {
+        var _a;
+        const config = ((_a = requestCtx.request.body) !== null && _a !== void 0 ? _a : {});
+        const current = ctx.settings.config;
+        if (!config || !current)
+            throw new Error(ctx.i18n.$t("TXT_CODE_e4d6cc20"));
+        if (config.gzip != null)
+            current.gzip = config.gzip;
+        if (config.maxCompress != null)
+            current.maxCompress = config.maxCompress;
+        if (config.maxDownload != null)
+            current.maxDownload = config.maxDownload;
+        if (config.zipType != null)
+            current.zipType = config.zipType;
+        if (config.forwardType != null)
+            current.forwardType = Number(config.forwardType);
+        if (config.dataPort != null)
+            current.dataPort = Number(config.dataPort);
+        ctx.operations.log("system_config_change", {
+            operator_ip: requestCtx.ip,
+            operator_name: ctx.identity.of(requestCtx).userName
+        });
+        await ctx.settings.save();
+        requestCtx.body = "OK";
+    });
+    // Everything installed, disabled plugins included: the page needs to list one
+    // to be able to enable it again.
+    router.get("/", requireAdmin, async (requestCtx) => {
+        const declared = new Set(settingsForm.declared());
+        requestCtx.body = ctx.plugins.inventory().map((record) => ({
+            ...record,
+            // So the page can say "no configurable options" without a round trip.
+            hasSettings: declared.has(record.id)
+        }));
+    });
+    // One plugin's form and its current values, as its own backend describes them.
+    // `null` when it declared nothing.
+    router.get("/settings", requireAdmin, async (requestCtx) => {
+        var _a;
+        requestCtx.body = await settingsForm.read(String((_a = requestCtx.request.query.id) !== null && _a !== void 0 ? _a : ""));
+    });
+    router.put("/settings", requireAdmin, ctx.middleware.validator({ query: { id: String } }), async (requestCtx) => {
+        var _a;
+        const id = String(requestCtx.request.query.id);
+        // The plugin's own `write()` validates: this route knows nothing about
+        // what any particular plugin's values mean.
+        requestCtx.body = await settingsForm.write(id, ((_a = requestCtx.request.body) !== null && _a !== void 0 ? _a : {}));
+    });
+    const groupsStorageId = (requestCtx) => String(ctx.identity.of(requestCtx).uuid || "anonymous");
+    router.get("/groups", requireAdmin, async (requestCtx) => {
+        var _a;
+        const stored = (await ctx.storage.getStorage().load(PLUGIN_GROUPS_CATEGORY, StoredPluginGroups, groupsStorageId(requestCtx)));
+        requestCtx.body = (_a = stored === null || stored === void 0 ? void 0 : stored.groups) !== null && _a !== void 0 ? _a : [];
+    });
+    router.put("/groups", requireAdmin, async (requestCtx) => {
+        var _a;
+        const groups = normalizePluginGroups((_a = requestCtx.request.body) === null || _a === void 0 ? void 0 : _a.groups);
+        await ctx.storage.getStorage().store(PLUGIN_GROUPS_CATEGORY, groupsStorageId(requestCtx), {
+            groups
+        });
+        requestCtx.body = groups;
+    });
+    router.put("/enabled", requireAdmin, ctx.middleware.validator({ body: { id: String, enabled: Boolean } }), async (requestCtx) => {
+        const id = String(requestCtx.request.body.id);
+        const enabled = Boolean(requestCtx.request.body.enabled);
+        // Thrown rather than answered: the panel's response protocol turns an
+        // Error into the standard envelope, which is what the page reports.
+        if (id === SELF && !enabled)
+            throw new Error(ctx.i18n.$t("TXT_CODE_PLUGIN_SELF_DISABLE"));
+        if (ESSENTIAL.has(id) && !enabled)
+            throw new Error(ctx.i18n.$t("TXT_CODE_PLUGIN_ESSENTIAL_DISABLE"));
+        requestCtx.body = await ctx.plugins.setEnabled(id, enabled);
+    });
+    router.delete("/", requireAdmin, ctx.middleware.validator({ query: { id: String } }), async (requestCtx) => {
+        await ctx.plugins.remove(String(requestCtx.request.query.id));
+        requestCtx.body = { removed: true };
+    });
+    // The node half. `remote` is resolved here rather than injected at the top, so
+    // removing `plugins/node` takes the node routes away and leaves the rest of the
+    // page working.
+    ctx.inject(["remote"], (scoped) => {
+        const nodeRouter = scoped.koa.router("/api/plugins/node");
+        const RemoteRequest = scoped.remote.Request;
+        const nodeOf = (requestCtx) => {
+            var _a;
+            const daemonId = String((_a = requestCtx.request.query.daemonId) !== null && _a !== void 0 ? _a : "");
+            const node = scoped.remote.services.getInstance(daemonId);
+            if (!node)
+                throw new Error(ctx.i18n.$t("TXT_CODE_PLUGIN_NODE_NOT_FOUND"));
+            return node;
+        };
+        // Which nodes there are to administer. Unavailable ones are listed too, so
+        // the page can say why it cannot reach one instead of hiding it.
+        nodeRouter.get("/list", requireAdmin, async (requestCtx) => {
+            requestCtx.body = Array.from(scoped.remote.services.services.entries()).map(([uuid, node]) => ({
+                uuid,
+                remarks: node.config.remarks,
+                ip: node.config.ip,
+                port: node.config.port,
+                available: node.available
+            }));
+        });
+        // Straight through to the daemon's own inventory.
+        nodeRouter.get("/plugins", requireAdmin, async (requestCtx) => {
+            requestCtx.body = await new RemoteRequest(nodeOf(requestCtx)).request("plugin/list");
+        });
+        nodeRouter.put("/enabled", requireAdmin, ctx.middleware.validator({
+            query: { daemonId: String },
+            body: { id: String, enabled: Boolean }
+        }), async (requestCtx) => {
+            const node = nodeOf(requestCtx);
+            const id = String(requestCtx.request.body.id);
+            const enabled = Boolean(requestCtx.request.body.enabled);
+            // No id list is checked here: which of its plugins a daemon refuses to
+            // switch off is the daemon's own business, and its refusal arrives as a
+            // protocol error that the response protocol turns into this envelope.
+            const record = await new RemoteRequest(node).request("plugin/enabled", { id, enabled });
+            // A daemon binds its protocol events onto each socket as that socket
+            // connects (`service/router.ts`), so a handler that has just appeared —
+            // or just gone — is invisible to the connection we are holding. The node
+            // is reconnected here, which is the only thing that makes the change
+            // actually reachable; the daemon has already answered by now.
+            node.refreshReconnect();
+            requestCtx.body = record;
+        });
+        nodeRouter.delete("/", requireAdmin, ctx.middleware.validator({ query: { daemonId: String, id: String } }), async (requestCtx) => {
+            const node = nodeOf(requestCtx);
+            // Removing unloads the plugin's scope before the files go, which can
+            // outlast the default request window; the market uninstall waits 30s too.
+            await new RemoteRequest(node).request("plugin/remove", { id: String(requestCtx.request.query.id) }, 30000);
+            node.refreshReconnect();
+            requestCtx.body = { removed: true };
+        });
+        // A daemon plugin's configuration, described by the plugin itself and
+        // rendered by the same generic form. Nothing about the form lives here.
+        nodeRouter.get("/settings", requireAdmin, ctx.middleware.validator({ query: { daemonId: String, id: String } }), async (requestCtx) => {
+            requestCtx.body = await new RemoteRequest(nodeOf(requestCtx)).request("plugin/config", {
+                id: String(requestCtx.request.query.id)
+            });
+        });
+        nodeRouter.put("/settings", requireAdmin, ctx.middleware.validator({ query: { daemonId: String, id: String } }), async (requestCtx) => {
+            var _a;
+            const request = new RemoteRequest(nodeOf(requestCtx));
+            requestCtx.body = await request.request("plugin/config/write", {
+                id: String(requestCtx.request.query.id),
+                values: ((_a = requestCtx.request.body) !== null && _a !== void 0 ? _a : {})
+            });
+            // Refresh node-owned connection metadata before subsequent file/terminal requests.
+            // A refresh failure must not turn a successfully saved setting into an error.
+            try {
+                await request.request("info/overview");
+            }
+            catch (error) {
+                ctx.logger.warn("Failed to refresh node information after saving plugin settings:", error);
+            }
+        });
+        nodeRouter.get("/groups", requireAdmin, ctx.middleware.validator({ query: { daemonId: String } }), async (requestCtx) => {
+            requestCtx.body = await new RemoteRequest(nodeOf(requestCtx)).request("plugin/groups");
+        });
+        nodeRouter.put("/groups", requireAdmin, ctx.middleware.validator({ query: { daemonId: String } }), async (requestCtx) => {
+            var _a;
+            const groups = (_a = requestCtx.request.body) === null || _a === void 0 ? void 0 : _a.groups;
+            requestCtx.body = await new RemoteRequest(nodeOf(requestCtx)).request("plugin/groups/write", { groups });
+        });
+    });
+}
+
+})();
+
+module.exports = __webpack_exports__;
+/******/ })()
+;