ehbrowser 1.0.0

package/dist/services/auth-service.js

@@ -0,0 +1,276 @@
+/*
+ * 账号服务：登录、igneous 维护、账号增删改与状态摘要。
+ * 凭据只写入 auth_setting，对外一律脱敏；变更后经 SSE 通知界面。
+ */
+import { activeAccount, igneousAgeDays, isCompleteCookies, isIgneousStale, newAccountId, removeAccount as removeFromList, upsertAccount, } from "../config/index.js";
+import { fetchIgneous, forumLogin, hasLoginCookies, isIgneousValue, probeExAccess, } from "../eh/index.js";
+import { describeTransportError } from "../platform/errors.js";
+const EX_ACCESS_META_KEY = "ex_accessible";
+export function createAuthService(ctx, options = {}) {
+    const log = options.logger ?? (() => undefined);
+    const listeners = new Set();
+    function status() {
+        const auth = ctx.auth.get();
+        const account = activeAccount(auth);
+        const cached = ctx.db.getMeta(EX_ACCESS_META_KEY);
+        // 账号条目可能仍在但凭据已被清除，故以凭据是否可用判定登录态
+        const usable = account !== null && hasLoginCookies(account.cookies);
+        return {
+            loggedIn: usable,
+            activeAccount: account === null ? null : summarize(auth, account),
+            accountCount: auth.accounts.length,
+            igneousAgeDays: usable ? igneousAgeDays(account) : null,
+            igneousStale: usable ? isIgneousStale(account) : false,
+            exAccessible: cached === null ? null : cached === "1",
+        };
+    }
+    function broadcast() {
+        const next = status();
+        for (const listener of listeners) {
+            try {
+                listener(next);
+            }
+            catch {
+                // 单个订阅者异常不影响其余订阅者
+            }
+        }
+    }
+    ctx.auth.onChange(() => {
+        broadcast();
+    });
+    /** 写入账号并设为当前账号 */
+    async function persistAccount(account, makeActive) {
+        const auth = ctx.auth.get();
+        await ctx.auth.patch({
+            accounts: upsertAccount(auth.accounts, account),
+            activeAccountId: makeActive ? account.id : auth.activeAccountId,
+        });
+    }
+    /**
+     * 里站可达性探测
+     * 探测失败（连接失败、握手被重置、连接被拒）按「不可达」处理，只记日志：
+     * 该结果为可选信息，不应影响登录之类的主流程
+     */
+    async function probe() {
+        const account = activeAccount(ctx.auth.get());
+        let accessible = false;
+        try {
+            accessible = await probeExAccess(account === null
+                ? {}
+                : {
+                    ipbMemberId: account.cookies.ipbMemberId,
+                    ipbPassHash: account.cookies.ipbPassHash,
+                    igneous: account.cookies.igneous,
+                });
+        }
+        catch (error) {
+            log("warn", `里站探测失败，按不可达处理：${describeTransportError(error)}`);
+        }
+        ctx.db.setMeta(EX_ACCESS_META_KEY, accessible ? "1" : "0");
+        log("info", `里站探测：${accessible ? "可达" : "不可达"}`);
+        broadcast();
+        return accessible;
+    }
+    /** 补齐 igneous；取不到时只记日志，登录本身仍算成功 */
+    async function withIgneous(account) {
+        if (isIgneousValue(account.cookies.igneous)) {
+            return account;
+        }
+        let igneous = null;
+        try {
+            igneous = await fetchIgneous({
+                ipbMemberId: account.cookies.ipbMemberId,
+                ipbPassHash: account.cookies.ipbPassHash,
+                ...(account.cookies.ipbSessionId === undefined
+                    ? {}
+                    : { ipbSessionId: account.cookies.ipbSessionId }),
+            }, {
+                onFailure: (site, error) => {
+                    log("warn", `取 igneous 时 ${site} 请求失败（继续试下一个）：${describeTransportError(error)}`);
+                },
+            });
+        }
+        catch (error) {
+            // 兜底：取 igneous 失败只影响 igneous，登录本身照常算成功
+            log("warn", `未取到 igneous：${describeTransportError(error)}`);
+            return account;
+        }
+        if (igneous === null) {
+            log("warn", "未取到 igneous：当前出口节点可能被上游拒绝，里站需换节点后重新登录");
+            return account;
+        }
+        log("info", `已取得 igneous（${igneous.length} 位）`);
+        return {
+            ...account,
+            cookies: { ...account.cookies, igneous },
+            igneousUpdatedAt: Math.floor(Date.now() / 1000),
+        };
+    }
+    return {
+        status,
+        async login(input) {
+            log("info", `开始登录：${input.username}`);
+            const cookies = await forumLogin({
+                username: input.username,
+                password: input.password,
+            });
+            const account = {
+                id: newAccountId(),
+                label: input.label ?? input.username,
+                site: input.site,
+                cookies: {
+                    ipbMemberId: cookies.ipbMemberId,
+                    ipbPassHash: cookies.ipbPassHash,
+                    igneous: "",
+                    ...(cookies.ipbSessionId === undefined
+                        ? {}
+                        : { ipbSessionId: cookies.ipbSessionId }),
+                },
+                igneousUpdatedAt: null,
+            };
+            const completed = await withIgneous(account);
+            await persistAccount(completed, true);
+            await probe();
+            log("info", `登录完成：${completed.label}`);
+            return status();
+        },
+        async logout() {
+            const auth = ctx.auth.get();
+            const account = activeAccount(auth);
+            if (account === null) {
+                return status();
+            }
+            // 只清 Cookie 与当前标记，保留账号条目便于再次登录
+            const cleared = {
+                ...account,
+                cookies: { ipbMemberId: "", ipbPassHash: "", igneous: "" },
+                igneousUpdatedAt: null,
+            };
+            await ctx.auth.patch({
+                accounts: upsertAccount(auth.accounts, cleared),
+                activeAccountId: account.id === auth.activeAccountId ? null : auth.activeAccountId,
+            });
+            log("info", "已清除当前账号的登录态");
+            return status();
+        },
+        async refreshIgneous() {
+            const auth = ctx.auth.get();
+            const account = activeAccount(auth);
+            if (account === null) {
+                throw new Error("尚未登录");
+            }
+            const refreshed = { ...account, cookies: { ...account.cookies, igneous: "" } };
+            const completed = await withIgneous(refreshed);
+            if (!isIgneousValue(completed.cookies.igneous)) {
+                throw new Error("未取到 igneous：当前出口节点可能被上游拒绝");
+            }
+            await persistAccount(completed, true);
+            return status();
+        },
+        probeExAccess: probe,
+        listAccounts() {
+            const auth = ctx.auth.get();
+            return auth.accounts.map((account) => summarize(auth, account));
+        },
+        async createAccount(input) {
+            if (!isCompleteCookies(input.cookies)) {
+                throw new Error("Cookie 不完整：ipb_member_id、ipb_pass_hash、igneous 均必填");
+            }
+            const now = Math.floor(Date.now() / 1000);
+            const account = {
+                id: newAccountId(),
+                label: input.label,
+                site: input.site,
+                cookies: {
+                    ipbMemberId: input.cookies.ipbMemberId,
+                    ipbPassHash: input.cookies.ipbPassHash,
+                    igneous: input.cookies.igneous,
+                    ...(input.cookies.ipbSessionId === undefined
+                        ? {}
+                        : { ipbSessionId: input.cookies.ipbSessionId }),
+                },
+                igneousUpdatedAt: now,
+                ...(input.apiKey === undefined ? {} : { apiKey: input.apiKey }),
+            };
+            await persistAccount(account, ctx.auth.get().activeAccountId === null);
+            return summarize(ctx.auth.get(), account);
+        },
+        async updateAccount(id, patch) {
+            const auth = ctx.auth.get();
+            const existing = auth.accounts.find((item) => item.id === id);
+            if (existing === undefined) {
+                throw new Error(`账号不存在：${id}`);
+            }
+            const next = {
+                ...existing,
+                ...(patch.label === undefined ? {} : { label: patch.label }),
+                ...(patch.apiKey === undefined ? {} : { apiKey: patch.apiKey }),
+                ...(patch.cookies === undefined
+                    ? {}
+                    : {
+                        cookies: { ...existing.cookies, ...cleanCookies(patch.cookies) },
+                        igneousUpdatedAt: patch.cookies.igneous === undefined || patch.cookies.igneous === ""
+                            ? existing.igneousUpdatedAt
+                            : Math.floor(Date.now() / 1000),
+                    }),
+            };
+            await persistAccount(next, false);
+            return summarize(ctx.auth.get(), next);
+        },
+        async removeAccount(id) {
+            const auth = ctx.auth.get();
+            const remaining = removeFromList(auth.accounts, id);
+            if (remaining.length === auth.accounts.length) {
+                return false;
+            }
+            await ctx.auth.patch({
+                accounts: remaining,
+                activeAccountId: auth.activeAccountId === id ? null : auth.activeAccountId,
+            });
+            log("info", `账号已删除：${id}`);
+            return true;
+        },
+        async activateAccount(id) {
+            const auth = ctx.auth.get();
+            if (!auth.accounts.some((item) => item.id === id)) {
+                throw new Error(`账号不存在：${id}`);
+            }
+            await ctx.auth.patch({ activeAccountId: id });
+            log("info", `已切换账号：${id}`);
+            return status();
+        },
+        onChange(listener) {
+            listeners.add(listener);
+            return () => {
+                listeners.delete(listener);
+            };
+        },
+    };
+}
+function summarize(auth, account) {
+    return {
+        id: account.id,
+        label: account.label,
+        site: account.site,
+        active: activeAccount(auth)?.id === account.id,
+        igneousUpdatedAt: account.igneousUpdatedAt,
+        hasApiKey: account.apiKey !== undefined,
+    };
+}
+/** 只接受非空字段，避免把 undefined 覆盖进已有凭据 */
+function cleanCookies(cookies) {
+    const out = {};
+    if (cookies.ipbMemberId !== undefined) {
+        out.ipbMemberId = cookies.ipbMemberId;
+    }
+    if (cookies.ipbPassHash !== undefined) {
+        out.ipbPassHash = cookies.ipbPassHash;
+    }
+    if (cookies.igneous !== undefined) {
+        out.igneous = cookies.igneous;
+    }
+    if (cookies.ipbSessionId !== undefined) {
+        out.ipbSessionId = cookies.ipbSessionId;
+    }
+    return out;
+}

