@hartl-services/medusa-base 0.3.0 → 0.4.0

package/.medusa/server/src/modules/plugin-features/domain/plugin-settings.js

@@ -0,0 +1,213 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toStoredSettingValues = exports.missingSettingKeys = exports.isSealed = void 0;
+exports.normalizeSettingValue = normalizeSettingValue;
+exports.validateSettingsUpdate = validateSettingsUpdate;
+exports.mergeStoredSettings = mergeStoredSettings;
+exports.resolveSettingValues = resolveSettingValues;
+const utils_1 = require("@medusajs/framework/utils");
+const isHttpUrl = (value) => {
+    try {
+        const url = new URL(value);
+        return url.protocol === "http:" || url.protocol === "https:";
+    }
+    catch {
+        return false;
+    }
+};
+const isSealed = (value) => typeof value === "object" &&
+    value !== null &&
+    typeof value.enc === "string";
+exports.isSealed = isSealed;
+/**
+ * Normalizes `value` for `definition` or returns why it is invalid. Strings
+ * and URLs are trimmed; secrets are kept exactly as entered.
+ */
+function normalizeSettingValue(definition, value) {
+    switch (definition.type) {
+        case "string":
+        case "url": {
+            if (typeof value !== "string" || !value.trim()) {
+                return { ok: false, message: "muss ein nicht-leerer Text sein" };
+            }
+            const trimmed = value.trim();
+            if (definition.type === "url" && !isHttpUrl(trimmed)) {
+                return { ok: false, message: "muss eine http(s)-URL sein" };
+            }
+            return { ok: true, value: trimmed };
+        }
+        case "secret":
+            return typeof value === "string" && value.trim()
+                ? { ok: true, value }
+                : { ok: false, message: "muss ein nicht-leerer Text sein" };
+        case "number": {
+            if (typeof value !== "number" || !Number.isFinite(value)) {
+                return { ok: false, message: "muss eine endliche Zahl sein" };
+            }
+            if (definition.min !== undefined && value < definition.min) {
+                return { ok: false, message: `muss mindestens ${definition.min} sein` };
+            }
+            if (definition.max !== undefined && value > definition.max) {
+                return { ok: false, message: `darf höchstens ${definition.max} sein` };
+            }
+            return { ok: true, value };
+        }
+        case "select": {
+            const options = definition.options ?? [];
+            return typeof value === "string" &&
+                options.some((option) => option.value === value)
+                ? { ok: true, value }
+                : {
+                    ok: false,
+                    message: `muss einer der Werte ${options
+                        .map((option) => `"${option.value}"`)
+                        .join(", ")} sein`,
+                };
+        }
+        case "boolean":
+            return typeof value === "boolean"
+                ? { ok: true, value }
+                : { ok: false, message: "muss true oder false sein" };
+        default:
+            return { ok: false, message: "hat einen unbekannten Typ" };
+    }
+}
+const invalid = (pluginKey, message) => new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, `Ungültige Einstellungen für Plugin "${pluginKey}": ${message}`);
+/**
+ * Validates an Admin update against the declared settings. `null` clears a
+ * key; any other value is normalized. Throws `INVALID_DATA` naming the key.
+ */
+function validateSettingsUpdate(descriptor, values) {
+    const declared = new Map((descriptor.settings ?? []).map((setting) => [setting.key, setting]));
+    const unknown = Object.keys(values).filter((key) => !declared.has(key));
+    if (unknown.length) {
+        throw invalid(descriptor.plugin_key, `unbekannte Einstellungen ${unknown.map((key) => `"${key}"`).join(", ")}.`);
+    }
+    const result = {};
+    for (const [key, value] of Object.entries(values)) {
+        if (value === null) {
+            result[key] = null;
+            continue;
+        }
+        const checked = normalizeSettingValue(declared.get(key), value);
+        if (!checked.ok) {
+            throw invalid(descriptor.plugin_key, `"${key}" ${checked.message}.`);
+        }
+        result[key] = checked.value;
+    }
+    return result;
+}
+const sameStored = (left, right) => (0, exports.isSealed)(left) || (0, exports.isSealed)(right) ? false : left === right;
+/**
+ * Applies a validated update to the stored values: `null` deletes, secrets
+ * are sealed, secrets not sent keep their stored value, keys the descriptor
+ * no longer declares are dropped. When a setting with `invalidates` changed,
+ * the stored values of the listed secrets are deleted too, unless the same
+ * update sets them anew. `changed_keys` lists every declared key whose
+ * stored value was set, replaced or removed (a re-sent secret counts), in
+ * declaration order.
+ */
+function mergeStoredSettings(descriptor, current, update, seal) {
+    const values = {};
+    const changed = [];
+    for (const definition of descriptor.settings ?? []) {
+        const key = definition.key;
+        const before = current[key];
+        if (!(key in update)) {
+            if (before !== undefined) {
+                values[key] = before;
+            }
+            continue;
+        }
+        const next = update[key];
+        if (next === null || next === undefined) {
+            if (before !== undefined) {
+                changed.push(key);
+            }
+            continue;
+        }
+        const stored = definition.type === "secret" ? { enc: seal(String(next), key) } : next;
+        values[key] = stored;
+        if (!sameStored(before, stored)) {
+            changed.push(key);
+        }
+    }
+    const invalidated = new Set();
+    for (const definition of descriptor.settings ?? []) {
+        if (!changed.includes(definition.key)) {
+            continue;
+        }
+        for (const target of definition.invalidates ?? []) {
+            const resent = update[target] !== null && update[target] !== undefined;
+            if (!resent && values[target] !== undefined) {
+                delete values[target];
+                invalidated.add(target);
+            }
+        }
+    }
+    const changedKeys = (descriptor.settings ?? [])
+        .map(({ key }) => key)
+        .filter((key) => changed.includes(key) || invalidated.has(key));
+    return { values, changed_keys: changedKeys };
+}
+/**
+ * Current value and source of every declared setting. Precedence:
+ * stored > config fallback > default > none. A stored or fallback value that
+ * no longer fits the declared type is skipped; `open` returns `undefined` for
+ * a stored secret that cannot be decrypted, which is then skipped as well.
+ */
+function resolveSettingValues(descriptor, stored, fallback, open) {
+    return (descriptor.settings ?? []).map((definition) => {
+        const key = definition.key;
+        const raw = stored[key];
+        if (raw !== undefined) {
+            const candidate = definition.type === "secret"
+                ? (0, exports.isSealed)(raw)
+                    ? open(key, raw.enc)
+                    : undefined
+                : (0, exports.isSealed)(raw)
+                    ? undefined
+                    : raw;
+            const checked = candidate === undefined
+                ? undefined
+                : normalizeSettingValue(definition, candidate);
+            if (checked?.ok) {
+                return { definition, source: "stored", value: checked.value };
+            }
+        }
+        const configured = fallback?.[key];
+        if (configured !== undefined && configured !== null && configured !== "") {
+            const checked = normalizeSettingValue(definition, configured);
+            if (checked.ok) {
+                return { definition, source: "config", value: checked.value };
+            }
+        }
+        if (definition.default !== undefined && definition.type !== "secret") {
+            return { definition, source: "default", value: definition.default };
+        }
+        return { definition, source: "none" };
+    });
+}
+/** Required settings without a value. */
+const missingSettingKeys = (resolved) => resolved
+    .filter((setting) => setting.definition.required === true && setting.source === "none")
+    .map((setting) => setting.definition.key);
+exports.missingSettingKeys = missingSettingKeys;
+/** Reads a persisted `values` column defensively. */
+const toStoredSettingValues = (raw) => {
+    const values = {};
+    if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
+        return values;
+    }
+    for (const [key, value] of Object.entries(raw)) {
+        if (typeof value === "string" ||
+            typeof value === "boolean" ||
+            (typeof value === "number" && Number.isFinite(value)) ||
+            (0, exports.isSealed)(value)) {
+            values[key] = (0, exports.isSealed)(value) ? { enc: value.enc } : value;
+        }
+    }
+    return values;
+};
+exports.toStoredSettingValues = toStoredSettingValues;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"plugin-settings.js","sourceRoot":"","sources":["../../../../../../src/modules/plugin-features/domain/plugin-settings.ts"],"names":[],"mappings":"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"}

