rn-update-cli 1.0.0

package/lib/utils/hermes-literals.d.ts

@@ -0,0 +1,64 @@
+export type LiteralValue = {
+    kind: 'null' | 'true' | 'false' | 'undefined';
+} | {
+    kind: 'number';
+    value: number;
+} | {
+    kind: 'int';
+    value: number;
+} | {
+    kind: 'string';
+    id: number;
+};
+/** The literal buffers of an HBC file, in one of the two layouts. */
+export type LiteralBuffers = {
+    layout: 'split';
+    version: number;
+    array: Buffer;
+    objectKeys: Buffer;
+    objectValues: Buffer;
+} | {
+    layout: 'shaped';
+    version: number;
+    values: Buffer;
+    objectKeys: Buffer;
+    shapes: Buffer;
+};
+/**
+ * Read only the literal buffers of an HBC file (header + three byte ranges,
+ * never the whole file). Null for a file whose layout is unknown: the caller
+ * then falls back to comparing the dumped buffers as a whole.
+ */
+export declare function readLiteralBuffers(file: string): Promise<LiteralBuffers | null>;
+/**
+ * Decode `count` literal values starting at byte `offset`. Null when the
+ * offset or a run reaches outside the buffer or a tag type is unknown; the
+ * caller reports that as a difference rather than guessing. `layout` decides
+ * what type 6 means (see the file comment).
+ */
+export declare function decodeSerializedLiterals(buffer: Buffer, offset: number, count: number, layout?: LiteralBuffers['layout']): LiteralValue[] | null;
+/**
+ * One literal as text, string ids resolved through the dump's string table
+ * (an unknown id stays visible as `?id`). Doubles keep their exact bits in
+ * the text so -0 and 0, or two NaNs, never collide by accident.
+ */
+export declare function renderLiteral(value: LiteralValue, strings: Map<number, string>): string;
+/**
+ * Decodes the literals an instruction refers to, for one side of a compare.
+ * Returns rendered entries, or null when the offset cannot be decoded.
+ */
+export declare class LiteralResolver {
+    private readonly buffers;
+    private readonly strings;
+    constructor(buffers: LiteralBuffers, strings: Map<number, string>);
+    private decode;
+    get layout(): LiteralBuffers['layout'];
+    array(offset: number, count: number): string[] | null;
+    objectKeys(offset: number, count: number): string[] | null;
+    objectValues(offset: number, count: number): string[] | null;
+    /** Shape table entry (HBC v98); null out of range or in the split layout. */
+    shape(index: number): {
+        keyOffset: number;
+        count: number;
+    } | null;
+}

package/lib/utils/hermes-literals.js