package/dist/services/config-service.js

@@ -0,0 +1,227 @@
+/*
+ * 配置服务：配置层之上的语义与装配。
+ * 负责内部配置与线上 DTO 的映射、跨字段校验、脱敏与变更广播，不处理 HTTP 细节。
+ * 结构校验（类型、范围）由 config/validate.ts 负责，此层只管跨字段规则。
+ */
+import { ConfigInvalidError, activeAccount, igneousAgeDays, isIgneousStale, } from "../config/index.js";
+/** 线上 DTO 中不落到配置文件里的字段：由服务层计算，patch 时忽略。 */
+const WIRE_ONLY_PATHS = ["schemaVersion", "network.proxy.hasCredentials"];
+export function createConfigService(ctx) {
+    const listeners = new Set();
+    function snapshot() {
+        return {
+            setting: toWireSetting(ctx.user.get(), ctx.auth.get()),
+            origins: collectOrigins(ctx.user),
+        };
+    }
+    ctx.user.onChange(() => {
+        const next = snapshot();
+        for (const listener of listeners) {
+            try {
+                listener(next);
+            }
+            catch {
+                // 单个订阅者异常不影响其余订阅者。
+            }
+        }
+    });
+    return {
+        snapshot,
+        async patchUserSetting(patch) {
+            const internal = toInternalPatch(patch);
+            if (Object.keys(internal).length > 0) {
+                const issues = validateSemantics(mergeSettings(ctx.user.get(), internal));
+                if (issues.length > 0) {
+                    throw new ConfigInvalidError(issues);
+                }
+                await ctx.user.patch(internal);
+            }
+            return snapshot();
+        },
+        pathsInfo() {
+            return {
+                configDir: ctx.paths.configDir,
+                dataDir: ctx.paths.dataDir,
+                cacheDir: ctx.paths.cacheDir,
+                sources: {
+                    configDir: ctx.paths.sources.configDir,
+                    dataDir: ctx.paths.sources.dataDir,
+                    cacheDir: ctx.paths.sources.cacheDir,
+                },
+            };
+        },
+        authStatus() {
+            const auth = ctx.auth.get();
+            const account = activeAccount(auth);
+            const activeAccountSummary = account === null
+                ? null
+                : {
+                    id: account.id,
+                    label: account.label,
+                    site: account.site,
+                    active: true,
+                    igneousUpdatedAt: account.igneousUpdatedAt,
+                    hasApiKey: account.apiKey !== undefined,
+                };
+            return {
+                loggedIn: account !== null,
+                activeAccount: activeAccountSummary,
+                accountCount: auth.accounts.length,
+                igneousAgeDays: igneousAgeDays(account),
+                igneousStale: isIgneousStale(account),
+                // 里站可达性尚未探测，接入上游请求后填充。
+                exAccessible: null,
+            };
+        },
+        onChange(listener) {
+            listeners.add(listener);
+            return () => {
+                listeners.delete(listener);
+            };
+        },
+    };
+}
+/** 内部配置 -> 线上 DTO。hasCredentials 由 auth 层提供，代理凭据本身不回传。 */
+function toWireSetting(setting, auth) {
+    return {
+        schemaVersion: setting.schemaVersion,
+        locale: setting.locale,
+        preferredSite: setting.preferredSite,
+        network: {
+            requestIntervalMs: setting.network.requestIntervalMs,
+            maxSequentialRequests: setting.network.maxSequentialRequests,
+            requestTimeoutMs: setting.network.requestTimeoutMs,
+            proxy: {
+                enabled: setting.network.proxy.enabled,
+                protocol: setting.network.proxy.protocol,
+                host: setting.network.proxy.host,
+                port: setting.network.proxy.port,
+                hasCredentials: auth.proxyAuth.username !== "",
+            },
+        },
+        viewer: {
+            mode: setting.viewer.mode,
+            imageQuality: setting.viewer.imageQuality,
+            preloadCount: setting.viewer.preloadCount,
+            maxCacheMb: setting.viewer.maxCacheMb,
+            maxConcurrentLoads: setting.viewer.maxConcurrentLoads,
+            autoplay: {
+                enabled: setting.viewer.autoplay.enabled,
+                intervalSeconds: setting.viewer.autoplay.intervalSeconds,
+                loop: setting.viewer.autoplay.loop,
+            },
+        },
+        translate: {
+            tags: setting.translate.tags,
+        },
+        safety: {
+            hintEnabled: setting.safety.hintEnabled,
+            url: setting.safety.url,
+        },
+        download: {
+            directory: setting.download.directory,
+            keepArchive: setting.download.keepArchive,
+            preferredResolution: setting.download.preferredResolution,
+            concurrency: setting.download.concurrency,
+        },
+        log: {
+            enabled: setting.log.enabled,
+            directory: setting.log.directory,
+        },
+        ui: {
+            theme: setting.ui.theme,
+            thumbnailSize: setting.ui.thumbnailSize,
+            pageSize: setting.ui.pageSize,
+            cachedGalleries: setting.ui.cachedGalleries,
+        },
+    };
+}
+/** 线上 patch -> 内部 patch：剔除只读字段，其余原样深拷贝。 */
+function toInternalPatch(patch) {
+    const copy = structuredClone(patch);
+    for (const path of WIRE_ONLY_PATHS) {
+        removePath(copy, path);
+    }
+    return copy;
+}
+function removePath(target, path) {
+    const keys = path.split(".");
+    const last = keys.pop();
+    if (last === undefined) {
+        return;
+    }
+    let current = target;
+    for (const key of keys) {
+        if (current === null || typeof current !== "object" || Array.isArray(current)) {
+            return;
+        }
+        current = current[key];
+    }
+    if (current !== null && typeof current === "object" && !Array.isArray(current)) {
+        delete current[last];
+    }
+}
+/** 出现在文件里的字段记为 file，其余记为 default。env / cli 只影响目录，不参与此处。 */
+function collectOrigins(store) {
+    const origins = {};
+    walkOrigins(store.raw(), "", origins);
+    return origins;
+}
+/** 递归遍历嵌套对象，每层都记一条，前端按点分路径取用。 */
+function walkOrigins(node, prefix, out) {
+    if (node === null || typeof node !== "object" || Array.isArray(node)) {
+        return;
+    }
+    for (const [key, value] of Object.entries(node)) {
+        const path = prefix === "" ? key : `${prefix}.${key}`;
+        out[path] = "file";
+        walkOrigins(value, path, out);
+    }
+}
+/** 在现有配置上叠加 patch，仅用于校验，不写盘 */
+function mergeSettings(base, patch) {
+    const merged = structuredClone(base);
+    mergeInto(merged, patch);
+    return merged;
+}
+function mergeInto(target, patch) {
+    for (const [key, value] of Object.entries(patch)) {
+        if (value === null || typeof value !== "object" || Array.isArray(value)) {
+            target[key] = value;
+            continue;
+        }
+        const current = target[key];
+        if (current === null || typeof current !== "object" || Array.isArray(current)) {
+            target[key] = structuredClone(value);
+            continue;
+        }
+        mergeInto(current, value);
+    }
+}
+/** 跨字段规则。 */
+function validateSemantics(setting) {
+    const issues = [];
+    const directory = setting.download.directory;
+    if (directory !== "" && !isAbsolutePath(directory)) {
+        issues.push({
+            path: "download.directory",
+            code: "conflict",
+            message: "需为绝对路径，或留空",
+        });
+    }
+    if (setting.network.proxy.enabled && setting.network.proxy.host.trim() === "") {
+        issues.push({ path: "network.proxy.host", code: "missing", message: "启用代理时不能为空" });
+    }
+    if (setting.viewer.preloadCount > setting.ui.pageSize) {
+        issues.push({
+            path: "viewer.preloadCount",
+            code: "conflict",
+            message: "不应超过每页条目数",
+        });
+    }
+    return issues;
+}
+/** POSIX 以 / 开头，Windows 为盘符:\ 或 UNC */
+function isAbsolutePath(value) {
+    return value.startsWith("/") || /^[A-Za-z]:[\\/]/.test(value) || value.startsWith("\\\\");
+}