package/.medusa/server/src/modules/plugin-features/domain/secret-box.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.secretBinding = void 0;
+exports.sealSecret = sealSecret;
+exports.openSecret = openSecret;
+const node_crypto_1 = require("node:crypto");
+const HKDF_INFO = "hartl-base-plugin-settings";
+const IV_BYTES = 12;
+const TAG_BYTES = 16;
+const KEY_BYTES = 32;
+const deriveKey = (keyMaterial) => {
+    if (!keyMaterial) {
+        throw new Error("Schlüsselmaterial für geheime Einstellungen fehlt.");
+    }
+    return Buffer.from((0, node_crypto_1.hkdfSync)("sha256", keyMaterial, Buffer.alloc(0), HKDF_INFO, KEY_BYTES));
+};
+/**
+ * Additional authenticated data of one stored secret: binds the ciphertext to
+ * its plugin and setting key, so it cannot be moved to another key or plugin.
+ */
+const secretBinding = (pluginKey, settingKey) => `${pluginKey}:${settingKey}`;
+exports.secretBinding = secretBinding;
+/**
+ * AES-256-GCM with a key derived by HKDF-SHA256 from `keyMaterial` and
+ * `binding` (see `secretBinding`) as additional authenticated data. Returns
+ * base64 of `iv (12) | tag (16) | ciphertext`.
+ */
+function sealSecret(plaintext, keyMaterial, binding) {
+    const iv = (0, node_crypto_1.randomBytes)(IV_BYTES);
+    const cipher = (0, node_crypto_1.createCipheriv)("aes-256-gcm", deriveKey(keyMaterial), iv);
+    cipher.setAAD(Buffer.from(binding, "utf8"));
+    const ciphertext = Buffer.concat([
+        cipher.update(plaintext, "utf8"),
+        cipher.final(),
+    ]);
+    return Buffer.concat([iv, cipher.getAuthTag(), ciphertext]).toString("base64");
+}
+/**
+ * Reverses `sealSecret`. Throws when the value was tampered with, is
+ * malformed, or was sealed with different key material or another binding
+ * (including values sealed without one).
+ */
+function openSecret(sealed, keyMaterial, binding) {
+    const raw = Buffer.from(sealed, "base64");
+    if (raw.length < IV_BYTES + TAG_BYTES) {
+        throw new Error("Verschlüsselter Wert ist unvollständig.");
+    }
+    const decipher = (0, node_crypto_1.createDecipheriv)("aes-256-gcm", deriveKey(keyMaterial), raw.subarray(0, IV_BYTES));
+    decipher.setAAD(Buffer.from(binding, "utf8"));
+    decipher.setAuthTag(raw.subarray(IV_BYTES, IV_BYTES + TAG_BYTES));
+    return Buffer.concat([
+        decipher.update(raw.subarray(IV_BYTES + TAG_BYTES)),
+        decipher.final(),
+    ]).toString("utf8");
+}
+//# sourceMappingURL=data:application/json;base64,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