@@ -0,0 +1,260 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LiteralResolver = void 0;
+exports.readLiteralBuffers = readLiteralBuffers;
+exports.decodeSerializedLiterals = decodeSerializedLiterals;
+exports.renderLiteral = renderLiteral;
+/**
+ * [INPUT]: 依赖 HBC 头部布局解析与二进制文件句柄，读取 Hermes 字面量缓冲区和 v98 shape 表
+ * [OUTPUT]: 对外提供字面量缓冲区读取、SLP 值解码、文本渲染与按指令定位的 LiteralResolver
+ * [POS]: CLI Hermes 等价校验的二进制语义层，屏蔽 split/shaped HBC 布局差异，不负责反汇编进程
+ */
+/**
+ * Binary literal buffers of an HBC file, for the Hermes base equivalence
+ * check (see docs/hermes-base-verification.md §3.2).
+ *
+ * `NewArrayWithBuffer` / `NewObjectWithBuffer` reference their literals by
+ * *byte offset* into the serialized literal buffers. The text dump prints
+ * those buffers entry by entry without byte positions, so the offsets in the
+ * instructions cannot be mapped to entries from the dump alone — and a delta
+ * build may lay the buffers out differently (deduplicated runs, different
+ * order) while every instruction still resolves to the same literals. Reading
+ * the buffers from the file and decoding at each instruction's offset
+ * compares what the instruction actually builds.
+ *
+ * Serialized literal format (hermes SerializedLiteralGenerator): runs of
+ * same-typed values. Tag byte: bits 6..4 = type, bit 7 = "length continues in
+ * the next byte", bits 3..0 = low 4 bits of the run length (high 8 bits in
+ * the next byte when bit 7 is set). Values follow the tag, fixed width per
+ * type: none (null/true/false), 8-byte little-endian double, 4/2/1-byte
+ * string id, 4-byte little-endian int32. HBC v98 reuses type 6 (the 1-byte
+ * string id before) for `undefined`, which takes no value bytes; string ids
+ * there are always 2 or 4 bytes wide.
+ *
+ * Two file layouts use that format:
+ * - HBC v87–96 (`split`): arrayBuffer, objKeyBuffer, objValueBuffer.
+ *   `NewArrayWithBuffer dst, sizeHint, count, arrayOffset`;
+ *   `NewObjectWithBuffer dst, sizeHint, count, keyOffset, valueOffset`.
+ * - HBC v98 (`shaped`): literalValueBuffer (array elements and object values
+ *   alike), objKeyBuffer, objShapeTable (8-byte entries: keyOffset u32,
+ *   numProps u32). `NewArrayWithBuffer dst, sizeHint, count, valueOffset`;
+ *   `NewObjectWithBuffer dst, shapeIndex, valueOffset` and
+ *   `NewObjectWithBufferAndParent dst, parent, shapeIndex, valueOffset`.
+ */
+const promises_1 = require("node:fs/promises");
+const hbcTransform_1 = require("./hbcTransform");
+const HBC_HEADER_SIZE = 128;
+const TAG_TYPE_MASK = 0x70;
+const TAG_LENGTH_CONTINUES = 0x80;
+const TAG_LENGTH_LOW = 0x0f;
+var Tag;
+(function (Tag) {
+    Tag[Tag["Null"] = 0] = "Null";
+    Tag[Tag["True"] = 16] = "True";
+    Tag[Tag["False"] = 32] = "False";
+    Tag[Tag["Number"] = 48] = "Number";
+    Tag[Tag["LongString"] = 64] = "LongString";
+    Tag[Tag["ShortString"] = 80] = "ShortString";
+    /** HBC ≤96: 1-byte string id; HBC v98: `undefined` */
+    Tag[Tag["ByteStringOrUndefined"] = 96] = "ByteStringOrUndefined";
+    Tag[Tag["Integer"] = 112] = "Integer";
+})(Tag || (Tag = {}));
+const SHAPE_ENTRY_SIZE = 8;
+/**
+ * Read only the literal buffers of an HBC file (header + three byte ranges,
+ * never the whole file). Null for a file whose layout is unknown: the caller
+ * then falls back to comparing the dumped buffers as a whole.
+ */
+async function readLiteralBuffers(file) {
+    const handle = await (0, promises_1.open)(file, 'r');
+    try {
+        const { size } = await handle.stat();
+        if (size < HBC_HEADER_SIZE)
+            return null;
+        const header = Buffer.alloc(HBC_HEADER_SIZE);
+        const read = await handle.read(header, 0, HBC_HEADER_SIZE, 0);
+        if (read.bytesRead !== HBC_HEADER_SIZE)
+            return null;
+        const resolved = (0, hbcTransform_1.resolveHbcSections)(header, size);
+        if (!resolved)
+            return null;
+        const readRanges = async (names) => {
+            const ranges = names.map((name) => resolved.sections.get(name));
+            if (ranges.some((r) => !r))
+                return null;
+            const bufs = await Promise.all(ranges.map(async (r) => {
+                const buf = Buffer.alloc(r.size);
+                if (r.size === 0)
+                    return buf;
+                const { bytesRead } = await handle.read(buf, 0, r.size, r.start);
+                return bytesRead === r.size ? buf : null;
+            }));
+            return bufs.some((b) => !b) ? null : bufs;
+        };
+        const { version } = resolved;
+        if (resolved.sections.has('objShapeTable')) {
+            const bufs = await readRanges([
+                'literalValueBuffer',
+                'objKeyBuffer',
+                'objShapeTable',
+            ]);
+            if (!bufs)
+                return null;
+            const [values, objectKeys, shapes] = bufs;
+            return { layout: 'shaped', version, values, objectKeys, shapes };
+        }
+        const bufs = await readRanges([
+            'arrayBuffer',
+            'objKeyBuffer',
+            'objValueBuffer',
+        ]);
+        if (!bufs)
+            return null;
+        const [array, objectKeys, objectValues] = bufs;
+        return { layout: 'split', version, array, objectKeys, objectValues };
+    }
+    finally {
+        await handle.close();
+    }
+}
+/**
+ * Decode `count` literal values starting at byte `offset`. Null when the
+ * offset or a run reaches outside the buffer or a tag type is unknown; the
+ * caller reports that as a difference rather than guessing. `layout` decides
+ * what type 6 means (see the file comment).
+ */
+function decodeSerializedLiterals(buffer, offset, count, layout = 'split') {
+    const values = [];
+    let pos = offset;
+    while (values.length < count) {
+        if (pos < 0 || pos >= buffer.length)
+            return null;
+        const tag = buffer[pos++];
+        let length = tag & TAG_LENGTH_LOW;
+        if (tag & TAG_LENGTH_CONTINUES) {
+            if (pos >= buffer.length)
+                return null;
+            length = (length << 8) | buffer[pos++];
+        }
+        const type = tag & TAG_TYPE_MASK;
+        for (let i = 0; i < length && values.length < count; i++) {
+            switch (type) {
+                case Tag.Null:
+                    values.push({ kind: 'null' });
+                    break;
+                case Tag.True:
+                    values.push({ kind: 'true' });
+                    break;
+                case Tag.False:
+                    values.push({ kind: 'false' });
+                    break;
+                case Tag.Number:
+                    if (pos + 8 > buffer.length)
+                        return null;
+                    values.push({ kind: 'number', value: buffer.readDoubleLE(pos) });
+                    pos += 8;
+                    break;
+                case Tag.LongString:
+                    if (pos + 4 > buffer.length)
+                        return null;
+                    values.push({ kind: 'string', id: buffer.readUInt32LE(pos) });
+                    pos += 4;
+                    break;
+                case Tag.ShortString:
+                    if (pos + 2 > buffer.length)
+                        return null;
+                    values.push({ kind: 'string', id: buffer.readUInt16LE(pos) });
+                    pos += 2;
+                    break;
+                case Tag.ByteStringOrUndefined:
+                    if (layout === 'shaped') {
+                        values.push({ kind: 'undefined' });
+                        break;
+                    }
+                    if (pos + 1 > buffer.length)
+                        return null;
+                    values.push({ kind: 'string', id: buffer[pos] });
+                    pos += 1;
+                    break;
+                case Tag.Integer:
+                    if (pos + 4 > buffer.length)
+                        return null;
+                    values.push({ kind: 'int', value: buffer.readInt32LE(pos) });
+                    pos += 4;
+                    break;
+                default:
+                    return null;
+            }
+        }
+    }
+    return values;
+}
+/**
+ * One literal as text, string ids resolved through the dump's string table
+ * (an unknown id stays visible as `?id`). Doubles keep their exact bits in
+ * the text so -0 and 0, or two NaNs, never collide by accident.
+ */
+function renderLiteral(value, strings) {
+    switch (value.kind) {
+        case 'null':
+        case 'true':
+        case 'false':
+        case 'undefined':
+            return value.kind;
+        case 'int':
+            return `[int ${value.value}]`;
+        case 'number': {
+            const bits = Buffer.alloc(8);
+            bits.writeDoubleLE(value.value);
+            return `[double ${Object.is(value.value, -0) ? '-0' : String(value.value)}#${bits.toString('hex')}]`;
+        }
+        case 'string': {
+            const text = strings.get(value.id);
+            return `[String ${text === undefined ? `?${value.id}` : JSON.stringify(text)}]`;
+        }
+    }
+}
+/**
+ * Decodes the literals an instruction refers to, for one side of a compare.
+ * Returns rendered entries, or null when the offset cannot be decoded.
+ */
+class LiteralResolver {
+    buffers;
+    strings;
+    constructor(buffers, strings) {
+        this.buffers = buffers;
+        this.strings = strings;
+    }
+    decode(buffer, offset, count) {
+        const values = decodeSerializedLiterals(buffer, offset, count, this.buffers.layout);
+        return values ? values.map((v) => renderLiteral(v, this.strings)) : null;
+    }
+    get layout() {
+        return this.buffers.layout;
+    }
+    array(offset, count) {
+        const b = this.buffers;
+        return this.decode(b.layout === 'split' ? b.array : b.values, offset, count);
+    }
+    objectKeys(offset, count) {
+        return this.decode(this.buffers.objectKeys, offset, count);
+    }
+    objectValues(offset, count) {
+        const b = this.buffers;
+        return this.decode(b.layout === 'split' ? b.objectValues : b.values, offset, count);
+    }
+    /** Shape table entry (HBC v98); null out of range or in the split layout. */
+    shape(index) {
+        const b = this.buffers;
+        if (b.layout !== 'shaped' || index < 0)
+            return null;
+        const at = index * SHAPE_ENTRY_SIZE;
+        if (at + SHAPE_ENTRY_SIZE > b.shapes.length)
+            return null;
+        return {
+            keyOffset: b.shapes.readUInt32LE(at),
+            count: b.shapes.readUInt32LE(at + 4),
+        };
+    }
+}
+exports.LiteralResolver = LiteralResolver;