package/dist/services/detail-cache.js

@@ -0,0 +1,193 @@
+/*
+ * 画廊详情缓存。
+ * 详情页要的三样东西都存这里：信息（detail）、封面（第 1 页的图片地址）、缩略图（预览图分组）。
+ * 内存 LRU，条数上限来自设置（ui.cachedGalleries，0 表示不缓存），超出就丢最久没用的那本。
+ * 再次进入同一画廊时一个上游请求都不发。
+ *
+ * 封面存的是 showpage 给的图片地址，地址里的 keystamp 会过期，因此封面单独带 10 分钟有效期。
+ * 信息和缩略图是静态内容，只受条数上限约束。
+ * 需要「一定要新」的调用方（更新检查、收藏挪版本、进入阅读前的存在性检查）传 fresh，
+ * 跳过读取但仍然写回缓存。
+ *
+ * 同一个键在途的读只发一次上游。多开几个页面同时看同一本，
+ * 或者详情页与播放器同时进同一本时，同一份东西不会重复请求很多遍。
+ */
+/** 封面地址的有效期。keystamp 过期后图片会 403，因此宁可重新解析一次 */
+const COVER_TTL_MS = 10 * 60 * 1000;
+/** 缓存空着时用来估体积的单个画廊大小，取自实际详情（含标签、评论、预览）的量级。 */
+const NOMINAL_BYTES = 24 * 1024;
+function keyOf(gid, token) {
+    return `${gid}:${token}`;
+}
+/** 条目占多少字节：按 JSON 文本长度估，够用来显示「约 X MB」 */
+function sizeOf(entry) {
+    let bytes = entry.detail === null ? 0 : JSON.stringify(entry.detail).length;
+    if (entry.cover !== null) {
+        bytes += JSON.stringify(entry.cover.page).length;
+    }
+    for (const set of entry.previews.values()) {
+        bytes += JSON.stringify(set).length;
+    }
+    return bytes;
+}
+export function createDetailCache(options) {
+    const log = options.logger ?? (() => undefined);
+    /** Map 的插入顺序当 LRU 用：命中就删了再放回尾部。 */
+    const entries = new Map();
+    function limit() {
+        const value = options.limit();
+        return Number.isFinite(value) && value > 0 ? Math.floor(value) : 0;
+    }
+    function touch(key, entry) {
+        entries.delete(key);
+        entries.set(key, entry);
+    }
+    /** 超上限就丢最久没用的。设置调小后下一次访问就会收敛。 */
+    function trim() {
+        const max = limit();
+        if (entries.size <= max) {
+            return;
+        }
+        for (const [key] of entries) {
+            if (entries.size <= max) {
+                break;
+            }
+            entries.delete(key);
+        }
+        log("info", `详情缓存超出上限（${max}），已丢弃最久未用的条目`);
+    }
+    /** 上限为 0 时缓存不该继续占内存，直接清空。条数调小后也一样收敛。 */
+    function prune() {
+        const max = limit();
+        if (max === 0) {
+            if (entries.size > 0) {
+                entries.clear();
+            }
+            return;
+        }
+        trim();
+    }
+    function entryOf(gid, token) {
+        const key = keyOf(gid, token);
+        const entry = entries.get(key);
+        if (entry === undefined) {
+            return null;
+        }
+        if (entry.detail === null && entry.cover === null && entry.previews.size === 0) {
+            entries.delete(key);
+            return null;
+        }
+        touch(key, entry);
+        return entry;
+    }
+    /*
+     * 在途的读。同一个键的并发调用共用一次上游请求，完成后立刻从表里摘掉。
+     * 共用的是「正在向上游要」这件事，因此 fresh 的调用方也跟着用，不算吃了旧数据。
+     */
+    const inflight = new Map();
+    function share(key, load) {
+        const running = inflight.get(key);
+        if (running !== undefined) {
+            return running;
+        }
+        const task = load().finally(() => {
+            inflight.delete(key);
+        });
+        inflight.set(key, task);
+        return task;
+    }
+    /** 拿一份可写的条目。不存在的就新建并占位，写回时再 trim。 */
+    function writable(gid, token) {
+        const existing = entryOf(gid, token);
+        if (existing !== null) {
+            return existing;
+        }
+        const fresh = {
+            at: Date.now(),
+            detail: null,
+            cover: null,
+            previews: new Map(),
+            bytes: 0,
+        };
+        entries.set(keyOf(gid, token), fresh);
+        return fresh;
+    }
+    function statsOf() {
+        prune();
+        let bytes = 0;
+        for (const entry of entries.values()) {
+            bytes += entry.bytes;
+        }
+        return {
+            entries: entries.size,
+            max: limit(),
+            bytes,
+            perGallery: entries.size === 0
+                ? NOMINAL_BYTES
+                : Math.max(1024, Math.round(bytes / entries.size)),
+        };
+    }
+    return {
+        async detail(gid, token, load, fresh = false) {
+            const max = limit();
+            if (max === 0) {
+                prune();
+                return share(`detail:${keyOf(gid, token)}`, load);
+            }
+            const cached = fresh ? null : entryOf(gid, token)?.detail;
+            if (cached !== undefined && cached !== null) {
+                return cached;
+            }
+            const detail = await share(`detail:${keyOf(gid, token)}`, load);
+            const entry = writable(gid, token);
+            entry.detail = detail;
+            entry.at = Date.now();
+            entry.bytes = sizeOf(entry);
+            trim();
+            return detail;
+        },
+        async cover(gid, token, load, fresh = false) {
+            const max = limit();
+            if (max === 0) {
+                prune();
+                return share(`cover:${keyOf(gid, token)}`, load);
+            }
+            const entry = fresh ? null : entryOf(gid, token);
+            const cached = entry?.cover;
+            if (cached !== undefined && cached !== null && Date.now() - cached.at < COVER_TTL_MS) {
+                return cached.page;
+            }
+            const page = await share(`cover:${keyOf(gid, token)}`, load);
+            const target = writable(gid, token);
+            target.cover = { at: Date.now(), page };
+            target.at = Date.now();
+            target.bytes = sizeOf(target);
+            trim();
+            return page;
+        },
+        async previews(gid, token, index, load, fresh = false) {
+            const max = limit();
+            if (max === 0) {
+                prune();
+                return share(`previews:${keyOf(gid, token)}:${index}`, load);
+            }
+            const cached = fresh ? undefined : entryOf(gid, token)?.previews.get(index);
+            if (cached !== undefined) {
+                return cached;
+            }
+            const set = await share(`previews:${keyOf(gid, token)}:${index}`, load);
+            const entry = writable(gid, token);
+            entry.previews.set(index, set);
+            entry.at = Date.now();
+            entry.bytes = sizeOf(entry);
+            trim();
+            return set;
+        },
+        stats: statsOf,
+        clear() {
+            entries.clear();
+            inflight.clear();
+            return statsOf();
+        },
+    };
+}