package/.medusa/server/src/modules/plugin-features/migrations/Migration20260928205031.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Migration20260928205031 = void 0;
+const migrations_1 = require("@medusajs/framework/mikro-orm/migrations");
+class Migration20260928205031 extends migrations_1.Migration {
+    async up() {
+        this.addSql(`create table if not exists "plugin_setting_state" ("id" text not null, "plugin_key" text not null, "values" jsonb not null, "version" integer not null default 1, "created_at" timestamptz not null default now(), "updated_at" timestamptz not null default now(), "deleted_at" timestamptz null, constraint "plugin_setting_state_pkey" primary key ("id"));`);
+        this.addSql(`CREATE INDEX IF NOT EXISTS "IDX_plugin_setting_state_deleted_at" ON "plugin_setting_state" ("deleted_at") WHERE deleted_at IS NULL;`);
+        this.addSql(`CREATE UNIQUE INDEX IF NOT EXISTS "IDX_plugin_setting_state_plugin_key" ON "plugin_setting_state" ("plugin_key") WHERE deleted_at IS NULL;`);
+    }
+    async down() {
+        this.addSql(`drop table if exists "plugin_setting_state" cascade;`);
+    }
+}
+exports.Migration20260928205031 = Migration20260928205031;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiTWlncmF0aW9uMjAyNjA5MjgyMDUwMzEuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9zcmMvbW9kdWxlcy9wbHVnaW4tZmVhdHVyZXMvbWlncmF0aW9ucy9NaWdyYXRpb24yMDI2MDkyODIwNTAzMS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7QUFBQSx5RUFBcUU7QUFFckUsTUFBYSx1QkFBd0IsU0FBUSxzQkFBUztJQUUzQyxLQUFLLENBQUMsRUFBRTtRQUNmLElBQUksQ0FBQyxNQUFNLENBQUMsZ1dBQWdXLENBQUMsQ0FBQztRQUM5VyxJQUFJLENBQUMsTUFBTSxDQUFDLHFJQUFxSSxDQUFDLENBQUM7UUFDbkosSUFBSSxDQUFDLE1BQU0sQ0FBQyw0SUFBNEksQ0FBQyxDQUFDO0lBQzVKLENBQUM7SUFFUSxLQUFLLENBQUMsSUFBSTtRQUNqQixJQUFJLENBQUMsTUFBTSxDQUFDLHNEQUFzRCxDQUFDLENBQUM7SUFDdEUsQ0FBQztDQUVGO0FBWkQsMERBWUMifQ==