package/lib/utils/http-helper.d.ts

@@ -0,0 +1,10 @@
+export declare function promiseAny<T>(promises: Promise<T>[]): Promise<T>;
+export declare const ping: (url: string, signal?: AbortSignal) => Promise<string | null>;
+export declare const testUrls: (urls?: string[], hedgeDelayMs?: number) => Promise<string | null>;
+export declare const isStandaloneService: () => boolean;
+/**
+ * The API base url: the env override, or the first default endpoint that
+ * answers a HEAD ping. Resolved lazily on the first API call (offline commands
+ * such as `hdiff`/`help` never ping) and memoized for the process lifetime.
+ */
+export declare const getBaseUrl: () => Promise<string>;

package/lib/utils/http-helper.js

@@ -0,0 +1,150 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getBaseUrl = exports.isStandaloneService = exports.testUrls = exports.ping = void 0;
+exports.promiseAny = promiseAny;
+/**
+ * [INPUT]: 依赖默认服务端点、RNU_SERVICE_URL 与运行时网络请求
+ * [OUTPUT]: 对外提供服务地址解析、独立服务判定、健康探测和并发竞速
+ * [POS]: CLI 网络寻址层，独立模式拒绝隐式回退到上游服务
+ */
+const constants_1 = require("./constants");
+const runtime_1 = require("./runtime");
+// const baseUrl = `http://localhost:9000`;
+// let baseUrl = SERVER.main[0];
+// const baseUrl = `https://p.reactnative.cn/api`;
+function promiseAny(promises) {
+    return new Promise((resolve, reject) => {
+        let count = 0;
+        for (const promise of promises) {
+            Promise.resolve(promise)
+                .then(resolve)
+                .catch(() => {
+                count++;
+                if (count === promises.length) {
+                    reject(new Error('All promises were rejected'));
+                }
+            });
+        }
+    });
+}
+const ping = async (url, signal) => {
+    let timer;
+    try {
+        return await Promise.race([
+            (0, runtime_1.runtimeFetch)(url, {
+                method: 'HEAD',
+                signal,
+            }).then(({ status }) => {
+                if (status === 200) {
+                    return url;
+                }
+                throw new Error('ping failed');
+            }),
+            new Promise((_, reject) => {
+                timer = setTimeout(() => {
+                    reject(new Error('ping timeout'));
+                }, 5000);
+            }),
+        ]);
+    }
+    finally {
+        // clear the timer so it doesn't keep the process alive for 5s
+        clearTimeout(timer);
+    }
+};
+exports.ping = ping;
+const HEDGE_DELAY_MS = 250;
+// Hedged race instead of pinging every endpoint at once: the preferred (first)
+// url is tried immediately, each following one only after HEDGE_DELAY_MS of
+// silence (or immediately when a previous ping failed). The first success wins
+// and the losing pings are aborted. Falls back to urls[0] when all fail.
+const testUrls = async (urls, hedgeDelayMs = HEDGE_DELAY_MS) => {
+    if (!urls?.length) {
+        return null;
+    }
+    return new Promise((resolve) => {
+        const controllers = [];
+        let nextIndex = 0;
+        let pending = 0;
+        let settled = false;
+        let hedgeTimer;
+        const finish = (winner, winnerController) => {
+            if (settled) {
+                return;
+            }
+            settled = true;
+            if (hedgeTimer) {
+                clearTimeout(hedgeTimer);
+            }
+            for (const controller of controllers) {
+                if (controller !== winnerController) {
+                    controller.abort();
+                }
+            }
+            resolve(winner ?? urls[0]);
+        };
+        const launchNext = () => {
+            if (hedgeTimer) {
+                clearTimeout(hedgeTimer);
+                hedgeTimer = undefined;
+            }
+            if (settled || nextIndex >= urls.length) {
+                return;
+            }
+            const url = urls[nextIndex++];
+            const controller = new AbortController();
+            controllers.push(controller);
+            pending++;
+            (0, exports.ping)(url, controller.signal).then(() => finish(url, controller), () => {
+                pending--;
+                if (settled) {
+                    return;
+                }
+                if (nextIndex < urls.length) {
+                    // A failure frees its slot: hedge the next url right away.
+                    launchNext();
+                }
+                else if (pending === 0) {
+                    finish(null);
+                }
+            });
+            if (!settled && nextIndex < urls.length) {
+                hedgeTimer = setTimeout(launchNext, hedgeDelayMs);
+            }
+        };
+        launchNext();
+    });
+};
+exports.testUrls = testUrls;
+let baseUrlPromise;
+const isStandaloneService = () => Boolean(process.env.RNU_SERVICE_URL || process.env.RNU_API_MODE === 'standalone');
+exports.isStandaloneService = isStandaloneService;
+async function resolveBaseUrl() {
+    const testEndpoint = process.env.RNU_SERVICE_URL || process.env.PAKTA_REGISTRY || process.env.RNU_API;
+    if (testEndpoint) {
+        return testEndpoint.replace(/\/+$/, '');
+    }
+    if ((0, exports.isStandaloneService)()) {
+        throw new Error('独立服务必须显式配置 RNU_SERVICE_URL；CLI 不会连接上游默认地址。');
+    }
+    const ret = await (0, exports.testUrls)(constants_1.defaultEndpoints.map((url) => `${url}/status`));
+    let baseUrl = constants_1.defaultEndpoints[0];
+    if (ret) {
+        // remove /status
+        baseUrl = ret.replace('/status', '');
+    }
+    // console.log('baseUrl', baseUrl);
+    return baseUrl;
+}
+/**
+ * The API base url: the env override, or the first default endpoint that
+ * answers a HEAD ping. Resolved lazily on the first API call (offline commands
+ * such as `hdiff`/`help` never ping) and memoized for the process lifetime.
+ */
+const getBaseUrl = () => {
+    if (!baseUrlPromise) {
+        baseUrlPromise = resolveBaseUrl();
+    }
+    return baseUrlPromise;
+};
+exports.getBaseUrl = getBaseUrl;