package/.medusa/server/src/modules/plugin-features/migrations/Migration20260928215428.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Migration20260928215428 = void 0;
+const migrations_1 = require("@medusajs/framework/mikro-orm/migrations");
+class Migration20260928215428 extends migrations_1.Migration {
+    async up() {
+        this.addSql(`create table if not exists "plugin_action_run" ("id" text not null, "plugin_key" text not null, "action_key" text not null, "status" text check ("status" in ('running', 'completed', 'failed')) not null, "started_at" timestamptz not null, "finished_at" timestamptz null, "triggered_by" text null, "message" text null, "progress" jsonb null, "result" jsonb null, "created_at" timestamptz not null default now(), "updated_at" timestamptz not null default now(), "deleted_at" timestamptz null, constraint "plugin_action_run_pkey" primary key ("id"));`);
+        this.addSql(`CREATE INDEX IF NOT EXISTS "IDX_plugin_action_run_deleted_at" ON "plugin_action_run" ("deleted_at") WHERE deleted_at IS NULL;`);
+        this.addSql(`CREATE INDEX IF NOT EXISTS "IDX_plugin_action_run_plugin_action_status" ON "plugin_action_run" ("plugin_key", "action_key", "status") WHERE deleted_at IS NULL;`);
+        this.addSql(`CREATE UNIQUE INDEX IF NOT EXISTS "IDX_plugin_action_run_single_running" ON "plugin_action_run" ("plugin_key", "action_key") WHERE status = 'running' AND deleted_at IS NULL;`);
+    }
+    async down() {
+        this.addSql(`drop table if exists "plugin_action_run" cascade;`);
+    }
+}
+exports.Migration20260928215428 = Migration20260928215428;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiTWlncmF0aW9uMjAyNjA5MjgyMTU0MjguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9zcmMvbW9kdWxlcy9wbHVnaW4tZmVhdHVyZXMvbWlncmF0aW9ucy9NaWdyYXRpb24yMDI2MDkyODIxNTQyOC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7QUFBQSx5RUFBcUU7QUFFckUsTUFBYSx1QkFBd0IsU0FBUSxzQkFBUztJQUUzQyxLQUFLLENBQUMsRUFBRTtRQUNmLElBQUksQ0FBQyxNQUFNLENBQUMsb2lCQUFvaUIsQ0FBQyxDQUFDO1FBQ2xqQixJQUFJLENBQUMsTUFBTSxDQUFDLCtIQUErSCxDQUFDLENBQUM7UUFDN0ksSUFBSSxDQUFDLE1BQU0sQ0FBQyxpS0FBaUssQ0FBQyxDQUFDO1FBQy9LLElBQUksQ0FBQyxNQUFNLENBQUMsK0tBQStLLENBQUMsQ0FBQztJQUMvTCxDQUFDO0lBRVEsS0FBSyxDQUFDLElBQUk7UUFDakIsSUFBSSxDQUFDLE1BQU0sQ0FBQyxtREFBbUQsQ0FBQyxDQUFDO0lBQ25FLENBQUM7Q0FFRjtBQWJELDBEQWFDIn0=

package/.medusa/server/src/modules/plugin-features/models/plugin-action-run.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("@medusajs/framework/utils");
+/**
+ * One run of a plugin action started through the base (sync or background).
+ * At most one `running` row per plugin action (partial unique index), which
+ * is what rejects a second start.
+ */
+const PluginActionRun = utils_1.model
+    .define({
+    name: "plugin_action_run",
+    tableName: "plugin_action_run",
+}, {
+    id: utils_1.model.id({ prefix: "plgrun" }).primaryKey(),
+    plugin_key: utils_1.model.text(),
+    action_key: utils_1.model.text(),
+    status: utils_1.model.enum(["running", "completed", "failed"]),
+    started_at: utils_1.model.dateTime(),
+    finished_at: utils_1.model.dateTime().nullable(),
+    /** Admin user id that started the run. */
+    triggered_by: utils_1.model.text().nullable(),
+    /** Error message of a failed run. */
+    message: utils_1.model.text().nullable(),
+    /** `{ current, total, label }` reported by the running workflow. */
+    progress: utils_1.model.json().nullable(),
+    /** Workflow result when it is JSON and at most 4 KB. */
+    result: utils_1.model.json().nullable(),
+})
+    .indexes([
+    {
+        name: "IDX_plugin_action_run_plugin_action_status",
+        on: ["plugin_key", "action_key", "status"],
+        where: "deleted_at IS NULL",
+    },
+    {
+        name: "IDX_plugin_action_run_single_running",
+        on: ["plugin_key", "action_key"],
+        unique: true,
+        where: "status = 'running' AND deleted_at IS NULL",
+    },
+]);
+exports.default = PluginActionRun;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGx1Z2luLWFjdGlvbi1ydW4uanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9zcmMvbW9kdWxlcy9wbHVnaW4tZmVhdHVyZXMvbW9kZWxzL3BsdWdpbi1hY3Rpb24tcnVuLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7O0FBQUEscURBQWlEO0FBRWpEOzs7O0dBSUc7QUFDSCxNQUFNLGVBQWUsR0FBRyxhQUFLO0tBQzFCLE1BQU0sQ0FDTDtJQUNFLElBQUksRUFBRSxtQkFBbUI7SUFDekIsU0FBUyxFQUFFLG1CQUFtQjtDQUMvQixFQUNEO0lBQ0UsRUFBRSxFQUFFLGFBQUssQ0FBQyxFQUFFLENBQUMsRUFBRSxNQUFNLEVBQUUsUUFBUSxFQUFFLENBQUMsQ0FBQyxVQUFVLEVBQUU7SUFDL0MsVUFBVSxFQUFFLGFBQUssQ0FBQyxJQUFJLEVBQUU7SUFDeEIsVUFBVSxFQUFFLGFBQUssQ0FBQyxJQUFJLEVBQUU7SUFDeEIsTUFBTSxFQUFFLGFBQUssQ0FBQyxJQUFJLENBQUMsQ0FBQyxTQUFTLEVBQUUsV0FBVyxFQUFFLFFBQVEsQ0FBQyxDQUFDO0lBQ3RELFVBQVUsRUFBRSxhQUFLLENBQUMsUUFBUSxFQUFFO0lBQzVCLFdBQVcsRUFBRSxhQUFLLENBQUMsUUFBUSxFQUFFLENBQUMsUUFBUSxFQUFFO0lBQ3hDLDBDQUEwQztJQUMxQyxZQUFZLEVBQUUsYUFBSyxDQUFDLElBQUksRUFBRSxDQUFDLFFBQVEsRUFBRTtJQUNyQyxxQ0FBcUM7SUFDckMsT0FBTyxFQUFFLGFBQUssQ0FBQyxJQUFJLEVBQUUsQ0FBQyxRQUFRLEVBQUU7SUFDaEMsb0VBQW9FO0lBQ3BFLFFBQVEsRUFBRSxhQUFLLENBQUMsSUFBSSxFQUFFLENBQUMsUUFBUSxFQUFFO0lBQ2pDLHdEQUF3RDtJQUN4RCxNQUFNLEVBQUUsYUFBSyxDQUFDLElBQUksRUFBRSxDQUFDLFFBQVEsRUFBRTtDQUNoQyxDQUNGO0tBQ0EsT0FBTyxDQUFDO0lBQ1A7UUFDRSxJQUFJLEVBQUUsNENBQTRDO1FBQ2xELEVBQUUsRUFBRSxDQUFDLFlBQVksRUFBRSxZQUFZLEVBQUUsUUFBUSxDQUFDO1FBQzFDLEtBQUssRUFBRSxvQkFBb0I7S0FDNUI7SUFDRDtRQUNFLElBQUksRUFBRSxzQ0FBc0M7UUFDNUMsRUFBRSxFQUFFLENBQUMsWUFBWSxFQUFFLFlBQVksQ0FBQztRQUNoQyxNQUFNLEVBQUUsSUFBSTtRQUNaLEtBQUssRUFBRSwyQ0FBMkM7S0FDbkQ7Q0FDRixDQUFDLENBQUE7QUFFSixrQkFBZSxlQUFlLENBQUEifQ==