package/lib/utils/i18n.d.ts

@@ -0,0 +1,22 @@
+/**
+ * [INPUT]: 依赖 i18next、CLI en/zh 文案资源与 RNU_LANG 环境覆盖
+ * [OUTPUT]: 对外提供 resolveLanguage 与 t，初始化 Pakta CLI 本地化资源
+ * [POS]: CLI 文案适配层，统一语言选择和模板翻译，不包含命令业务逻辑
+ */
+import en from '../locales/en';
+import zh from '../locales/zh';
+/**
+ * UI language: `RNU_LANG=en|zh` (a locale such as `zh_CN` counts by its
+ * prefix) overrides the Pakta default.
+ */
+export declare function resolveLanguage(env?: NodeJS.ProcessEnv, defaultLanguage?: 'en' | 'zh'): 'en' | 'zh';
+declare module 'i18next' {
+    interface CustomTypeOptions {
+        defaultNS: 'en';
+        resources: {
+            en: typeof en;
+            zh: typeof zh;
+        };
+    }
+}
+export declare function t(key: string, options?: any): string;

package/lib/utils/i18n.js

@@ -0,0 +1,46 @@
+"use strict";
+/**
+ * [INPUT]: 依赖 i18next、CLI en/zh 文案资源与 RNU_LANG 环境覆盖
+ * [OUTPUT]: 对外提供 resolveLanguage 与 t，初始化 Pakta CLI 本地化资源
+ * [POS]: CLI 文案适配层，统一语言选择和模板翻译，不包含命令业务逻辑
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveLanguage = resolveLanguage;
+exports.t = t;
+const i18next_1 = __importDefault(require("i18next"));
+const en_1 = __importDefault(require("../locales/en"));
+const zh_1 = __importDefault(require("../locales/zh"));
+/**
+ * UI language: `RNU_LANG=en|zh` (a locale such as `zh_CN` counts by its
+ * prefix) overrides the Pakta default.
+ */
+function resolveLanguage(env = process.env, defaultLanguage = 'zh') {
+    const override = env.RNU_LANG?.trim().toLowerCase();
+    if (override?.startsWith('zh'))
+        return 'zh';
+    if (override?.startsWith('en'))
+        return 'en';
+    return defaultLanguage;
+}
+i18next_1.default.init({
+    lng: resolveLanguage(),
+    // debug: process.env.NODE_ENV !== 'production',
+    // debug: true,
+    resources: {
+        en: {
+            translation: en_1.default,
+        },
+        zh: {
+            translation: zh_1.default,
+        },
+    },
+    interpolation: {
+        escapeValue: false,
+    },
+});
+function t(key, options) {
+    return i18next_1.default.t(key, options);
+}