package/.medusa/server/src/modules/plugin-features/models/plugin-setting-state.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("@medusajs/framework/utils");
+/**
+ * One row per plugin with the settings stored through the Admin. No row (or
+ * a missing key) means the setting falls back to medusa-config or its
+ * declared default.
+ */
+const PluginSettingState = utils_1.model
+    .define({
+    name: "plugin_setting_state",
+    tableName: "plugin_setting_state",
+}, {
+    id: utils_1.model.id({ prefix: "plgset" }).primaryKey(),
+    plugin_key: utils_1.model.text(),
+    /**
+     * `{ [settingKey]: string | number | boolean }`; a secret is stored as
+     * `{ enc: "<base64 iv|tag|ciphertext>" }`.
+     */
+    values: utils_1.model.json(),
+    version: utils_1.model.number().default(1),
+})
+    .indexes([
+    {
+        name: "IDX_plugin_setting_state_plugin_key",
+        on: ["plugin_key"],
+        unique: true,
+        where: "deleted_at IS NULL",
+    },
+]);
+exports.default = PluginSettingState;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGx1Z2luLXNldHRpbmctc3RhdGUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9zcmMvbW9kdWxlcy9wbHVnaW4tZmVhdHVyZXMvbW9kZWxzL3BsdWdpbi1zZXR0aW5nLXN0YXRlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7O0FBQUEscURBQWlEO0FBRWpEOzs7O0dBSUc7QUFDSCxNQUFNLGtCQUFrQixHQUFHLGFBQUs7S0FDN0IsTUFBTSxDQUNMO0lBQ0UsSUFBSSxFQUFFLHNCQUFzQjtJQUM1QixTQUFTLEVBQUUsc0JBQXNCO0NBQ2xDLEVBQ0Q7SUFDRSxFQUFFLEVBQUUsYUFBSyxDQUFDLEVBQUUsQ0FBQyxFQUFFLE1BQU0sRUFBRSxRQUFRLEVBQUUsQ0FBQyxDQUFDLFVBQVUsRUFBRTtJQUMvQyxVQUFVLEVBQUUsYUFBSyxDQUFDLElBQUksRUFBRTtJQUN4Qjs7O09BR0c7SUFDSCxNQUFNLEVBQUUsYUFBSyxDQUFDLElBQUksRUFBRTtJQUNwQixPQUFPLEVBQUUsYUFBSyxDQUFDLE1BQU0sRUFBRSxDQUFDLE9BQU8sQ0FBQyxDQUFDLENBQUM7Q0FDbkMsQ0FDRjtLQUNBLE9BQU8sQ0FBQztJQUNQO1FBQ0UsSUFBSSxFQUFFLHFDQUFxQztRQUMzQyxFQUFFLEVBQUUsQ0FBQyxZQUFZLENBQUM7UUFDbEIsTUFBTSxFQUFFLElBQUk7UUFDWixLQUFLLEVBQUUsb0JBQW9CO0tBQzVCO0NBQ0YsQ0FBQyxDQUFBO0FBRUosa0JBQWUsa0JBQWtCLENBQUEifQ==