package/lib/utils/index.d.ts

@@ -0,0 +1,67 @@
+import { checkPlugins } from './check-plugin';
+/**
+ * tty-table (~25 ms to load) only when a table is rendered. Bun's require of
+ * a CJS module can hand back a namespace object, so unwrap `default`.
+ */
+export declare function loadTtyTable(): typeof import('tty-table');
+/** True when prompts cannot or must not be shown. */
+export declare function isNonInteractive(env?: NodeJS.ProcessEnv, stdinIsTTY?: boolean | undefined, globalFlag?: boolean | undefined): boolean;
+export declare function question(query: string, password?: boolean): Promise<string>;
+export declare function translateOptions<T extends Record<string, unknown>>(options: T, map?: Record<string, string>): T & Record<string, unknown>;
+export declare const ApkBundleFileName: RegExp;
+export declare function getApkInfo(fn: string): Promise<{
+    versionName: string;
+    buildTime: string;
+    bundleHash: string;
+    bundleFile: Blob | Buffer<ArrayBufferLike>;
+    channel: string;
+}>;
+export declare function getAppInfo(fn: string): Promise<{
+    versionName: string | undefined;
+    buildTime: string;
+    bundleHash: string;
+    bundleFile: Buffer<ArrayBufferLike>;
+    channel: string;
+}>;
+export declare const IpaBundleFileName: RegExp;
+export declare function getIpaInfo(fn: string): Promise<{
+    versionName: string;
+    buildTime: string;
+    bundleHash: string;
+    bundleFile: Blob | Buffer<ArrayBufferLike>;
+    channel: string;
+}>;
+export declare function getAabInfo(fn: string): Promise<{
+    versionName: string;
+    buildTime: string;
+    bundleHash?: string | undefined;
+    channel: string;
+}>;
+export interface VersionCheck {
+    /** settles once the registry check has finished (or failed); never rejects */
+    done: Promise<void>;
+    /** wait for the check, but never longer than `graceMs` */
+    settle: (graceMs: number) => Promise<void>;
+    /** launch a detached self-update after the foreground command is done */
+    startAutoUpdate: () => void;
+    /**
+     * Print the "newer version available" hints if the check has completed by
+     * now; a no-op while it is still pending, when nothing is newer, and after
+     * the first call. Safe to call from a process 'exit' handler.
+     */
+    printHints: () => void;
+}
+/**
+ * Print the installed CLI / rn-update versions (and refuse or warn
+ * about unsupported client versions) immediately, without touching the
+ * network.
+ *
+ * With `wait: true` (the `-v`/`version` command) the registry is queried
+ * first and the latest versions are printed inline. Otherwise the registry
+ * check runs in the background and the returned `printHints` shows what is
+ * newer once the command is done — the command itself is never delayed by it.
+ */
+export declare function printVersionCommand({ wait, }?: {
+    wait?: boolean;
+}): Promise<VersionCheck>;
+export { checkPlugins };