feat: 초기 프로젝트 설정 및 룰.md 파일 추가

api.hyungi.net/node_modules/@pm2/io/build/main/configuration.d.ts

@@ -0,0 +1,6 @@
+export default class Configuration {
+    static configureModule(opts: any): void;
+    static findPackageJson(): string | null | undefined;
+    static init(conf: any, doNotTellPm2?: any): any;
+    static getMain(): any;
+}

api.hyungi.net/node_modules/@pm2/io/build/main/constants.d.ts

@@ -0,0 +1,5 @@
+declare const _default: {
+    METRIC_INTERVAL: number;
+};
+export default _default;
+export declare function canUseInspector(): any;

api.hyungi.net/node_modules/@pm2/io/build/main/constants.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.canUseInspector = void 0;
+const semver = require("semver");
+exports.default = {
+    METRIC_INTERVAL: 990
+};
+function canUseInspector() {
+    const isAboveNode10 = semver.satisfies(process.version, '>= 10.1.0');
+    const isAboveNode8 = semver.satisfies(process.version, '>= 8.0.0');
+    const canUseInNode8 = process.env.FORCE_INSPECTOR === '1'
+        || process.env.FORCE_INSPECTOR === 'true' || process.env.NODE_ENV === 'production';
+    return isAboveNode10 || (isAboveNode8 && canUseInNode8);
+}
+exports.canUseInspector = canUseInspector;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29uc3RhbnRzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL2NvbnN0YW50cy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7QUFBQSxpQ0FBZ0M7QUFFaEMsa0JBQWU7SUFDYixlQUFlLEVBQUUsR0FBRztDQUNyQixDQUFBO0FBRUQsU0FBZ0IsZUFBZTtJQUM3QixNQUFNLGFBQWEsR0FBRyxNQUFNLENBQUMsU0FBUyxDQUFDLE9BQU8sQ0FBQyxPQUFPLEVBQUUsV0FBVyxDQUFDLENBQUE7SUFDcEUsTUFBTSxZQUFZLEdBQUcsTUFBTSxDQUFDLFNBQVMsQ0FBQyxPQUFPLENBQUMsT0FBTyxFQUFFLFVBQVUsQ0FBQyxDQUFBO0lBQ2xFLE1BQU0sYUFBYSxHQUFHLE9BQU8sQ0FBQyxHQUFHLENBQUMsZUFBZSxLQUFLLEdBQUc7V0FDcEQsT0FBTyxDQUFDLEdBQUcsQ0FBQyxlQUFlLEtBQUssTUFBTSxJQUFJLE9BQU8sQ0FBQyxHQUFHLENBQUMsUUFBUSxLQUFLLFlBQVksQ0FBQTtJQUNwRixPQUFPLGFBQWEsSUFBSSxDQUFDLFlBQVksSUFBSSxhQUFhLENBQUMsQ0FBQTtBQUN6RCxDQUFDO0FBTkQsMENBTUMifQ==

api.hyungi.net/node_modules/@pm2/io/build/main/featureManager.d.ts

@@ -0,0 +1,14 @@
+import { IOConfig } from './pmx';
+export declare function getObjectAtPath(context: Object, path: string): any;
+export declare class FeatureManager {
+    private logger;
+    init(options: IOConfig): void;
+    get(name: string): Feature;
+    destroy(): void;
+}
+export declare class FeatureConfig {
+}
+export interface Feature {
+    init(config?: any): void;
+    destroy(): void;
+}

api.hyungi.net/node_modules/@pm2/io/build/main/featureManager.js

@@ -0,0 +1,100 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FeatureConfig = exports.FeatureManager = exports.getObjectAtPath = void 0;
+const notify_1 = require("./features/notify");
+const profiling_1 = require("./features/profiling");
+const events_1 = require("./features/events");
+const metrics_1 = require("./features/metrics");
+const dependencies_1 = require("./features/dependencies");
+const Debug = require("debug");
+function getObjectAtPath(context, path) {
+    if (path.indexOf('.') === -1 && path.indexOf('[') === -1) {
+        return context[path];
+    }
+    let crumbs = path.split(/\.|\[|\]/g);
+    let i = -1;
+    let len = crumbs.length;
+    let result;
+    while (++i < len) {
+        if (i === 0)
+            result = context;
+        if (!crumbs[i])
+            continue;
+        if (result === undefined)
+            break;
+        result = result[crumbs[i]];
+    }
+    return result;
+}
+exports.getObjectAtPath = getObjectAtPath;
+class AvailableFeature {
+}
+const availablesFeatures = [
+    {
+        name: 'notify',
+        optionsPath: '.',
+        module: notify_1.NotifyFeature
+    },
+    {
+        name: 'profiler',
+        optionsPath: 'profiling',
+        module: profiling_1.ProfilingFeature
+    },
+    {
+        name: 'events',
+        module: events_1.EventsFeature
+    },
+    {
+        name: 'metrics',
+        optionsPath: 'metrics',
+        module: metrics_1.MetricsFeature
+    },
+    {
+        name: 'dependencies',
+        module: dependencies_1.DependenciesFeature
+    }
+];
+class FeatureManager {
+    constructor() {
+        this.logger = Debug('axm:features');
+    }
+    init(options) {
+        for (let availableFeature of availablesFeatures) {
+            this.logger(`Creating feature ${availableFeature.name}`);
+            const feature = new availableFeature.module();
+            let config = undefined;
+            if (typeof availableFeature.optionsPath !== 'string') {
+                config = {};
+            }
+            else if (availableFeature.optionsPath === '.') {
+                config = options;
+            }
+            else {
+                config = getObjectAtPath(options, availableFeature.optionsPath);
+            }
+            this.logger(`Init feature ${availableFeature.name}`);
+            feature.init(config);
+            availableFeature.instance = feature;
+        }
+    }
+    get(name) {
+        const feature = availablesFeatures.find(feature => feature.name === name);
+        if (feature === undefined || feature.instance === undefined) {
+            throw new Error(`Tried to call feature ${name} which doesn't exist or wasn't initiated`);
+        }
+        return feature.instance;
+    }
+    destroy() {
+        for (let availableFeature of availablesFeatures) {
+            if (availableFeature.instance === undefined)
+                continue;
+            this.logger(`Destroy feature ${availableFeature.name}`);
+            availableFeature.instance.destroy();
+        }
+    }
+}
+exports.FeatureManager = FeatureManager;
+class FeatureConfig {
+}
+exports.FeatureConfig = FeatureConfig;
+//# sourceMappingURL=data:application/json;base64,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

api.hyungi.net/node_modules/@pm2/io/build/main/features/dependencies.d.ts

@@ -0,0 +1,7 @@
+import { Feature } from '../featureManager';
+export declare class DependenciesFeature implements Feature {
+    private transport;
+    private logger;
+    init(): void;
+    destroy(): void;
+}

api.hyungi.net/node_modules/@pm2/io/build/main/features/dependencies.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DependenciesFeature = void 0;
+const serviceManager_1 = require("../serviceManager");
+const Debug = require("debug");
+const configuration_1 = require("../configuration");
+const fs_1 = require("fs");
+class DependenciesFeature {
+    constructor() {
+        this.logger = Debug('axm:features:dependencies');
+    }
+    init() {
+        this.transport = serviceManager_1.ServiceManager.get('transport');
+        this.logger('init');
+        const pkgPath = configuration_1.default.findPackageJson();
+        if (typeof pkgPath !== 'string')
+            return this.logger('failed to found pkg.json path');
+        this.logger(`found pkg.json in ${pkgPath}`);
+        (0, fs_1.readFile)(pkgPath, (err, data) => {
+            if (err)
+                return this.logger(`failed to read pkg.json`, err);
+            try {
+                const pkg = JSON.parse(data.toString());
+                if (typeof pkg.dependencies !== 'object') {
+                    return this.logger(`failed to find deps in pkg.json`);
+                }
+                const dependencies = Object.keys(pkg.dependencies)
+                    .reduce((list, name) => {
+                    list[name] = { version: pkg.dependencies[name] };
+                    return list;
+                }, {});
+                this.logger(`collected ${Object.keys(dependencies).length} dependencies`);
+                this.transport.send('application:dependencies', dependencies);
+                this.logger('sent dependencies list');
+            }
+            catch (err) {
+                return this.logger(`failed to parse pkg.json`, err);
+            }
+        });
+    }
+    destroy() {
+        this.logger('destroy');
+    }
+}
+exports.DependenciesFeature = DependenciesFeature;
+//# sourceMappingURL=data:application/json;base64,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

api.hyungi.net/node_modules/@pm2/io/build/main/features/entrypoint.d.ts

@@ -0,0 +1,11 @@
+import { IOConfig } from '../pmx';
+export declare class Entrypoint {
+    private io;
+    constructor();
+    events(): void;
+    sensors(): void;
+    actuators(): void;
+    onStart(cb: Function): void;
+    onStop(err: Error, cb: Function, code: number, signal: string): any;
+    conf(): IOConfig | undefined;
+}

api.hyungi.net/node_modules/@pm2/io/build/main/features/entrypoint.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Entrypoint = void 0;
+const IO_KEY = Symbol.for('@pm2/io');
+class Entrypoint {
+    constructor() {
+        try {
+            this.io = global[IO_KEY].init(this.conf());
+            this.onStart(err => {
+                if (err) {
+                    console.error(err);
+                    process.exit(1);
+                }
+                this.sensors();
+                this.events();
+                this.actuators();
+                this.io.onExit((code, signal) => {
+                    this.onStop(err, () => {
+                        this.io.destroy();
+                    }, code, signal);
+                });
+                if (process && process.send)
+                    process.send('ready');
+            });
+        }
+        catch (e) {
+            if (this.io) {
+                this.io.destroy();
+            }
+            throw (e);
+        }
+    }
+    events() {
+        return;
+    }
+    sensors() {
+        return;
+    }
+    actuators() {
+        return;
+    }
+    onStart(cb) {
+        throw new Error('Entrypoint onStart() not specified');
+    }
+    onStop(err, cb, code, signal) {
+        return cb();
+    }
+    conf() {
+        return undefined;
+    }
+}
+exports.Entrypoint = Entrypoint;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZW50cnlwb2ludC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9mZWF0dXJlcy9lbnRyeXBvaW50LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7OztBQUVBLE1BQU0sTUFBTSxHQUFHLE1BQU0sQ0FBQyxHQUFHLENBQUMsU0FBUyxDQUFDLENBQUE7QUFFcEMsTUFBYSxVQUFVO0lBR3JCO1FBQ0UsSUFBSSxDQUFDO1lBQ0gsSUFBSSxDQUFDLEVBQUUsR0FBRyxNQUFNLENBQUMsTUFBTSxDQUFDLENBQUMsSUFBSSxDQUFDLElBQUksQ0FBQyxJQUFJLEVBQUUsQ0FBQyxDQUFBO1lBRTFDLElBQUksQ0FBQyxPQUFPLENBQUMsR0FBRyxDQUFDLEVBQUU7Z0JBQ2pCLElBQUksR0FBRyxFQUFFLENBQUM7b0JBQ1IsT0FBTyxDQUFDLEtBQUssQ0FBQyxHQUFHLENBQUMsQ0FBQTtvQkFDbEIsT0FBTyxDQUFDLElBQUksQ0FBQyxDQUFDLENBQUMsQ0FBQTtnQkFDakIsQ0FBQztnQkFFRCxJQUFJLENBQUMsT0FBTyxFQUFFLENBQUE7Z0JBQ2QsSUFBSSxDQUFDLE1BQU0sRUFBRSxDQUFBO2dCQUNiLElBQUksQ0FBQyxTQUFTLEVBQUUsQ0FBQTtnQkFFaEIsSUFBSSxDQUFDLEVBQUUsQ0FBQyxNQUFNLENBQUMsQ0FBQyxJQUFJLEVBQUUsTUFBTSxFQUFFLEVBQUU7b0JBQzlCLElBQUksQ0FBQyxNQUFNLENBQUMsR0FBRyxFQUFFLEdBQUcsRUFBRTt3QkFDcEIsSUFBSSxDQUFDLEVBQUUsQ0FBQyxPQUFPLEVBQUUsQ0FBQTtvQkFDbkIsQ0FBQyxFQUFFLElBQUksRUFBRSxNQUFNLENBQUMsQ0FBQTtnQkFDbEIsQ0FBQyxDQUFDLENBQUE7Z0JBRUYsSUFBSSxPQUFPLElBQUksT0FBTyxDQUFDLElBQUk7b0JBQUUsT0FBTyxDQUFDLElBQUksQ0FBQyxPQUFPLENBQUMsQ0FBQTtZQUNwRCxDQUFDLENBQUMsQ0FBQTtRQUNKLENBQUM7UUFBQyxPQUFPLENBQUMsRUFBRSxDQUFDO1lBRVgsSUFBSSxJQUFJLENBQUMsRUFBRSxFQUFFLENBQUM7Z0JBQ1osSUFBSSxDQUFDLEVBQUUsQ0FBQyxPQUFPLEVBQUUsQ0FBQTtZQUNuQixDQUFDO1lBRUQsTUFBTSxDQUFDLENBQUMsQ0FBQyxDQUFBO1FBQ1gsQ0FBQztJQUNILENBQUM7SUFFRCxNQUFNO1FBQ0osT0FBTTtJQUNSLENBQUM7SUFFRCxPQUFPO1FBQ0wsT0FBTTtJQUNSLENBQUM7SUFFRCxTQUFTO1FBQ1AsT0FBTTtJQUNSLENBQUM7SUFFRCxPQUFPLENBQUUsRUFBWTtRQUNuQixNQUFNLElBQUksS0FBSyxDQUFDLG9DQUFvQyxDQUFDLENBQUE7SUFDdkQsQ0FBQztJQUVELE1BQU0sQ0FBRSxHQUFVLEVBQUUsRUFBWSxFQUFFLElBQVksRUFBRSxNQUFjO1FBQzVELE9BQU8sRUFBRSxFQUFFLENBQUE7SUFDYixDQUFDO0lBRUQsSUFBSTtRQUNGLE9BQU8sU0FBUyxDQUFBO0lBQ2xCLENBQUM7Q0FDRjtBQTFERCxnQ0EwREMifQ==

api.hyungi.net/node_modules/@pm2/io/build/main/features/events.d.ts

@@ -0,0 +1,8 @@
+import { Feature } from '../featureManager';
+export declare class EventsFeature implements Feature {
+    private transport;
+    private logger;
+    init(): void;
+    emit(name?: string, data?: any): any;
+    destroy(): void;
+}

api.hyungi.net/node_modules/@pm2/io/build/main/features/events.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EventsFeature = void 0;
+const serviceManager_1 = require("../serviceManager");
+const Debug = require("debug");
+class EventsFeature {
+    constructor() {
+        this.logger = Debug('axm:features:events');
+    }
+    init() {
+        this.transport = serviceManager_1.ServiceManager.get('transport');
+        this.logger('init');
+    }
+    emit(name, data) {
+        if (typeof name !== 'string') {
+            console.error('event name must be a string');
+            return console.trace();
+        }
+        if (typeof data !== 'object') {
+            console.error('event data must be an object');
+            return console.trace();
+        }
+        if (data instanceof Array) {
+            console.error(`event data cannot be an array`);
+            return console.trace();
+        }
+        let inflightObj = {};
+        try {
+            inflightObj = JSON.parse(JSON.stringify(data));
+        }
+        catch (err) {
+            return console.log('Failed to serialize the event data', err.message);
+        }
+        inflightObj.__name = name;
+        if (this.transport === undefined) {
+            return this.logger('Failed to send event as transporter isnt available');
+        }
+        this.transport.send('human:event', inflightObj);
+    }
+    destroy() {
+        this.logger('destroy');
+    }
+}
+exports.EventsFeature = EventsFeature;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZXZlbnRzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL2ZlYXR1cmVzL2V2ZW50cy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7QUFBQSxzREFBa0Q7QUFHbEQsK0JBQThCO0FBRTlCLE1BQWEsYUFBYTtJQUExQjtRQUdVLFdBQU0sR0FBYSxLQUFLLENBQUMscUJBQXFCLENBQUMsQ0FBQTtJQXNDekQsQ0FBQztJQXBDQyxJQUFJO1FBQ0YsSUFBSSxDQUFDLFNBQVMsR0FBRywrQkFBYyxDQUFDLEdBQUcsQ0FBQyxXQUFXLENBQUMsQ0FBQTtRQUNoRCxJQUFJLENBQUMsTUFBTSxDQUFDLE1BQU0sQ0FBQyxDQUFBO0lBQ3JCLENBQUM7SUFFRCxJQUFJLENBQUUsSUFBYSxFQUFFLElBQVU7UUFDN0IsSUFBSSxPQUFPLElBQUksS0FBSyxRQUFRLEVBQUUsQ0FBQztZQUM3QixPQUFPLENBQUMsS0FBSyxDQUFDLDZCQUE2QixDQUFDLENBQUE7WUFDNUMsT0FBTyxPQUFPLENBQUMsS0FBSyxFQUFFLENBQUE7UUFDeEIsQ0FBQztRQUNELElBQUksT0FBTyxJQUFJLEtBQUssUUFBUSxFQUFFLENBQUM7WUFDN0IsT0FBTyxDQUFDLEtBQUssQ0FBQyw4QkFBOEIsQ0FBQyxDQUFBO1lBQzdDLE9BQU8sT0FBTyxDQUFDLEtBQUssRUFBRSxDQUFBO1FBQ3hCLENBQUM7UUFDRCxJQUFJLElBQUksWUFBWSxLQUFLLEVBQUUsQ0FBQztZQUMxQixPQUFPLENBQUMsS0FBSyxDQUFDLCtCQUErQixDQUFDLENBQUE7WUFDOUMsT0FBTyxPQUFPLENBQUMsS0FBSyxFQUFFLENBQUE7UUFDeEIsQ0FBQztRQUVELElBQUksV0FBVyxHQUFpQixFQUFFLENBQUE7UUFDbEMsSUFBSSxDQUFDO1lBQ0gsV0FBVyxHQUFHLElBQUksQ0FBQyxLQUFLLENBQUMsSUFBSSxDQUFDLFNBQVMsQ0FBQyxJQUFJLENBQUMsQ0FBQyxDQUFBO1FBQ2hELENBQUM7UUFBQyxPQUFPLEdBQUcsRUFBRSxDQUFDO1lBQ2IsT0FBTyxPQUFPLENBQUMsR0FBRyxDQUFDLG9DQUFvQyxFQUFFLEdBQUcsQ0FBQyxPQUFPLENBQUMsQ0FBQTtRQUN2RSxDQUFDO1FBRUQsV0FBVyxDQUFDLE1BQU0sR0FBRyxJQUFJLENBQUE7UUFDekIsSUFBSSxJQUFJLENBQUMsU0FBUyxLQUFLLFNBQVMsRUFBRSxDQUFDO1lBQ2pDLE9BQU8sSUFBSSxDQUFDLE1BQU0sQ0FBQyxvREFBb0QsQ0FBQyxDQUFBO1FBQzFFLENBQUM7UUFDRCxJQUFJLENBQUMsU0FBUyxDQUFDLElBQUksQ0FBQyxhQUFhLEVBQUUsV0FBVyxDQUFDLENBQUE7SUFDakQsQ0FBQztJQUVELE9BQU87UUFDTCxJQUFJLENBQUMsTUFBTSxDQUFDLFNBQVMsQ0FBQyxDQUFBO0lBQ3hCLENBQUM7Q0FDRjtBQXpDRCxzQ0F5Q0MifQ==

api.hyungi.net/node_modules/@pm2/io/build/main/features/metrics.d.ts

@@ -0,0 +1,24 @@
+import { Feature } from '../featureManager';
+import { EventLoopMetricOption } from '../metrics/eventLoopMetrics';
+import { NetworkTrafficConfig } from '../metrics/network';
+import { HttpMetricsConfig } from '../metrics/httpMetrics';
+import { V8MetricsConfig } from '../metrics/v8';
+import { RuntimeMetricsOptions } from '../metrics/runtime';
+export declare const defaultMetricConf: MetricConfig;
+export declare class MetricConfig {
+    v8?: V8MetricsConfig | boolean;
+    runtime?: RuntimeMetricsOptions | boolean;
+    http?: HttpMetricsConfig | boolean;
+    network?: NetworkTrafficConfig | boolean;
+    eventLoop?: EventLoopMetricOption | boolean;
+}
+export interface MetricInterface {
+    init(config?: Object | boolean): void;
+    destroy(): void;
+}
+export declare class MetricsFeature implements Feature {
+    private logger;
+    init(options?: Object): void;
+    get(name: string): MetricInterface | undefined;
+    destroy(): void;
+}

api.hyungi.net/node_modules/@pm2/io/build/main/features/metrics.js

@@ -0,0 +1,90 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MetricsFeature = exports.MetricConfig = exports.defaultMetricConf = void 0;
+const debug_1 = require("debug");
+const featureManager_1 = require("../featureManager");
+const eventLoopMetrics_1 = require("../metrics/eventLoopMetrics");
+const network_1 = require("../metrics/network");
+const httpMetrics_1 = require("../metrics/httpMetrics");
+const v8_1 = require("../metrics/v8");
+const runtime_1 = require("../metrics/runtime");
+exports.defaultMetricConf = {
+    eventLoop: true,
+    network: false,
+    http: true,
+    runtime: true,
+    v8: true
+};
+class MetricConfig {
+}
+exports.MetricConfig = MetricConfig;
+class AvailableMetric {
+}
+const availableMetrics = [
+    {
+        name: 'eventloop',
+        module: eventLoopMetrics_1.default,
+        optionsPath: 'eventLoop'
+    },
+    {
+        name: 'http',
+        module: httpMetrics_1.default,
+        optionsPath: 'http'
+    },
+    {
+        name: 'network',
+        module: network_1.default,
+        optionsPath: 'network'
+    },
+    {
+        name: 'v8',
+        module: v8_1.default,
+        optionsPath: 'v8'
+    },
+    {
+        name: 'runtime',
+        module: runtime_1.default,
+        optionsPath: 'runtime'
+    }
+];
+class MetricsFeature {
+    constructor() {
+        this.logger = (0, debug_1.default)('axm:features:metrics');
+    }
+    init(options) {
+        if (typeof options !== 'object')
+            options = {};
+        this.logger('init');
+        for (let availableMetric of availableMetrics) {
+            const metric = new availableMetric.module();
+            let config = undefined;
+            if (typeof availableMetric.optionsPath !== 'string') {
+                config = {};
+            }
+            else if (availableMetric.optionsPath === '.') {
+                config = options;
+            }
+            else {
+                config = (0, featureManager_1.getObjectAtPath)(options, availableMetric.optionsPath);
+            }
+            metric.init(config);
+            availableMetric.instance = metric;
+        }
+    }
+    get(name) {
+        const metric = availableMetrics.find(metric => metric.name === name);
+        if (metric === undefined)
+            return undefined;
+        return metric.instance;
+    }
+    destroy() {
+        this.logger('destroy');
+        for (let availableMetric of availableMetrics) {
+            if (availableMetric.instance === undefined)
+                continue;
+            availableMetric.instance.destroy();
+        }
+    }
+}
+exports.MetricsFeature = MetricsFeature;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibWV0cmljcy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9mZWF0dXJlcy9tZXRyaWNzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7OztBQUFBLGlDQUF5QjtBQUN6QixzREFBNEQ7QUFDNUQsa0VBQW1HO0FBQ25HLGdEQUF3RTtBQUN4RSx3REFBdUU7QUFDdkUsc0NBQXlEO0FBQ3pELGdEQUEwRTtBQUU3RCxRQUFBLGlCQUFpQixHQUFpQjtJQUM3QyxTQUFTLEVBQUUsSUFBSTtJQUNmLE9BQU8sRUFBRSxLQUFLO0lBQ2QsSUFBSSxFQUFFLElBQUk7SUFDVixPQUFPLEVBQUUsSUFBSTtJQUNiLEVBQUUsRUFBRSxJQUFJO0NBQ1QsQ0FBQTtBQUVELE1BQWEsWUFBWTtDQXVCeEI7QUF2QkQsb0NBdUJDO0FBRUQsTUFBTSxlQUFlO0NBcUJwQjtBQUVELE1BQU0sZ0JBQWdCLEdBQXNCO0lBQzFDO1FBQ0UsSUFBSSxFQUFFLFdBQVc7UUFDakIsTUFBTSxFQUFFLDBCQUE4QjtRQUN0QyxXQUFXLEVBQUUsV0FBVztLQUN6QjtJQUNEO1FBQ0UsSUFBSSxFQUFFLE1BQU07UUFDWixNQUFNLEVBQUUscUJBQVc7UUFDbkIsV0FBVyxFQUFFLE1BQU07S0FDcEI7SUFDRDtRQUNFLElBQUksRUFBRSxTQUFTO1FBQ2YsTUFBTSxFQUFFLGlCQUFhO1FBQ3JCLFdBQVcsRUFBRSxTQUFTO0tBQ3ZCO0lBQ0Q7UUFDRSxJQUFJLEVBQUUsSUFBSTtRQUNWLE1BQU0sRUFBRSxZQUFRO1FBQ2hCLFdBQVcsRUFBRSxJQUFJO0tBQ2xCO0lBQ0Q7UUFDRSxJQUFJLEVBQUUsU0FBUztRQUNmLE1BQU0sRUFBRSxpQkFBYztRQUN0QixXQUFXLEVBQUUsU0FBUztLQUN2QjtDQUNGLENBQUE7QUFPRCxNQUFhLGNBQWM7SUFBM0I7UUFFVSxXQUFNLEdBQWEsSUFBQSxlQUFLLEVBQUMsc0JBQXNCLENBQUMsQ0FBQTtJQXFDMUQsQ0FBQztJQW5DQyxJQUFJLENBQUUsT0FBZ0I7UUFDcEIsSUFBSSxPQUFPLE9BQU8sS0FBSyxRQUFRO1lBQUUsT0FBTyxHQUFHLEVBQUUsQ0FBQTtRQUM3QyxJQUFJLENBQUMsTUFBTSxDQUFDLE1BQU0sQ0FBQyxDQUFBO1FBRW5CLEtBQUssSUFBSSxlQUFlLElBQUksZ0JBQWdCLEVBQUUsQ0FBQztZQUM3QyxNQUFNLE1BQU0sR0FBRyxJQUFJLGVBQWUsQ0FBQyxNQUFNLEVBQUUsQ0FBQTtZQUMzQyxJQUFJLE1BQU0sR0FBUSxTQUFTLENBQUE7WUFDM0IsSUFBSSxPQUFPLGVBQWUsQ0FBQyxXQUFXLEtBQUssUUFBUSxFQUFFLENBQUM7Z0JBQ3BELE1BQU0sR0FBRyxFQUFFLENBQUE7WUFDYixDQUFDO2lCQUFNLElBQUksZUFBZSxDQUFDLFdBQVcsS0FBSyxHQUFHLEVBQUUsQ0FBQztnQkFDL0MsTUFBTSxHQUFHLE9BQU8sQ0FBQTtZQUNsQixDQUFDO2lCQUFNLENBQUM7Z0JBQ04sTUFBTSxHQUFHLElBQUEsZ0NBQWUsRUFBQyxPQUFPLEVBQUUsZUFBZSxDQUFDLFdBQVcsQ0FBQyxDQUFBO1lBQ2hFLENBQUM7WUFJRCxNQUFNLENBQUMsSUFBSSxDQUFDLE1BQU0sQ0FBQyxDQUFBO1lBQ25CLGVBQWUsQ0FBQyxRQUFRLEdBQUcsTUFBTSxDQUFBO1FBQ25DLENBQUM7SUFDSCxDQUFDO0lBRUQsR0FBRyxDQUFFLElBQVk7UUFDZixNQUFNLE1BQU0sR0FBRyxnQkFBZ0IsQ0FBQyxJQUFJLENBQUMsTUFBTSxDQUFDLEVBQUUsQ0FBQyxNQUFNLENBQUMsSUFBSSxLQUFLLElBQUksQ0FBQyxDQUFBO1FBQ3BFLElBQUksTUFBTSxLQUFLLFNBQVM7WUFBRSxPQUFPLFNBQVMsQ0FBQTtRQUMxQyxPQUFPLE1BQU0sQ0FBQyxRQUFRLENBQUE7SUFDeEIsQ0FBQztJQUVELE9BQU87UUFDTCxJQUFJLENBQUMsTUFBTSxDQUFDLFNBQVMsQ0FBQyxDQUFBO1FBQ3RCLEtBQUssSUFBSSxlQUFlLElBQUksZ0JBQWdCLEVBQUUsQ0FBQztZQUM3QyxJQUFJLGVBQWUsQ0FBQyxRQUFRLEtBQUssU0FBUztnQkFBRSxTQUFRO1lBQ3BELGVBQWUsQ0FBQyxRQUFRLENBQUMsT0FBTyxFQUFFLENBQUE7UUFDcEMsQ0FBQztJQUNILENBQUM7Q0FDRjtBQXZDRCx3Q0F1Q0MifQ==

api.hyungi.net/node_modules/@pm2/io/build/main/features/notify.d.ts

@@ -0,0 +1,23 @@
+import { Feature } from '../featureManager';
+export declare class NotifyOptions {
+    catchExceptions: boolean;
+}
+export declare class ErrorContext {
+    http?: Object;
+    custom?: Object;
+}
+export declare class NotifyFeature implements Feature {
+    private logger;
+    private transport;
+    private cache;
+    private stackParser;
+    init(options?: NotifyOptions): any;
+    destroy(): void;
+    getSafeError(err: any): Error;
+    notifyError(err: Error | string | {}, context?: ErrorContext): any;
+    private onUncaughtException;
+    private onUnhandledRejection;
+    private catchAll;
+    expressErrorHandler(): (err: any, req: any, res: any, next: any) => any;
+    koaErrorHandler(): (ctx: any, next: any) => Promise<void>;
+}

api.hyungi.net/node_modules/@pm2/io/build/main/features/profiling.d.ts

@@ -0,0 +1,18 @@
+import { Feature } from '../featureManager';
+export interface ProfilerType {
+    init(): void;
+    register(): void;
+    destroy(): void;
+}
+export declare class ProfilingConfig {
+    cpuJS: boolean;
+    heapSnapshot: boolean;
+    heapSampling: boolean;
+    implementation?: string;
+}
+export declare class ProfilingFeature implements Feature {
+    private profiler;
+    private logger;
+    init(config?: ProfilingConfig | boolean): any;
+    destroy(): void;
+}

api.hyungi.net/node_modules/@pm2/io/build/main/features/profiling.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProfilingFeature = exports.ProfilingConfig = void 0;
+const addonProfiler_1 = require("../profilers/addonProfiler");
+const inspectorProfiler_1 = require("../profilers/inspectorProfiler");
+const constants_1 = require("../constants");
+const Debug = require("debug");
+class ProfilingConfig {
+}
+exports.ProfilingConfig = ProfilingConfig;
+const defaultProfilingConfig = {
+    cpuJS: true,
+    heapSnapshot: true,
+    heapSampling: true,
+    implementation: 'both'
+};
+const disabledProfilingConfig = {
+    cpuJS: false,
+    heapSnapshot: false,
+    heapSampling: false,
+    implementation: 'none'
+};
+class ProfilingFeature {
+    constructor() {
+        this.logger = Debug('axm:features:profiling');
+    }
+    init(config) {
+        if (config === true) {
+            config = defaultProfilingConfig;
+        }
+        else if (config === false) {
+            config = disabledProfilingConfig;
+        }
+        else if (config === undefined) {
+            config = defaultProfilingConfig;
+        }
+        if (process.env.PM2_PROFILING_FORCE_FALLBACK === 'true') {
+            config.implementation = 'addon';
+        }
+        if (config.implementation === undefined || config.implementation === 'both') {
+            config.implementation = (0, constants_1.canUseInspector)() === true ? 'inspector' : 'addon';
+        }
+        switch (config.implementation) {
+            case 'inspector': {
+                this.logger('using inspector implementation');
+                this.profiler = new inspectorProfiler_1.default();
+                break;
+            }
+            case 'addon': {
+                this.logger('using addon implementation');
+                this.profiler = new addonProfiler_1.default();
+                break;
+            }
+            default: {
+                return this.logger(`Invalid profiler implementation choosen: ${config.implementation}`);
+            }
+        }
+        this.logger('init');
+        this.profiler.init();
+    }
+    destroy() {
+        this.logger('destroy');
+        if (this.profiler === undefined)
+            return;
+        this.profiler.destroy();
+    }
+}
+exports.ProfilingFeature = ProfilingFeature;
+//# sourceMappingURL=data:application/json;base64,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

api.hyungi.net/node_modules/@pm2/io/build/main/index.d.ts

@@ -0,0 +1,3 @@
+import PMX from './pmx';
+declare const io: PMX;
+export = io;

api.hyungi.net/node_modules/@pm2/io/build/main/index.js

@@ -0,0 +1,8 @@
+"use strict";
+const pmx_1 = require("./pmx");
+const IO_KEY = Symbol.for('@pm2/io');
+const isAlreadyHere = (Object.getOwnPropertySymbols(global).indexOf(IO_KEY) > -1);
+const io = isAlreadyHere ? global[IO_KEY] : new pmx_1.default().init();
+global[IO_KEY] = io;
+module.exports = io;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IjtBQUNBLCtCQUF1QjtBQUV2QixNQUFNLE1BQU0sR0FBRyxNQUFNLENBQUMsR0FBRyxDQUFDLFNBQVMsQ0FBQyxDQUFBO0FBQ3BDLE1BQU0sYUFBYSxHQUFHLENBQUMsTUFBTSxDQUFDLHFCQUFxQixDQUFDLE1BQU0sQ0FBQyxDQUFDLE9BQU8sQ0FBQyxNQUFNLENBQUMsR0FBRyxDQUFDLENBQUMsQ0FBQyxDQUFBO0FBRWpGLE1BQU0sRUFBRSxHQUFRLGFBQWEsQ0FBQyxDQUFDLENBQUMsTUFBTSxDQUFDLE1BQU0sQ0FBUSxDQUFDLENBQUMsQ0FBQyxJQUFJLGFBQUcsRUFBRSxDQUFDLElBQUksRUFBRSxDQUFBO0FBQ3hFLE1BQU0sQ0FBQyxNQUFNLENBQUMsR0FBRyxFQUFFLENBQUE7QUFFbkIsaUJBQVMsRUFBRSxDQUFBIn0=

api.hyungi.net/node_modules/@pm2/io/build/main/metrics/eventLoopMetrics.d.ts

@@ -0,0 +1,17 @@
+import { MetricInterface } from '../features/metrics';
+export declare class EventLoopMetricOption {
+    eventLoopActive: boolean;
+    eventLoopDelay: boolean;
+}
+export default class EventLoopHandlesRequestsMetric implements MetricInterface {
+    private metricService;
+    private logger;
+    private requestTimer;
+    private handleTimer;
+    private delayTimer;
+    private delayLoopInterval;
+    private runtimeStatsService;
+    private handle;
+    init(config?: EventLoopMetricOption | boolean): any;
+    destroy(): void;
+}

api.hyungi.net/node_modules/@pm2/io/build/main/metrics/httpMetrics.d.ts

@@ -0,0 +1,18 @@
+import { MetricInterface } from '../features/metrics';
+export declare class HttpMetricsConfig {
+    http: boolean;
+}
+export default class HttpMetrics implements MetricInterface {
+    private defaultConf;
+    private metrics;
+    private logger;
+    private metricService;
+    private modules;
+    private hooks;
+    init(config?: HttpMetricsConfig | boolean): any;
+    private registerHttpMetric;
+    private registerHttpsMetric;
+    destroy(): void;
+    private hookHttp;
+    private hookRequire;
+}

api.hyungi.net/node_modules/@pm2/io/build/main/metrics/network.d.ts

@@ -0,0 +1,15 @@
+import { MetricInterface } from '../features/metrics';
+export declare class NetworkTrafficConfig {
+    upload: boolean;
+    download: boolean;
+}
+export default class NetworkMetric implements MetricInterface {
+    private metricService;
+    private timer;
+    private logger;
+    private socketProto;
+    init(config?: NetworkTrafficConfig | boolean): any;
+    destroy(): void;
+    private catchDownload;
+    private catchUpload;
+}

api.hyungi.net/node_modules/@pm2/io/build/main/metrics/network.js

@@ -0,0 +1,122 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NetworkTrafficConfig = void 0;
+const netModule = require("net");
+const metrics_1 = require("../services/metrics");
+const Debug = require("debug");
+const meter_1 = require("../utils/metrics/meter");
+const shimmer = require("shimmer");
+const serviceManager_1 = require("../serviceManager");
+class NetworkTrafficConfig {
+}
+exports.NetworkTrafficConfig = NetworkTrafficConfig;
+const defaultConfig = {
+    upload: false,
+    download: false
+};
+const allEnabled = {
+    upload: true,
+    download: true
+};
+class NetworkMetric {
+    constructor() {
+        this.logger = Debug('axm:features:metrics:network');
+    }
+    init(config) {
+        if (config === false)
+            return;
+        if (config === true) {
+            config = allEnabled;
+        }
+        if (config === undefined) {
+            config = defaultConfig;
+        }
+        this.metricService = serviceManager_1.ServiceManager.get('metrics');
+        if (this.metricService === undefined) {
+            return this.logger(`Failed to load metric service`);
+        }
+        if (config.download === true) {
+            this.catchDownload();
+        }
+        if (config.upload === true) {
+            this.catchUpload();
+        }
+        this.logger('init');
+    }
+    destroy() {
+        if (this.timer !== undefined) {
+            clearTimeout(this.timer);
+        }
+        if (this.socketProto !== undefined && this.socketProto !== null) {
+            shimmer.unwrap(this.socketProto, 'read');
+            shimmer.unwrap(this.socketProto, 'write');
+        }
+        this.logger('destroy');
+    }
+    catchDownload() {
+        if (this.metricService === undefined)
+            return this.logger(`Failed to load metric service`);
+        const downloadMeter = new meter_1.default({});
+        this.metricService.registerMetric({
+            name: 'Network In',
+            id: 'internal/network/in',
+            historic: true,
+            type: metrics_1.MetricType.meter,
+            implementation: downloadMeter,
+            unit: 'kb/s',
+            handler: function () {
+                return Math.floor(this.implementation.val() / 1024 * 1000) / 1000;
+            }
+        });
+        setTimeout(() => {
+            const property = netModule.Socket.prototype.read;
+            const isWrapped = property && property.__wrapped === true;
+            if (isWrapped) {
+                return this.logger(`Already patched socket read, canceling`);
+            }
+            shimmer.wrap(netModule.Socket.prototype, 'read', function (original) {
+                return function () {
+                    this.on('data', (data) => {
+                        if (typeof data.length === 'number') {
+                            downloadMeter.mark(data.length);
+                        }
+                    });
+                    return original.apply(this, arguments);
+                };
+            });
+        }, 500);
+    }
+    catchUpload() {
+        if (this.metricService === undefined)
+            return this.logger(`Failed to load metric service`);
+        const uploadMeter = new meter_1.default();
+        this.metricService.registerMetric({
+            name: 'Network Out',
+            id: 'internal/network/out',
+            type: metrics_1.MetricType.meter,
+            historic: true,
+            implementation: uploadMeter,
+            unit: 'kb/s',
+            handler: function () {
+                return Math.floor(this.implementation.val() / 1024 * 1000) / 1000;
+            }
+        });
+        setTimeout(() => {
+            const property = netModule.Socket.prototype.write;
+            const isWrapped = property && property.__wrapped === true;
+            if (isWrapped) {
+                return this.logger(`Already patched socket write, canceling`);
+            }
+            shimmer.wrap(netModule.Socket.prototype, 'write', function (original) {
+                return function (data) {
+                    if (typeof data.length === 'number') {
+                        uploadMeter.mark(data.length);
+                    }
+                    return original.apply(this, arguments);
+                };
+            });
+        }, 500);
+    }
+}
+exports.default = NetworkMetric;
+//# sourceMappingURL=data:application/json;base64,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

api.hyungi.net/node_modules/@pm2/io/build/main/metrics/runtime.d.ts

@@ -0,0 +1,16 @@
+import { MetricInterface } from '../features/metrics';
+export declare class RuntimeMetricsOptions {
+    gcOldPause: boolean;
+    gcNewPause: boolean;
+    pageFaults: boolean;
+    contextSwitchs: boolean;
+}
+export default class RuntimeMetrics implements MetricInterface {
+    private metricService;
+    private logger;
+    private runtimeStatsService;
+    private handle;
+    private metrics;
+    init(config?: RuntimeMetricsOptions | boolean): any;
+    destroy(): void;
+}

api.hyungi.net/node_modules/@pm2/io/build/main/metrics/v8.d.ts

@@ -0,0 +1,23 @@
+import { MetricInterface } from '../features/metrics';
+export declare class V8MetricsConfig {
+    new_space: boolean;
+    old_space: boolean;
+    map_space: boolean;
+    code_space: boolean;
+    large_object_space: boolean;
+    heap_total_size: boolean;
+    heap_used_size: boolean;
+    heap_used_percent: boolean;
+}
+export default class V8Metric implements MetricInterface {
+    private timer;
+    private TIME_INTERVAL;
+    private metricService;
+    private logger;
+    private metricStore;
+    private unitKB;
+    private metricsDefinitions;
+    init(config?: V8MetricsConfig | boolean): any;
+    destroy(): void;
+    private formatMiBytes;
+}

api.hyungi.net/node_modules/@pm2/io/build/main/metrics/v8.js

@@ -0,0 +1,101 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.V8MetricsConfig = void 0;
+const v8 = require("v8");
+const debug_1 = require("debug");
+const serviceManager_1 = require("../serviceManager");
+class V8MetricsConfig {
+}
+exports.V8MetricsConfig = V8MetricsConfig;
+const defaultOptions = {
+    new_space: false,
+    old_space: false,
+    map_space: false,
+    code_space: false,
+    large_object_space: false,
+    heap_total_size: true,
+    heap_used_size: true,
+    heap_used_percent: true
+};
+class V8Metric {
+    constructor() {
+        this.TIME_INTERVAL = 800;
+        this.logger = (0, debug_1.default)('axm:features:metrics:v8');
+        this.metricStore = new Map();
+        this.unitKB = 'MiB';
+        this.metricsDefinitions = {
+            total_heap_size: {
+                name: 'Heap Size',
+                id: 'internal/v8/heap/total',
+                unit: this.unitKB,
+                historic: true
+            },
+            heap_used_percent: {
+                name: 'Heap Usage',
+                id: 'internal/v8/heap/usage',
+                unit: '%',
+                historic: true
+            },
+            used_heap_size: {
+                name: 'Used Heap Size',
+                id: 'internal/v8/heap/used',
+                unit: this.unitKB,
+                historic: true
+            }
+        };
+    }
+    init(config) {
+        if (config === false)
+            return;
+        if (config === undefined) {
+            config = defaultOptions;
+        }
+        if (config === true) {
+            config = defaultOptions;
+        }
+        this.metricService = serviceManager_1.ServiceManager.get('metrics');
+        if (this.metricService === undefined)
+            return this.logger('Failed to load metric service');
+        this.logger('init');
+        if (!v8.hasOwnProperty('getHeapStatistics')) {
+            return this.logger(`V8.getHeapStatistics is not available, aborting`);
+        }
+        for (let metricName in this.metricsDefinitions) {
+            if (config[metricName] === false)
+                continue;
+            const isEnabled = config[metricName];
+            if (isEnabled === false)
+                continue;
+            let metric = this.metricsDefinitions[metricName];
+            this.metricStore.set(metricName, this.metricService.metric(metric));
+        }
+        this.timer = setInterval(() => {
+            const stats = v8.getHeapStatistics();
+            for (let metricName in this.metricsDefinitions) {
+                if (typeof stats[metricName] !== 'number')
+                    continue;
+                const gauge = this.metricStore.get(metricName);
+                if (gauge === undefined)
+                    continue;
+                gauge.set(this.formatMiBytes(stats[metricName]));
+            }
+            const usage = (stats.used_heap_size / stats.total_heap_size * 100).toFixed(2);
+            const usageMetric = this.metricStore.get('heap_used_percent');
+            if (usageMetric !== undefined) {
+                usageMetric.set(parseFloat(usage));
+            }
+        }, this.TIME_INTERVAL);
+        this.timer.unref();
+    }
+    destroy() {
+        if (this.timer !== undefined) {
+            clearInterval(this.timer);
+        }
+        this.logger('destroy');
+    }
+    formatMiBytes(val) {
+        return (val / 1024 / 1024).toFixed(2);
+    }
+}
+exports.default = V8Metric;
+//# sourceMappingURL=data:application/json;base64,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

api.hyungi.net/node_modules/@pm2/io/build/main/pmx.d.ts

@@ -0,0 +1,50 @@
+import { TransportConfig } from './services/transport';
+import { ErrorContext } from './features/notify';
+import { Metric, HistogramOptions, MetricBulk } from './services/metrics';
+import Meter from './utils/metrics/meter';
+import Histogram from './utils/metrics/histogram';
+import Gauge from './utils/metrics/gauge';
+import Counter from './utils/metrics/counter';
+import { MetricConfig } from './features/metrics';
+import { ProfilingConfig } from './features/profiling';
+import { Entrypoint } from './features/entrypoint';
+export declare class IOConfig {
+    catchExceptions?: boolean;
+    metrics?: MetricConfig;
+    actions?: {
+        eventLoopDump?: boolean;
+    };
+    profiling?: ProfilingConfig | boolean;
+    standalone?: boolean;
+    apmOptions?: TransportConfig;
+}
+export declare const defaultConfig: IOConfig;
+export default class PMX {
+    private initialConfig;
+    private featureManager;
+    private transport;
+    private actionService;
+    private metricService;
+    private runtimeStatsService;
+    private logger;
+    private initialized;
+    Entrypoint: {
+        new (): Entrypoint;
+    };
+    init(config?: IOConfig): this;
+    destroy(): void;
+    getConfig(): IOConfig;
+    notifyError(error: Error | string | {}, context?: ErrorContext): any;
+    metrics(metric: MetricBulk | Array<MetricBulk>): any[];
+    histogram(config: HistogramOptions): Histogram;
+    metric(config: Metric): Gauge;
+    gauge(config: Metric): Gauge;
+    counter(config: Metric): Counter;
+    meter(config: Metric): Meter;
+    action(name: string, opts?: Object, fn?: Function): void;
+    onExit(callback: Function): any;
+    emit(name: string, data: Object): any;
+    initModule(opts: any, cb?: Function): any;
+    expressErrorHandler(): (err: any, req: any, res: any, next: any) => any;
+    koaErrorHandler(): (ctx: any, next: any) => Promise<void>;
+}

api.hyungi.net/node_modules/@pm2/io/build/main/profilers/addonProfiler.d.ts

@@ -0,0 +1,16 @@
+import { ProfilerType } from '../features/profiling';
+export default class AddonProfiler implements ProfilerType {
+    private profiler;
+    private modules;
+    private actionService;
+    private transport;
+    private currentProfile;
+    private logger;
+    init(): any;
+    register(): any;
+    destroy(): void;
+    private onCPUProfileStart;
+    private onCPUProfileStop;
+    private onHeapdump;
+    private takeSnapshot;
+}

api.hyungi.net/node_modules/@pm2/io/build/main/profilers/inspectorProfiler.d.ts

@@ -0,0 +1,18 @@
+import { ProfilerType } from '../features/profiling';
+export default class InspectorProfiler implements ProfilerType {
+    private profiler;
+    private actionService;
+    private transport;
+    private currentProfile;
+    private logger;
+    private isNode11;
+    init(): any;
+    register(): any;
+    destroy(): void;
+    private onHeapProfileStart;
+    private onHeapProfileStop;
+    private onCPUProfileStart;
+    private onCPUProfileStop;
+    private onHeapdump;
+    takeSnapshot(): Promise<unknown>;
+}

api.hyungi.net/node_modules/@pm2/io/build/main/serviceManager.d.ts

@@ -0,0 +1,7 @@
+export declare class Service {
+}
+export declare class ServiceManager {
+    static get(serviceName: string): any | undefined;
+    static set(serviceName: string, service: Service): Map<string, any>;
+    static reset(serviceName: string): boolean;
+}

api.hyungi.net/node_modules/@pm2/io/build/main/serviceManager.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ServiceManager = exports.Service = void 0;
+const services = new Map();
+class Service {
+}
+exports.Service = Service;
+class ServiceManager {
+    static get(serviceName) {
+        return services.get(serviceName);
+    }
+    static set(serviceName, service) {
+        return services.set(serviceName, service);
+    }
+    static reset(serviceName) {
+        return services.delete(serviceName);
+    }
+}
+exports.ServiceManager = ServiceManager;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2VydmljZU1hbmFnZXIuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvc2VydmljZU1hbmFnZXIudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7O0FBQ0EsTUFBTSxRQUFRLEdBQXFCLElBQUksR0FBRyxFQUFlLENBQUE7QUFFekQsTUFBYSxPQUFPO0NBQUc7QUFBdkIsMEJBQXVCO0FBRXZCLE1BQWEsY0FBYztJQUVsQixNQUFNLENBQUMsR0FBRyxDQUFFLFdBQW1CO1FBQ3BDLE9BQU8sUUFBUSxDQUFDLEdBQUcsQ0FBQyxXQUFXLENBQUMsQ0FBQTtJQUNsQyxDQUFDO0lBRU0sTUFBTSxDQUFDLEdBQUcsQ0FBRSxXQUFtQixFQUFFLE9BQWdCO1FBQ3RELE9BQU8sUUFBUSxDQUFDLEdBQUcsQ0FBQyxXQUFXLEVBQUUsT0FBTyxDQUFDLENBQUE7SUFDM0MsQ0FBQztJQUVNLE1BQU0sQ0FBQyxLQUFLLENBQUUsV0FBbUI7UUFDdEMsT0FBTyxRQUFRLENBQUMsTUFBTSxDQUFDLFdBQVcsQ0FBQyxDQUFBO0lBQ3JDLENBQUM7Q0FDRjtBQWJELHdDQWFDIn0=

api.hyungi.net/node_modules/@pm2/io/build/main/services/actions.d.ts

@@ -0,0 +1,20 @@
+export declare class Action {
+    handler: Function;
+    name: string;
+    type: string;
+    isScoped: boolean;
+    callback?: Function;
+    arity: number;
+    opts: Object | null | undefined;
+}
+export declare class ActionService {
+    private timer;
+    private transport;
+    private actions;
+    private logger;
+    private listener;
+    init(): void;
+    destroy(): void;
+    registerAction(actionName?: string, opts?: Object | undefined | Function, handler?: Function): void;
+    scopedAction(actionName?: string, handler?: Function): any;
+}

api.hyungi.net/node_modules/@pm2/io/build/main/services/inspector.d.ts

@@ -0,0 +1,9 @@
+/// <reference types="node" />
+import * as inspector from 'inspector';
+export declare class InspectorService {
+    private session;
+    private logger;
+    init(): inspector.Session;
+    getSession(): inspector.Session;
+    destroy(): void;
+}

api.hyungi.net/node_modules/@pm2/io/build/main/services/inspector.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InspectorService = void 0;
+const inspector = require("inspector");
+const debug_1 = require("debug");
+class InspectorService {
+    constructor() {
+        this.session = null;
+        this.logger = (0, debug_1.default)('axm:services:inspector');
+    }
+    init() {
+        this.logger(`Creating new inspector session`);
+        this.session = new inspector.Session();
+        this.session.connect();
+        this.logger('Connected to inspector');
+        this.session.post('Profiler.enable');
+        this.session.post('HeapProfiler.enable');
+        return this.session;
+    }
+    getSession() {
+        if (this.session === null) {
+            this.session = this.init();
+            return this.session;
+        }
+        else {
+            return this.session;
+        }
+    }
+    destroy() {
+        if (this.session !== null) {
+            this.session.post('Profiler.disable');
+            this.session.post('HeapProfiler.disable');
+            this.session.disconnect();
+            this.session = null;
+        }
+        else {
+            this.logger('No open session');
+        }
+    }
+}
+exports.InspectorService = InspectorService;
+module.exports = InspectorService;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5zcGVjdG9yLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL3NlcnZpY2VzL2luc3BlY3Rvci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7QUFBQSx1Q0FBc0M7QUFDdEMsaUNBQXlCO0FBRXpCLE1BQWEsZ0JBQWdCO0lBQTdCO1FBRVUsWUFBTyxHQUE2QixJQUFJLENBQUE7UUFDeEMsV0FBTSxHQUFhLElBQUEsZUFBSyxFQUFDLHdCQUF3QixDQUFDLENBQUE7SUErQjVELENBQUM7SUE3QkMsSUFBSTtRQUNGLElBQUksQ0FBQyxNQUFNLENBQUMsZ0NBQWdDLENBQUMsQ0FBQTtRQUM3QyxJQUFJLENBQUMsT0FBTyxHQUFHLElBQUksU0FBUyxDQUFDLE9BQU8sRUFBRSxDQUFBO1FBQ3RDLElBQUksQ0FBQyxPQUFPLENBQUMsT0FBTyxFQUFFLENBQUE7UUFDdEIsSUFBSSxDQUFDLE1BQU0sQ0FBQyx3QkFBd0IsQ0FBQyxDQUFBO1FBQ3JDLElBQUksQ0FBQyxPQUFPLENBQUMsSUFBSSxDQUFDLGlCQUFpQixDQUFDLENBQUE7UUFDcEMsSUFBSSxDQUFDLE9BQU8sQ0FBQyxJQUFJLENBQUMscUJBQXFCLENBQUMsQ0FBQTtRQUN4QyxPQUFPLElBQUksQ0FBQyxPQUFPLENBQUE7SUFDckIsQ0FBQztJQUVELFVBQVU7UUFDUixJQUFJLElBQUksQ0FBQyxPQUFPLEtBQUssSUFBSSxFQUFFLENBQUM7WUFDMUIsSUFBSSxDQUFDLE9BQU8sR0FBRyxJQUFJLENBQUMsSUFBSSxFQUFFLENBQUE7WUFDMUIsT0FBTyxJQUFJLENBQUMsT0FBTyxDQUFBO1FBQ3JCLENBQUM7YUFBTSxDQUFDO1lBQ04sT0FBTyxJQUFJLENBQUMsT0FBTyxDQUFBO1FBQ3JCLENBQUM7SUFDSCxDQUFDO0lBRUQsT0FBTztRQUNMLElBQUksSUFBSSxDQUFDLE9BQU8sS0FBSyxJQUFJLEVBQUUsQ0FBQztZQUMxQixJQUFJLENBQUMsT0FBTyxDQUFDLElBQUksQ0FBQyxrQkFBa0IsQ0FBQyxDQUFBO1lBQ3JDLElBQUksQ0FBQyxPQUFPLENBQUMsSUFBSSxDQUFDLHNCQUFzQixDQUFDLENBQUE7WUFDekMsSUFBSSxDQUFDLE9BQU8sQ0FBQyxVQUFVLEVBQUUsQ0FBQTtZQUN6QixJQUFJLENBQUMsT0FBTyxHQUFHLElBQUksQ0FBQTtRQUNyQixDQUFDO2FBQU0sQ0FBQztZQUNOLElBQUksQ0FBQyxNQUFNLENBQUMsaUJBQWlCLENBQUMsQ0FBQTtRQUNoQyxDQUFDO0lBQ0gsQ0FBQztDQUNGO0FBbENELDRDQWtDQztBQUVELE1BQU0sQ0FBQyxPQUFPLEdBQUcsZ0JBQWdCLENBQUEifQ==

api.hyungi.net/node_modules/@pm2/io/build/main/services/metrics.d.ts

@@ -0,0 +1,63 @@
+import Meter from '../utils/metrics/meter';
+import Counter from '../utils/metrics/counter';
+import Histogram from '../utils/metrics/histogram';
+import { Service } from '../serviceManager';
+import Gauge from '../utils/metrics/gauge';
+export declare enum MetricType {
+    'meter' = "meter",
+    'histogram' = "histogram",
+    'counter' = "counter",
+    'gauge' = "gauge",
+    'metric' = "metric"
+}
+export declare enum MetricMeasurements {
+    'min' = "min",
+    'max' = "max",
+    'sum' = "sum",
+    'count' = "count",
+    'variance' = "variance",
+    'mean' = "mean",
+    'stddev' = "stddev",
+    'median' = "median",
+    'p75' = "p75",
+    'p95' = "p95",
+    'p99' = "p99",
+    'p999' = "p999"
+}
+export interface InternalMetric {
+    name?: string;
+    type?: MetricType;
+    id?: string;
+    historic?: boolean;
+    unit?: string;
+    handler: Function;
+    implementation: any;
+    value?: number;
+}
+export declare class Metric {
+    name?: string;
+    id?: string;
+    historic?: boolean;
+    unit?: string;
+    value?: () => number;
+}
+export declare class MetricBulk extends Metric {
+    type: MetricType;
+}
+export declare class HistogramOptions extends Metric {
+    measurement: MetricMeasurements;
+}
+export declare class MetricService implements Service {
+    private metrics;
+    private timer;
+    private transport;
+    private logger;
+    init(): void;
+    registerMetric(metric: InternalMetric): void;
+    meter(opts: Metric): Meter;
+    counter(opts: Metric): Counter;
+    histogram(opts: HistogramOptions): Histogram;
+    metric(opts: Metric): Gauge;
+    deleteMetric(name: string): boolean;
+    destroy(): void;
+}

api.hyungi.net/node_modules/@pm2/io/build/main/services/runtimeStats.d.ts

@@ -0,0 +1,10 @@
+import { EventEmitter2 } from 'eventemitter2';
+export declare class RuntimeStatsService extends EventEmitter2 {
+    private logger;
+    private handle;
+    private noduleInstance;
+    private enabled;
+    init(): any;
+    isEnabled(): boolean;
+    destroy(): void;
+}

api.hyungi.net/node_modules/@pm2/io/build/main/services/runtimeStats.js

@@ -0,0 +1,50 @@
+'use strict';
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RuntimeStatsService = void 0;
+const debug_1 = require("debug");
+const module_1 = require("../utils/module");
+const eventemitter2_1 = require("eventemitter2");
+class RuntimeStatsService extends eventemitter2_1.EventEmitter2 {
+    constructor() {
+        super(...arguments);
+        this.logger = (0, debug_1.default)('axm:services:runtimeStats');
+        this.enabled = false;
+    }
+    init() {
+        this.logger('init');
+        if (process.env.PM2_APM_DISABLE_RUNTIME_STATS === 'true') {
+            return this.logger('disabling service because of the environment flag');
+        }
+        const modulePath = module_1.default.detectModule('@pm2/node-runtime-stats');
+        if (typeof modulePath !== 'string')
+            return;
+        const RuntimeStats = module_1.default.loadModule(modulePath);
+        if (RuntimeStats instanceof Error) {
+            return this.logger(`Failed to require module @pm2/node-runtime-stats: ${RuntimeStats.message}`);
+        }
+        this.noduleInstance = new RuntimeStats({
+            delay: 1000
+        });
+        this.logger('starting runtime stats');
+        this.noduleInstance.start();
+        this.handle = (data) => {
+            this.logger('received runtime stats', data);
+            this.emit('data', data);
+        };
+        this.noduleInstance.on('sense', this.handle);
+        this.enabled = true;
+    }
+    isEnabled() {
+        return this.enabled;
+    }
+    destroy() {
+        if (this.noduleInstance !== undefined && this.noduleInstance !== null) {
+            this.logger('removing listener on runtime stats service');
+            this.noduleInstance.removeListener('sense', this.handle);
+            this.noduleInstance.stop();
+        }
+        this.logger('destroy');
+    }
+}
+exports.RuntimeStatsService = RuntimeStatsService;
+//# sourceMappingURL=data:application/json;base64,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

api.hyungi.net/node_modules/@pm2/io/build/main/services/transport.d.ts

@@ -0,0 +1,22 @@
+import { Action } from './actions';
+import { InternalMetric } from './metrics';
+import { EventEmitter2 } from 'eventemitter2';
+export declare class TransportConfig {
+    publicKey: string;
+    secretKey: string;
+    appName: string;
+    serverName?: string;
+    sendLogs?: Boolean;
+    logFilter?: string | RegExp;
+    disableLogs?: Boolean;
+    proxy?: string;
+}
+export interface Transport extends EventEmitter2 {
+    init: (config: TransportConfig) => Transport;
+    destroy: () => void;
+    send: (channel: string, payload: Object) => void;
+    addAction: (action: Action) => void;
+    setMetrics: (metrics: InternalMetric[]) => void;
+    setOptions: (options: any) => void;
+}
+export declare function createTransport(name: string, config: TransportConfig): Transport;

api.hyungi.net/node_modules/@pm2/io/build/main/services/transport.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createTransport = exports.TransportConfig = void 0;
+const IPCTransport_1 = require("../transports/IPCTransport");
+class TransportConfig {
+}
+exports.TransportConfig = TransportConfig;
+function createTransport(name, config) {
+    const transport = new IPCTransport_1.IPCTransport();
+    transport.init(config);
+    return transport;
+}
+exports.createTransport = createTransport;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHJhbnNwb3J0LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL3NlcnZpY2VzL3RyYW5zcG9ydC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7QUFHQSw2REFBeUQ7QUFJekQsTUFBYSxlQUFlO0NBMEMzQjtBQTFDRCwwQ0EwQ0M7QUFnQ0QsU0FBZ0IsZUFBZSxDQUFFLElBQVksRUFBRSxNQUF1QjtJQUNwRSxNQUFNLFNBQVMsR0FBRyxJQUFJLDJCQUFZLEVBQUUsQ0FBQTtJQUNwQyxTQUFTLENBQUMsSUFBSSxDQUFDLE1BQU0sQ0FBQyxDQUFBO0lBQ3RCLE9BQU8sU0FBUyxDQUFBO0FBZWxCLENBQUM7QUFsQkQsMENBa0JDIn0=

api.hyungi.net/node_modules/@pm2/io/build/main/transports/IPCTransport.d.ts

@@ -0,0 +1,17 @@
+import { Transport, TransportConfig } from '../services/transport';
+import { Action } from '../services/actions';
+import { InternalMetric } from '../services/metrics';
+import { EventEmitter2 } from 'eventemitter2';
+export declare class IPCTransport extends EventEmitter2 implements Transport {
+    private initiated;
+    private logger;
+    private onMessage;
+    private autoExitHandle;
+    init(config?: TransportConfig): Transport;
+    private autoExitHook;
+    setMetrics(metrics: InternalMetric[]): void;
+    addAction(action: Action): void;
+    setOptions(options: any): -1 | undefined;
+    send(channel: any, payload: any): -1 | undefined;
+    destroy(): void;
+}

api.hyungi.net/node_modules/@pm2/io/build/main/transports/IPCTransport.js

@@ -0,0 +1,103 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IPCTransport = void 0;
+const Debug = require("debug");
+const eventemitter2_1 = require("eventemitter2");
+const cluster = require("cluster");
+class IPCTransport extends eventemitter2_1.EventEmitter2 {
+    constructor() {
+        super(...arguments);
+        this.initiated = false;
+        this.logger = Debug('axm:transport:ipc');
+    }
+    init(config) {
+        this.logger('Init new transport service');
+        if (this.initiated === true) {
+            console.error(`Trying to re-init the transport, please avoid`);
+            return this;
+        }
+        this.initiated = true;
+        this.logger('Agent launched');
+        this.onMessage = (data) => {
+            this.logger(`Received reverse message from IPC`);
+            this.emit('data', data);
+        };
+        process.on('message', this.onMessage);
+        if (cluster.isWorker === false) {
+            this.autoExitHook();
+        }
+        return this;
+    }
+    autoExitHook() {
+        this.autoExitHandle = setInterval(() => {
+            let currentProcess = (cluster.isWorker) ? cluster.worker.process : process;
+            if (currentProcess._getActiveHandles().length === 3) {
+                let handlers = currentProcess._getActiveHandles().map(h => h.constructor.name);
+                if (handlers.includes('Pipe') === true &&
+                    handlers.includes('Socket') === true) {
+                    process.removeListener('message', this.onMessage);
+                    let tmp = setTimeout(_ => {
+                        this.logger(`Still alive, listen back to IPC`);
+                        process.on('message', this.onMessage);
+                    }, 200);
+                    tmp.unref();
+                }
+            }
+        }, 3000);
+        this.autoExitHandle.unref();
+    }
+    setMetrics(metrics) {
+        const serializedMetric = metrics.reduce((object, metric) => {
+            if (typeof metric.name !== 'string')
+                return object;
+            object[metric.name] = {
+                historic: metric.historic,
+                unit: metric.unit,
+                type: metric.id,
+                value: metric.value
+            };
+            return object;
+        }, {});
+        this.send('axm:monitor', serializedMetric);
+    }
+    addAction(action) {
+        this.logger(`Add action: ${action.name}:${action.type}`);
+        this.send('axm:action', {
+            action_name: action.name,
+            action_type: action.type,
+            arity: action.arity,
+            opts: action.opts
+        });
+    }
+    setOptions(options) {
+        this.logger(`Set options: [${Object.keys(options).join(',')}]`);
+        return this.send('axm:option:configuration', options);
+    }
+    send(channel, payload) {
+        if (typeof process.send !== 'function')
+            return -1;
+        if (process.connected === false) {
+            console.error('Process disconnected from parent! (not connected)');
+            return process.exit(1);
+        }
+        try {
+            process.send({ type: channel, data: payload });
+        }
+        catch (err) {
+            this.logger('Process disconnected from parent !');
+            this.logger(err);
+            return process.exit(1);
+        }
+    }
+    destroy() {
+        if (this.onMessage !== undefined) {
+            process.removeListener('message', this.onMessage);
+        }
+        if (this.autoExitHandle !== undefined) {
+            clearInterval(this.autoExitHandle);
+        }
+        this.logger('destroy');
+    }
+}
+exports.IPCTransport = IPCTransport;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiSVBDVHJhbnNwb3J0LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL3RyYW5zcG9ydHMvSVBDVHJhbnNwb3J0LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7OztBQUNBLCtCQUE4QjtBQUc5QixpREFBNkM7QUFDN0MsbUNBQWtDO0FBRWxDLE1BQWEsWUFBYSxTQUFRLDZCQUFhO0lBQS9DOztRQUVVLGNBQVMsR0FBWSxLQUFLLENBQUE7UUFDMUIsV0FBTSxHQUFhLEtBQUssQ0FBQyxtQkFBbUIsQ0FBQyxDQUFBO0lBd0d2RCxDQUFDO0lBcEdDLElBQUksQ0FBRSxNQUF3QjtRQUM1QixJQUFJLENBQUMsTUFBTSxDQUFDLDRCQUE0QixDQUFDLENBQUE7UUFDekMsSUFBSSxJQUFJLENBQUMsU0FBUyxLQUFLLElBQUksRUFBRSxDQUFDO1lBQzVCLE9BQU8sQ0FBQyxLQUFLLENBQUMsK0NBQStDLENBQUMsQ0FBQTtZQUM5RCxPQUFPLElBQUksQ0FBQTtRQUNiLENBQUM7UUFDRCxJQUFJLENBQUMsU0FBUyxHQUFHLElBQUksQ0FBQTtRQUNyQixJQUFJLENBQUMsTUFBTSxDQUFDLGdCQUFnQixDQUFDLENBQUE7UUFDN0IsSUFBSSxDQUFDLFNBQVMsR0FBRyxDQUFDLElBQWEsRUFBRSxFQUFFO1lBQ2pDLElBQUksQ0FBQyxNQUFNLENBQUMsbUNBQW1DLENBQUMsQ0FBQTtZQUNoRCxJQUFJLENBQUMsSUFBSSxDQUFDLE1BQU0sRUFBRSxJQUFJLENBQUMsQ0FBQTtRQUN6QixDQUFDLENBQUE7UUFDRCxPQUFPLENBQUMsRUFBRSxDQUFDLFNBQVMsRUFBRSxJQUFJLENBQUMsU0FBUyxDQUFDLENBQUE7UUFJckMsSUFBSSxPQUFPLENBQUMsUUFBUSxLQUFLLEtBQUssRUFBRSxDQUFDO1lBQy9CLElBQUksQ0FBQyxZQUFZLEVBQUUsQ0FBQTtRQUNyQixDQUFDO1FBQ0QsT0FBTyxJQUFJLENBQUE7SUFDYixDQUFDO0lBRU8sWUFBWTtRQUdsQixJQUFJLENBQUMsY0FBYyxHQUFHLFdBQVcsQ0FBQyxHQUFHLEVBQUU7WUFDckMsSUFBSSxjQUFjLEdBQVEsQ0FBQyxPQUFPLENBQUMsUUFBUSxDQUFDLENBQUMsQ0FBQyxDQUFDLE9BQU8sQ0FBQyxNQUFNLENBQUMsT0FBTyxDQUFDLENBQUMsQ0FBQyxPQUFPLENBQUE7WUFFL0UsSUFBSSxjQUFjLENBQUMsaUJBQWlCLEVBQUUsQ0FBQyxNQUFNLEtBQUssQ0FBQyxFQUFFLENBQUM7Z0JBQ3BELElBQUksUUFBUSxHQUFRLGNBQWMsQ0FBQyxpQkFBaUIsRUFBRSxDQUFDLEdBQUcsQ0FBQyxDQUFDLENBQUMsRUFBRSxDQUFDLENBQUMsQ0FBQyxXQUFXLENBQUMsSUFBSSxDQUFDLENBQUE7Z0JBRW5GLElBQUksUUFBUSxDQUFDLFFBQVEsQ0FBQyxNQUFNLENBQUMsS0FBSyxJQUFJO29CQUNsQyxRQUFRLENBQUMsUUFBUSxDQUFDLFFBQVEsQ0FBQyxLQUFLLElBQUksRUFBRSxDQUFDO29CQUN6QyxPQUFPLENBQUMsY0FBYyxDQUFDLFNBQVMsRUFBRSxJQUFJLENBQUMsU0FBUyxDQUFDLENBQUE7b0JBQ2pELElBQUksR0FBRyxHQUFHLFVBQVUsQ0FBQyxDQUFDLENBQUMsRUFBRTt3QkFDdkIsSUFBSSxDQUFDLE1BQU0sQ0FBQyxpQ0FBaUMsQ0FBQyxDQUFBO3dCQUM5QyxPQUFPLENBQUMsRUFBRSxDQUFDLFNBQVMsRUFBRSxJQUFJLENBQUMsU0FBUyxDQUFDLENBQUE7b0JBQ3ZDLENBQUMsRUFBRSxHQUFHLENBQUMsQ0FBQTtvQkFDUCxHQUFHLENBQUMsS0FBSyxFQUFFLENBQUE7Z0JBQ2IsQ0FBQztZQUNILENBQUM7UUFDSCxDQUFDLEVBQUUsSUFBSSxDQUFDLENBQUE7UUFFUixJQUFJLENBQUMsY0FBYyxDQUFDLEtBQUssRUFBRSxDQUFBO0lBQzdCLENBQUM7SUFFRCxVQUFVLENBQUUsT0FBeUI7UUFDbkMsTUFBTSxnQkFBZ0IsR0FBRyxPQUFPLENBQUMsTUFBTSxDQUFDLENBQUMsTUFBTSxFQUFFLE1BQXNCLEVBQUUsRUFBRTtZQUN6RSxJQUFJLE9BQU8sTUFBTSxDQUFDLElBQUksS0FBSyxRQUFRO2dCQUFFLE9BQU8sTUFBTSxDQUFBO1lBQ2xELE1BQU0sQ0FBQyxNQUFNLENBQUMsSUFBSSxDQUFDLEdBQUc7Z0JBQ3BCLFFBQVEsRUFBRSxNQUFNLENBQUMsUUFBUTtnQkFDekIsSUFBSSxFQUFFLE1BQU0sQ0FBQyxJQUFJO2dCQUNqQixJQUFJLEVBQUUsTUFBTSxDQUFDLEVBQUU7Z0JBQ2YsS0FBSyxFQUFFLE1BQU0sQ0FBQyxLQUFLO2FBQ3BCLENBQUE7WUFDRCxPQUFPLE1BQU0sQ0FBQTtRQUNmLENBQUMsRUFBRSxFQUFFLENBQUMsQ0FBQTtRQUNOLElBQUksQ0FBQyxJQUFJLENBQUMsYUFBYSxFQUFFLGdCQUFnQixDQUFDLENBQUE7SUFDNUMsQ0FBQztJQUVELFNBQVMsQ0FBRSxNQUFjO1FBQ3ZCLElBQUksQ0FBQyxNQUFNLENBQUMsZUFBZSxNQUFNLENBQUMsSUFBSSxJQUFJLE1BQU0sQ0FBQyxJQUFJLEVBQUUsQ0FBQyxDQUFBO1FBQ3hELElBQUksQ0FBQyxJQUFJLENBQUMsWUFBWSxFQUFFO1lBQ3RCLFdBQVcsRUFBRSxNQUFNLENBQUMsSUFBSTtZQUN4QixXQUFXLEVBQUUsTUFBTSxDQUFDLElBQUk7WUFDeEIsS0FBSyxFQUFFLE1BQU0sQ0FBQyxLQUFLO1lBQ25CLElBQUksRUFBRSxNQUFNLENBQUMsSUFBSTtTQUNsQixDQUFDLENBQUE7SUFDSixDQUFDO0lBRUQsVUFBVSxDQUFFLE9BQU87UUFDakIsSUFBSSxDQUFDLE1BQU0sQ0FBQyxpQkFBaUIsTUFBTSxDQUFDLElBQUksQ0FBQyxPQUFPLENBQUMsQ0FBQyxJQUFJLENBQUMsR0FBRyxDQUFDLEdBQUcsQ0FBQyxDQUFBO1FBQy9ELE9BQU8sSUFBSSxDQUFDLElBQUksQ0FBQywwQkFBMEIsRUFBRSxPQUFPLENBQUMsQ0FBQTtJQUN2RCxDQUFDO0lBRUQsSUFBSSxDQUFFLE9BQU8sRUFBRSxPQUFPO1FBQ3BCLElBQUksT0FBTyxPQUFPLENBQUMsSUFBSSxLQUFLLFVBQVU7WUFBRSxPQUFPLENBQUMsQ0FBQyxDQUFBO1FBQ2pELElBQUksT0FBTyxDQUFDLFNBQVMsS0FBSyxLQUFLLEVBQUUsQ0FBQztZQUNoQyxPQUFPLENBQUMsS0FBSyxDQUFDLG1EQUFtRCxDQUFDLENBQUE7WUFDbEUsT0FBTyxPQUFPLENBQUMsSUFBSSxDQUFDLENBQUMsQ0FBQyxDQUFBO1FBQ3hCLENBQUM7UUFFRCxJQUFJLENBQUM7WUFDSCxPQUFPLENBQUMsSUFBSSxDQUFDLEVBQUUsSUFBSSxFQUFFLE9BQU8sRUFBRSxJQUFJLEVBQUUsT0FBTyxFQUFFLENBQUMsQ0FBQTtRQUNoRCxDQUFDO1FBQUMsT0FBTyxHQUFHLEVBQUUsQ0FBQztZQUNiLElBQUksQ0FBQyxNQUFNLENBQUMsb0NBQW9DLENBQUMsQ0FBQTtZQUNqRCxJQUFJLENBQUMsTUFBTSxDQUFDLEdBQUcsQ0FBQyxDQUFBO1lBQ2hCLE9BQU8sT0FBTyxDQUFDLElBQUksQ0FBQyxDQUFDLENBQUMsQ0FBQTtRQUN4QixDQUFDO0lBQ0gsQ0FBQztJQUVELE9BQU87UUFDTCxJQUFJLElBQUksQ0FBQyxTQUFTLEtBQUssU0FBUyxFQUFFLENBQUM7WUFDakMsT0FBTyxDQUFDLGNBQWMsQ0FBQyxTQUFTLEVBQUUsSUFBSSxDQUFDLFNBQVMsQ0FBQyxDQUFBO1FBQ25ELENBQUM7UUFDRCxJQUFJLElBQUksQ0FBQyxjQUFjLEtBQUssU0FBUyxFQUFFLENBQUM7WUFDdEMsYUFBYSxDQUFDLElBQUksQ0FBQyxjQUFjLENBQUMsQ0FBQTtRQUNwQyxDQUFDO1FBQ0QsSUFBSSxDQUFDLE1BQU0sQ0FBQyxTQUFTLENBQUMsQ0FBQTtJQUN4QixDQUFDO0NBQ0Y7QUEzR0Qsb0NBMkdDIn0=

api.hyungi.net/node_modules/@pm2/io/build/main/transports/WebsocketTransport.js

@@ -0,0 +1 @@
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiV2Vic29ja2V0VHJhbnNwb3J0LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL3RyYW5zcG9ydHMvV2Vic29ja2V0VHJhbnNwb3J0LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIifQ==

api.hyungi.net/node_modules/@pm2/io/build/main/utils/BinaryHeap.d.ts

@@ -0,0 +1,16 @@
+export default class BinaryHeap {
+    private _elements;
+    constructor(options: any);
+    add(): void;
+    first(): any;
+    removeFirst(): any;
+    clone(): BinaryHeap;
+    toSortedArray(): any[];
+    toArray(): never[];
+    size(): any;
+    _bubble(bubbleIndex: any): void;
+    _sink(sinkIndex: any): void;
+    _parentIndex(index: any): number;
+    _childIndexes(index: any): number[];
+    _score(element: any): any;
+}

api.hyungi.net/node_modules/@pm2/io/build/main/utils/BinaryHeap.js

@@ -0,0 +1,109 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class BinaryHeap {
+    constructor(options) {
+        options = options || {};
+        this._elements = options.elements || [];
+        this._score = options.score || this._score;
+    }
+    add() {
+        for (let i = 0; i < arguments.length; i++) {
+            const element = arguments[i];
+            this._elements.push(element);
+            this._bubble(this._elements.length - 1);
+        }
+    }
+    first() {
+        return this._elements[0];
+    }
+    removeFirst() {
+        const root = this._elements[0];
+        const last = this._elements.pop();
+        if (this._elements.length > 0) {
+            this._elements[0] = last;
+            this._sink(0);
+        }
+        return root;
+    }
+    clone() {
+        return new BinaryHeap({
+            elements: this.toArray(),
+            score: this._score
+        });
+    }
+    toSortedArray() {
+        const array = [];
+        const clone = this.clone();
+        while (true) {
+            const element = clone.removeFirst();
+            if (element === undefined)
+                break;
+            array.push(element);
+        }
+        return array;
+    }
+    toArray() {
+        return [].concat(this._elements);
+    }
+    size() {
+        return this._elements.length;
+    }
+    _bubble(bubbleIndex) {
+        const bubbleElement = this._elements[bubbleIndex];
+        const bubbleScore = this._score(bubbleElement);
+        while (bubbleIndex > 0) {
+            const parentIndex = this._parentIndex(bubbleIndex);
+            const parentElement = this._elements[parentIndex];
+            const parentScore = this._score(parentElement);
+            if (bubbleScore <= parentScore)
+                break;
+            this._elements[parentIndex] = bubbleElement;
+            this._elements[bubbleIndex] = parentElement;
+            bubbleIndex = parentIndex;
+        }
+    }
+    _sink(sinkIndex) {
+        const sinkElement = this._elements[sinkIndex];
+        const sinkScore = this._score(sinkElement);
+        const length = this._elements.length;
+        while (true) {
+            let swapIndex;
+            let swapScore;
+            let swapElement = null;
+            const childIndexes = this._childIndexes(sinkIndex);
+            for (let i = 0; i < childIndexes.length; i++) {
+                const childIndex = childIndexes[i];
+                if (childIndex >= length)
+                    break;
+                const childElement = this._elements[childIndex];
+                const childScore = this._score(childElement);
+                if (childScore > sinkScore) {
+                    if (swapScore === undefined || swapScore < childScore) {
+                        swapIndex = childIndex;
+                        swapScore = childScore;
+                        swapElement = childElement;
+                    }
+                }
+            }
+            if (swapIndex === undefined)
+                break;
+            this._elements[swapIndex] = sinkElement;
+            this._elements[sinkIndex] = swapElement;
+            sinkIndex = swapIndex;
+        }
+    }
+    _parentIndex(index) {
+        return Math.floor((index - 1) / 2);
+    }
+    _childIndexes(index) {
+        return [
+            2 * index + 1,
+            2 * index + 2
+        ];
+    }
+    _score(element) {
+        return element.valueOf();
+    }
+}
+exports.default = BinaryHeap;
+//# sourceMappingURL=data:application/json;base64,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

api.hyungi.net/node_modules/@pm2/io/build/main/utils/EDS.d.ts

@@ -0,0 +1,21 @@
+export default class ExponentiallyDecayingSample {
+    private RESCALE_INTERVAL;
+    private ALPHA;
+    private SIZE;
+    private _elements;
+    private _rescaleInterval;
+    private _alpha;
+    private _size;
+    private _landmark;
+    private _nextRescale;
+    private _mean;
+    constructor(options?: any);
+    update(value: any, timestamp?: any): void;
+    toSortedArray(): any;
+    toArray(): any;
+    _weight(age: any): number;
+    _priority(age: any): number;
+    _random(): number;
+    _rescale(now: any): void;
+    avg(now: any): number;
+}

api.hyungi.net/node_modules/@pm2/io/build/main/utils/EDS.js

@@ -0,0 +1,93 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const BinaryHeap_1 = require("./BinaryHeap");
+const units_1 = require("./units");
+class ExponentiallyDecayingSample {
+    constructor(options) {
+        this.RESCALE_INTERVAL = 1 * units_1.default.HOURS;
+        this.ALPHA = 0.015;
+        this.SIZE = 1028;
+        options = options || {};
+        this._elements = new BinaryHeap_1.default({
+            score: function (element) {
+                return -element.priority;
+            }
+        });
+        this._rescaleInterval = options.rescaleInterval || this.RESCALE_INTERVAL;
+        this._alpha = options.alpha || this.ALPHA;
+        this._size = options.size || this.SIZE;
+        this._random = options.random || this._random;
+        this._landmark = null;
+        this._nextRescale = null;
+        this._mean = null;
+    }
+    update(value, timestamp) {
+        const now = Date.now();
+        if (!this._landmark) {
+            this._landmark = now;
+            this._nextRescale = this._landmark + this._rescaleInterval;
+        }
+        timestamp = timestamp || now;
+        const newSize = this._elements.size() + 1;
+        const element = {
+            priority: this._priority(timestamp - this._landmark),
+            value: value
+        };
+        if (newSize <= this._size) {
+            this._elements.add(element);
+        }
+        else if (element.priority > this._elements.first().priority) {
+            this._elements.removeFirst();
+            this._elements.add(element);
+        }
+        if (now >= this._nextRescale)
+            this._rescale(now);
+    }
+    toSortedArray() {
+        return this._elements
+            .toSortedArray()
+            .map(function (element) {
+            return element.value;
+        });
+    }
+    toArray() {
+        return this._elements
+            .toArray()
+            .map(function (element) {
+            return element.value;
+        });
+    }
+    _weight(age) {
+        return Math.exp(this._alpha * (age / 1000));
+    }
+    _priority(age) {
+        return this._weight(age) / this._random();
+    }
+    _random() {
+        return Math.random();
+    }
+    _rescale(now) {
+        now = now || Date.now();
+        const self = this;
+        const oldLandmark = this._landmark;
+        this._landmark = now || Date.now();
+        this._nextRescale = now + this._rescaleInterval;
+        const factor = self._priority(-(self._landmark - oldLandmark));
+        this._elements
+            .toArray()
+            .forEach(function (element) {
+            element.priority *= factor;
+        });
+    }
+    avg(now) {
+        let sum = 0;
+        this._elements
+            .toArray()
+            .forEach(function (element) {
+            sum += element.value;
+        });
+        return (sum / this._elements.size());
+    }
+}
+exports.default = ExponentiallyDecayingSample;
+//# sourceMappingURL=data:application/json;base64,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

api.hyungi.net/node_modules/@pm2/io/build/main/utils/EWMA.d.ts

@@ -0,0 +1,12 @@
+export default class ExponentiallyWeightedMovingAverage {
+    private _timePeriod;
+    private _tickInterval;
+    private _alpha;
+    private _count;
+    private _rate;
+    private TICK_INTERVAL;
+    constructor(timePeriod?: number, tickInterval?: number);
+    update(n: any): void;
+    tick(): void;
+    rate(timeUnit: any): number;
+}

api.hyungi.net/node_modules/@pm2/io/build/main/utils/EWMA.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const units_1 = require("./units");
+class ExponentiallyWeightedMovingAverage {
+    constructor(timePeriod, tickInterval) {
+        this._count = 0;
+        this._rate = 0;
+        this.TICK_INTERVAL = 5 * units_1.default.SECONDS;
+        this._timePeriod = timePeriod || 1 * units_1.default.MINUTES;
+        this._tickInterval = tickInterval || this.TICK_INTERVAL;
+        this._alpha = 1 - Math.exp(-this._tickInterval / this._timePeriod);
+    }
+    update(n) {
+        this._count += n;
+    }
+    tick() {
+        const instantRate = this._count / this._tickInterval;
+        this._count = 0;
+        this._rate += (this._alpha * (instantRate - this._rate));
+    }
+    rate(timeUnit) {
+        return (this._rate || 0) * timeUnit;
+    }
+}
+exports.default = ExponentiallyWeightedMovingAverage;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiRVdNQS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy91dGlscy9FV01BLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7O0FBQUEsbUNBQTJCO0FBRTNCLE1BQXFCLGtDQUFrQztJQVNyRCxZQUFhLFVBQW1CLEVBQUUsWUFBcUI7UUFML0MsV0FBTSxHQUFXLENBQUMsQ0FBQTtRQUNsQixVQUFLLEdBQVcsQ0FBQyxDQUFBO1FBRWpCLGtCQUFhLEdBQVcsQ0FBQyxHQUFHLGVBQUssQ0FBQyxPQUFPLENBQUE7UUFHL0MsSUFBSSxDQUFDLFdBQVcsR0FBRyxVQUFVLElBQUksQ0FBQyxHQUFHLGVBQUssQ0FBQyxPQUFPLENBQUE7UUFDbEQsSUFBSSxDQUFDLGFBQWEsR0FBRyxZQUFZLElBQUksSUFBSSxDQUFDLGFBQWEsQ0FBQTtRQUN2RCxJQUFJLENBQUMsTUFBTSxHQUFHLENBQUMsR0FBRyxJQUFJLENBQUMsR0FBRyxDQUFDLENBQUMsSUFBSSxDQUFDLGFBQWEsR0FBRyxJQUFJLENBQUMsV0FBVyxDQUFDLENBQUE7SUFDcEUsQ0FBQztJQUVELE1BQU0sQ0FBRSxDQUFDO1FBQ1AsSUFBSSxDQUFDLE1BQU0sSUFBSSxDQUFDLENBQUE7SUFDbEIsQ0FBQztJQUVELElBQUk7UUFDRixNQUFNLFdBQVcsR0FBRyxJQUFJLENBQUMsTUFBTSxHQUFHLElBQUksQ0FBQyxhQUFhLENBQUE7UUFDcEQsSUFBSSxDQUFDLE1BQU0sR0FBRyxDQUFDLENBQUE7UUFFZixJQUFJLENBQUMsS0FBSyxJQUFJLENBQUMsSUFBSSxDQUFDLE1BQU0sR0FBRyxDQUFDLFdBQVcsR0FBRyxJQUFJLENBQUMsS0FBSyxDQUFDLENBQUMsQ0FBQTtJQUMxRCxDQUFDO0lBRUQsSUFBSSxDQUFFLFFBQVE7UUFDWixPQUFPLENBQUMsSUFBSSxDQUFDLEtBQUssSUFBSSxDQUFDLENBQUMsR0FBRyxRQUFRLENBQUE7SUFDckMsQ0FBQztDQUNGO0FBN0JELHFEQTZCQyJ9

api.hyungi.net/node_modules/@pm2/io/build/main/utils/autocast.d.ts

@@ -0,0 +1,13 @@
+export default class Autocast {
+    commonStrings: {
+        true: boolean;
+        false: boolean;
+        undefined: undefined;
+        null: null;
+        NaN: number;
+    };
+    process(key: any, value: any, o: any): void;
+    traverse(o: any, func: any): void;
+    autocast(s: any): any;
+    private _cast;
+}

api.hyungi.net/node_modules/@pm2/io/build/main/utils/autocast.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class Autocast {
+    constructor() {
+        this.commonStrings = {
+            'true': true,
+            'false': false,
+            'undefined': undefined,
+            'null': null,
+            'NaN': NaN
+        };
+    }
+    process(key, value, o) {
+        if (typeof (value) === 'object')
+            return;
+        o[key] = this._cast(value);
+    }
+    traverse(o, func) {
+        for (let i in o) {
+            func.apply(this, [i, o[i], o]);
+            if (o[i] !== null && typeof (o[i]) === 'object') {
+                this.traverse(o[i], func);
+            }
+        }
+    }
+    autocast(s) {
+        if (typeof (s) === 'object') {
+            this.traverse(s, this.process);
+            return s;
+        }
+        return this._cast(s);
+    }
+    _cast(s) {
+        let key;
+        if (s instanceof Date)
+            return s;
+        if (typeof s === 'boolean')
+            return s;
+        if (!isNaN(s))
+            return Number(s);
+        for (key in this.commonStrings) {
+            if (s === key)
+                return this.commonStrings[key];
+        }
+        return s;
+    }
+}
+exports.default = Autocast;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXV0b2Nhc3QuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvdXRpbHMvYXV0b2Nhc3QudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7QUFBQSxNQUFxQixRQUFRO0lBQTdCO1FBSUUsa0JBQWEsR0FBRztZQUNkLE1BQU0sRUFBRSxJQUFJO1lBQ1osT0FBTyxFQUFFLEtBQUs7WUFDZCxXQUFXLEVBQUUsU0FBUztZQUN0QixNQUFNLEVBQUUsSUFBSTtZQUNaLEtBQUssRUFBRSxHQUFHO1NBQ1gsQ0FBQTtJQStDSCxDQUFDO0lBN0NDLE9BQU8sQ0FBRSxHQUFHLEVBQUMsS0FBSyxFQUFFLENBQUM7UUFDbkIsSUFBSSxPQUFNLENBQUMsS0FBSyxDQUFDLEtBQUssUUFBUTtZQUFFLE9BQU07UUFDdEMsQ0FBQyxDQUFDLEdBQUcsQ0FBQyxHQUFHLElBQUksQ0FBQyxLQUFLLENBQUMsS0FBSyxDQUFDLENBQUE7SUFDNUIsQ0FBQztJQUVELFFBQVEsQ0FBRSxDQUFDLEVBQUMsSUFBSTtRQUNkLEtBQUssSUFBSSxDQUFDLElBQUksQ0FBQyxFQUFFLENBQUM7WUFDaEIsSUFBSSxDQUFDLEtBQUssQ0FBQyxJQUFJLEVBQUMsQ0FBQyxDQUFDLEVBQUMsQ0FBQyxDQUFDLENBQUMsQ0FBQyxFQUFFLENBQUMsQ0FBQyxDQUFDLENBQUE7WUFDNUIsSUFBSSxDQUFDLENBQUMsQ0FBQyxDQUFDLEtBQUssSUFBSSxJQUFJLE9BQU0sQ0FBQyxDQUFDLENBQUMsQ0FBQyxDQUFDLENBQUMsS0FBSyxRQUFRLEVBQUUsQ0FBQztnQkFFL0MsSUFBSSxDQUFDLFFBQVEsQ0FBQyxDQUFDLENBQUMsQ0FBQyxDQUFDLEVBQUMsSUFBSSxDQUFDLENBQUE7WUFDMUIsQ0FBQztRQUNILENBQUM7SUFDSCxDQUFDO0lBS0QsUUFBUSxDQUFFLENBQUM7UUFDVCxJQUFJLE9BQU0sQ0FBQyxDQUFDLENBQUMsS0FBSyxRQUFRLEVBQUUsQ0FBQztZQUMzQixJQUFJLENBQUMsUUFBUSxDQUFDLENBQUMsRUFBRSxJQUFJLENBQUMsT0FBTyxDQUFDLENBQUE7WUFDOUIsT0FBTyxDQUFDLENBQUE7UUFDVixDQUFDO1FBRUQsT0FBTyxJQUFJLENBQUMsS0FBSyxDQUFDLENBQUMsQ0FBQyxDQUFBO0lBQ3RCLENBQUM7SUFFTyxLQUFLLENBQUUsQ0FBQztRQUNkLElBQUksR0FBRyxDQUFBO1FBR1AsSUFBSSxDQUFDLFlBQVksSUFBSTtZQUFFLE9BQU8sQ0FBQyxDQUFBO1FBQy9CLElBQUksT0FBTyxDQUFDLEtBQUssU0FBUztZQUFFLE9BQU8sQ0FBQyxDQUFBO1FBR3BDLElBQUksQ0FBQyxLQUFLLENBQUMsQ0FBQyxDQUFDO1lBQUUsT0FBTyxNQUFNLENBQUMsQ0FBQyxDQUFDLENBQUE7UUFHL0IsS0FBSyxHQUFHLElBQUksSUFBSSxDQUFDLGFBQWEsRUFBRSxDQUFDO1lBQy9CLElBQUksQ0FBQyxLQUFLLEdBQUc7Z0JBQUUsT0FBTyxJQUFJLENBQUMsYUFBYSxDQUFDLEdBQUcsQ0FBQyxDQUFBO1FBQy9DLENBQUM7UUFHRCxPQUFPLENBQUMsQ0FBQTtJQUNWLENBQUM7Q0FDRjtBQXpERCwyQkF5REMifQ==

api.hyungi.net/node_modules/@pm2/io/build/main/utils/metrics/counter.d.ts

@@ -0,0 +1,10 @@
+export default class Counter {
+    private _count;
+    private used;
+    constructor(opts?: any);
+    val(): number;
+    inc(n?: number): void;
+    dec(n?: number): void;
+    reset(count?: number): void;
+    isUsed(): boolean;
+}

api.hyungi.net/node_modules/@pm2/io/build/main/utils/metrics/counter.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class Counter {
+    constructor(opts) {
+        this.used = false;
+        opts = opts || {};
+        this._count = opts.count || 0;
+    }
+    val() {
+        return this._count;
+    }
+    inc(n) {
+        this.used = true;
+        this._count += (n || 1);
+    }
+    dec(n) {
+        this.used = true;
+        this._count -= (n || 1);
+    }
+    reset(count) {
+        this._count = count || 0;
+    }
+    isUsed() {
+        return this.used;
+    }
+}
+exports.default = Counter;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY291bnRlci5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy91dGlscy9tZXRyaWNzL2NvdW50ZXIudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7QUFBQSxNQUFxQixPQUFPO0lBSTFCLFlBQWEsSUFBSztRQUZWLFNBQUksR0FBWSxLQUFLLENBQUE7UUFHM0IsSUFBSSxHQUFHLElBQUksSUFBSSxFQUFFLENBQUE7UUFDakIsSUFBSSxDQUFDLE1BQU0sR0FBRyxJQUFJLENBQUMsS0FBSyxJQUFJLENBQUMsQ0FBQTtJQUMvQixDQUFDO0lBRUQsR0FBRztRQUNELE9BQU8sSUFBSSxDQUFDLE1BQU0sQ0FBQTtJQUNwQixDQUFDO0lBRUQsR0FBRyxDQUFFLENBQVU7UUFDYixJQUFJLENBQUMsSUFBSSxHQUFHLElBQUksQ0FBQTtRQUNoQixJQUFJLENBQUMsTUFBTSxJQUFJLENBQUMsQ0FBQyxJQUFJLENBQUMsQ0FBQyxDQUFBO0lBQ3pCLENBQUM7SUFFRCxHQUFHLENBQUUsQ0FBVTtRQUNiLElBQUksQ0FBQyxJQUFJLEdBQUcsSUFBSSxDQUFBO1FBQ2hCLElBQUksQ0FBQyxNQUFNLElBQUksQ0FBQyxDQUFDLElBQUksQ0FBQyxDQUFDLENBQUE7SUFDekIsQ0FBQztJQUVELEtBQUssQ0FBRSxLQUFjO1FBQ25CLElBQUksQ0FBQyxNQUFNLEdBQUcsS0FBSyxJQUFJLENBQUMsQ0FBQTtJQUMxQixDQUFDO0lBRUQsTUFBTTtRQUNKLE9BQU8sSUFBSSxDQUFDLElBQUksQ0FBQTtJQUNsQixDQUFDO0NBQ0Y7QUE5QkQsMEJBOEJDIn0=

api.hyungi.net/node_modules/@pm2/io/build/main/utils/metrics/gauge.d.ts

@@ -0,0 +1,7 @@
+export default class Gauge {
+    private value;
+    private used;
+    val(): number;
+    set(value: any): void;
+    isUsed(): boolean;
+}

api.hyungi.net/node_modules/@pm2/io/build/main/utils/metrics/gauge.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class Gauge {
+    constructor() {
+        this.value = 0;
+        this.used = false;
+    }
+    val() {
+        return this.value;
+    }
+    set(value) {
+        this.used = true;
+        this.value = value;
+    }
+    isUsed() {
+        return this.used;
+    }
+}
+exports.default = Gauge;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZ2F1Z2UuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvdXRpbHMvbWV0cmljcy9nYXVnZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOztBQUFBLE1BQXFCLEtBQUs7SUFBMUI7UUFDVSxVQUFLLEdBQUcsQ0FBQyxDQUFBO1FBQ1QsU0FBSSxHQUFHLEtBQUssQ0FBQTtJQWN0QixDQUFDO0lBWkMsR0FBRztRQUNELE9BQU8sSUFBSSxDQUFDLEtBQUssQ0FBQTtJQUNuQixDQUFDO0lBRUQsR0FBRyxDQUFFLEtBQUs7UUFDUixJQUFJLENBQUMsSUFBSSxHQUFHLElBQUksQ0FBQTtRQUNoQixJQUFJLENBQUMsS0FBSyxHQUFHLEtBQUssQ0FBQTtJQUNwQixDQUFDO0lBRUQsTUFBTTtRQUNKLE9BQU8sSUFBSSxDQUFDLElBQUksQ0FBQTtJQUNsQixDQUFDO0NBQ0Y7QUFoQkQsd0JBZ0JDIn0=

api.hyungi.net/node_modules/@pm2/io/build/main/utils/metrics/histogram.d.ts

@@ -0,0 +1,43 @@
+export default class Histogram {
+    private _measurement;
+    private _callFn;
+    private _sample;
+    private _min;
+    private _max;
+    private _count;
+    private _sum;
+    private _varianceM;
+    private _varianceS;
+    private _ema;
+    private used;
+    constructor(opts?: any);
+    update(value: number): void;
+    percentiles(percentiles: any): {};
+    val(): any;
+    getMin(): any;
+    getMax(): any;
+    getSum(): number;
+    getCount(): number;
+    getEma(): number;
+    fullResults(): {
+        min: any;
+        max: any;
+        sum: number;
+        variance: number | null;
+        mean: number;
+        count: number;
+        median: any;
+        p75: any;
+        p95: any;
+        p99: any;
+        p999: any;
+        ema: number;
+    };
+    _updateMin(value: any): void;
+    _updateMax(value: any): void;
+    _updateVariance(value: any): any;
+    _updateEma(value: any): number | undefined;
+    _calculateMean(): number;
+    _calculateVariance(): number | null;
+    isUsed(): boolean;
+}

api.hyungi.net/node_modules/@pm2/io/build/main/utils/metrics/meter.d.ts

@@ -0,0 +1,12 @@
+export default class Meter {
+    private _tickInterval;
+    private _samples;
+    private _timeframe;
+    private _rate;
+    private _interval;
+    private used;
+    constructor(opts?: any);
+    mark: (n?: number) => void;
+    val: () => number;
+    isUsed(): boolean;
+}

api.hyungi.net/node_modules/@pm2/io/build/main/utils/metrics/meter.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const EWMA_1 = require("../EWMA");
+const units_1 = require("../units");
+class Meter {
+    constructor(opts) {
+        this.used = false;
+        this.mark = function (n = 1) {
+            this.used = true;
+            this._rate.update(n);
+        };
+        this.val = function () {
+            return Math.round(this._rate.rate(this._samples * units_1.default.SECONDS) * 100) / 100;
+        };
+        const self = this;
+        if (typeof opts !== 'object') {
+            opts = {};
+        }
+        this._samples = opts.samples || opts.seconds || 1;
+        this._timeframe = opts.timeframe || 60;
+        this._tickInterval = opts.tickInterval || 5 * units_1.default.SECONDS;
+        this._rate = new EWMA_1.default(this._timeframe * units_1.default.SECONDS, this._tickInterval);
+        if (opts.debug && opts.debug === true) {
+            return;
+        }
+        this._interval = setInterval(function () {
+            self._rate.tick();
+        }, this._tickInterval);
+        this._interval.unref();
+    }
+    isUsed() {
+        return this.used;
+    }
+}
+exports.default = Meter;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibWV0ZXIuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvdXRpbHMvbWV0cmljcy9tZXRlci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOztBQUFBLGtDQUEwQjtBQUMxQixvQ0FBNEI7QUFFNUIsTUFBcUIsS0FBSztJQVN4QixZQUFhLElBQVU7UUFGZixTQUFJLEdBQVksS0FBSyxDQUFBO1FBMEI3QixTQUFJLEdBQUcsVUFBVSxJQUFZLENBQUM7WUFDNUIsSUFBSSxDQUFDLElBQUksR0FBRyxJQUFJLENBQUE7WUFDaEIsSUFBSSxDQUFDLEtBQUssQ0FBQyxNQUFNLENBQUMsQ0FBQyxDQUFDLENBQUE7UUFDdEIsQ0FBQyxDQUFBO1FBRUQsUUFBRyxHQUFHO1lBQ0osT0FBTyxJQUFJLENBQUMsS0FBSyxDQUFDLElBQUksQ0FBQyxLQUFLLENBQUMsSUFBSSxDQUFDLElBQUksQ0FBQyxRQUFRLEdBQUcsZUFBSyxDQUFDLE9BQU8sQ0FBQyxHQUFHLEdBQUcsQ0FBQyxHQUFHLEdBQUcsQ0FBQTtRQUMvRSxDQUFDLENBQUE7UUE5QkMsTUFBTSxJQUFJLEdBQUcsSUFBSSxDQUFBO1FBRWpCLElBQUksT0FBTyxJQUFJLEtBQUssUUFBUSxFQUFFLENBQUM7WUFDN0IsSUFBSSxHQUFHLEVBQUUsQ0FBQTtRQUNYLENBQUM7UUFFRCxJQUFJLENBQUMsUUFBUSxHQUFHLElBQUksQ0FBQyxPQUFPLElBQUksSUFBSSxDQUFDLE9BQU8sSUFBSSxDQUFDLENBQUE7UUFDakQsSUFBSSxDQUFDLFVBQVUsR0FBRyxJQUFJLENBQUMsU0FBUyxJQUFJLEVBQUUsQ0FBQTtRQUN0QyxJQUFJLENBQUMsYUFBYSxHQUFHLElBQUksQ0FBQyxZQUFZLElBQUksQ0FBQyxHQUFHLGVBQUssQ0FBQyxPQUFPLENBQUE7UUFFM0QsSUFBSSxDQUFDLEtBQUssR0FBRyxJQUFJLGNBQUksQ0FBQyxJQUFJLENBQUMsVUFBVSxHQUFHLGVBQUssQ0FBQyxPQUFPLEVBQUUsSUFBSSxDQUFDLGFBQWEsQ0FBQyxDQUFBO1FBRTFFLElBQUksSUFBSSxDQUFDLEtBQUssSUFBSSxJQUFJLENBQUMsS0FBSyxLQUFLLElBQUksRUFBRSxDQUFDO1lBQ3RDLE9BQU07UUFDUixDQUFDO1FBRUQsSUFBSSxDQUFDLFNBQVMsR0FBRyxXQUFXLENBQUM7WUFDM0IsSUFBSSxDQUFDLEtBQUssQ0FBQyxJQUFJLEVBQUUsQ0FBQTtRQUNuQixDQUFDLEVBQUUsSUFBSSxDQUFDLGFBQWEsQ0FBQyxDQUFBO1FBRXRCLElBQUksQ0FBQyxTQUFTLENBQUMsS0FBSyxFQUFFLENBQUE7SUFDeEIsQ0FBQztJQVdELE1BQU07UUFDSixPQUFPLElBQUksQ0FBQyxJQUFJLENBQUE7SUFDbEIsQ0FBQztDQUNGO0FBN0NELHdCQTZDQyJ9

api.hyungi.net/node_modules/@pm2/io/build/main/utils/miscellaneous.d.ts

@@ -0,0 +1,4 @@
+export default class MiscUtils {
+    static generateUUID(): string;
+    static getValueFromDump(property: any, parentProperty?: any): number;
+}

api.hyungi.net/node_modules/@pm2/io/build/main/utils/miscellaneous.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const serviceManager_1 = require("../serviceManager");
+class MiscUtils {
+    static generateUUID() {
+        return Math.random().toString(36).substr(2, 16);
+    }
+    static getValueFromDump(property, parentProperty) {
+        if (!parentProperty) {
+            parentProperty = 'handles';
+        }
+        const dump = serviceManager_1.ServiceManager.get('eventLoopService').inspector.dump();
+        return dump[parentProperty].hasOwnProperty(property) ? dump[parentProperty][property].length : 0;
+    }
+}
+exports.default = MiscUtils;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibWlzY2VsbGFuZW91cy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy91dGlscy9taXNjZWxsYW5lb3VzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7O0FBQUEsc0RBQWtEO0FBRWxELE1BQXFCLFNBQVM7SUFDNUIsTUFBTSxDQUFDLFlBQVk7UUFDakIsT0FBTyxJQUFJLENBQUMsTUFBTSxFQUFFLENBQUMsUUFBUSxDQUFDLEVBQUUsQ0FBQyxDQUFDLE1BQU0sQ0FBQyxDQUFDLEVBQUUsRUFBRSxDQUFDLENBQUE7SUFDakQsQ0FBQztJQUVELE1BQU0sQ0FBQyxnQkFBZ0IsQ0FBRSxRQUFRLEVBQUUsY0FBZTtRQUNoRCxJQUFJLENBQUMsY0FBYyxFQUFFLENBQUM7WUFDcEIsY0FBYyxHQUFHLFNBQVMsQ0FBQTtRQUM1QixDQUFDO1FBQ0QsTUFBTSxJQUFJLEdBQUcsK0JBQWMsQ0FBQyxHQUFHLENBQUMsa0JBQWtCLENBQUMsQ0FBQyxTQUFTLENBQUMsSUFBSSxFQUFFLENBQUE7UUFDcEUsT0FBTyxJQUFJLENBQUMsY0FBYyxDQUFDLENBQUMsY0FBYyxDQUFDLFFBQVEsQ0FBQyxDQUFDLENBQUMsQ0FBQyxJQUFJLENBQUMsY0FBYyxDQUFDLENBQUMsUUFBUSxDQUFDLENBQUMsTUFBTSxDQUFDLENBQUMsQ0FBQyxDQUFDLENBQUE7SUFDbEcsQ0FBQztDQUNGO0FBWkQsNEJBWUMifQ==

api.hyungi.net/node_modules/@pm2/io/build/main/utils/module.d.ts

@@ -0,0 +1,5 @@
+export default class ModuleUtils {
+    static loadModule(modulePath: string, args?: Object): any | Error;
+    static detectModule(moduleName: string): string | null;
+    private static _lookForModule;
+}

api.hyungi.net/node_modules/@pm2/io/build/main/utils/module.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs = require("fs");
+const Debug = require("debug");
+const path = require("path");
+const debug = Debug('axm:utils:module');
+class ModuleUtils {
+    static loadModule(modulePath, args) {
+        let nodule;
+        try {
+            if (args) {
+                nodule = require(modulePath).apply(this, args);
+            }
+            else {
+                nodule = require(modulePath);
+            }
+            debug(`Succesfully required module at path ${modulePath}`);
+            return nodule;
+        }
+        catch (err) {
+            debug(`Failed to load module at path ${modulePath}: ${err.message}`);
+            return err;
+        }
+    }
+    static detectModule(moduleName) {
+        const fakePath = ['./node_modules', '/node_modules'];
+        if (!require.main) {
+            return null;
+        }
+        const paths = typeof require.main.paths === 'undefined' ? fakePath : require.main.paths;
+        const requirePaths = paths.slice();
+        return ModuleUtils._lookForModule(requirePaths, moduleName);
+    }
+    static _lookForModule(requirePaths, moduleName) {
+        const fsConstants = fs.constants || fs;
+        for (let requirePath of requirePaths) {
+            const completePath = path.join(requirePath, moduleName);
+            debug(`Looking for module ${moduleName} in ${completePath}`);
+            try {
+                fs.accessSync(completePath, fsConstants.R_OK);
+                debug(`Found module ${moduleName} in path ${completePath}`);
+                return completePath;
+            }
+            catch (err) {
+                debug(`module ${moduleName} not found in path ${completePath}`);
+                continue;
+            }
+        }
+        return null;
+    }
+}
+exports.default = ModuleUtils;
+//# sourceMappingURL=data:application/json;base64,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

api.hyungi.net/node_modules/@pm2/io/build/main/utils/stackParser.d.ts

@@ -0,0 +1,37 @@
+export type MissFunction = (key: string) => any;
+export type CacheOptions = {
+    miss: MissFunction;
+    ttl?: number;
+};
+export type StackContext = {
+    callsite: string;
+    context: string;
+};
+export type FrameMetadata = {
+    line_number: number;
+    file_name: string;
+};
+export declare class Cache {
+    private cache;
+    private ttlCache;
+    private worker;
+    private tllTime;
+    private onMiss;
+    constructor(opts: CacheOptions);
+    workerFn(): void;
+    get(key: string): any;
+    set(key: string, value: any): boolean;
+    reset(): void;
+}
+export type StackTraceParserOptions = {
+    cache: Cache;
+    contextSize: number;
+};
+export declare class StackTraceParser {
+    private cache;
+    private contextSize;
+    constructor(options: StackTraceParserOptions);
+    isAbsolute(path: any): boolean;
+    parse(stack: FrameMetadata[]): StackContext | null;
+    retrieveContext(error: Error): StackContext | null;
+}

api.hyungi.net/node_modules/@pm2/io/build/main/utils/transactionAggregator.d.ts

@@ -0,0 +1,74 @@
+import { EventEmitter2 } from 'eventemitter2';
+import EWMA from './EWMA';
+import Histogram from './metrics/histogram';
+export interface Span {
+    name: string;
+    labels: any;
+    kind: string;
+    startTime: number;
+    min: number;
+    max: number;
+    median: number;
+}
+export interface Variance {
+    spans: Span[];
+    count: number;
+    min: number;
+    max: number;
+    median: number;
+    p95: number;
+}
+export interface Route {
+    path: string;
+    meta: {
+        min: number;
+        max: number;
+        count: number;
+        meter: number;
+        median: number;
+        p95: number;
+    };
+    variances: Variance[];
+}
+export interface Trace {
+    routes: Route[];
+    meta: {
+        trace_count: number;
+        http_meter: number;
+        db_meter: number;
+        http_percentiles: {
+            median: number;
+            p95: number;
+            p99: number;
+        };
+        db_percentiles: any;
+    };
+}
+export interface TraceCache {
+    routes: any;
+    meta: {
+        trace_count: number;
+        http_meter: EWMA;
+        db_meter: EWMA;
+        histogram: Histogram;
+        db_histograms: any;
+    };
+}
+export declare class TransactionAggregator extends EventEmitter2 {
+    private spanTypes;
+    private cache;
+    private privacyRegex;
+    private worker;
+    init(sendInterval?: number): void;
+    destroy(): void;
+    getAggregation(): TraceCache;
+    validateData(packet: any): boolean;
+    aggregate(packet: any): false | TraceCache;
+    mergeTrace(aggregated: any, trace: any): void;
+    updateSpanDuration(spans: any, newSpans: any): void;
+    compareList(one: any[], two: any[]): boolean;
+    matchPath(path: any, routes: any): any;
+    prepareAggregationforShipping(): Trace;
+    isIdentifier(id: any): boolean;
+    censorSpans(spans: any): any;
+}

api.hyungi.net/node_modules/@pm2/io/build/main/utils/units.d.ts

@@ -0,0 +1,10 @@
+declare const _default: {
+    NANOSECONDS: number;
+    MICROSECONDS: number;
+    MILLISECONDS: number;
+    SECONDS: number;
+    MINUTES: number;
+    HOURS: number;
+    DAYS: number;
+};
+export default _default;

api.hyungi.net/node_modules/@pm2/io/build/main/utils/units.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const MILLISECONDS = 1;
+const SECONDS = 1000 * MILLISECONDS;
+const MINUTES = 60 * SECONDS;
+const HOURS = 60 * MINUTES;
+exports.default = {
+    NANOSECONDS: 1 / (1000 * 1000),
+    MICROSECONDS: 1 / 1000,
+    MILLISECONDS: MILLISECONDS,
+    SECONDS: SECONDS,
+    MINUTES: MINUTES,
+    HOURS: HOURS,
+    DAYS: 24 * HOURS
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidW5pdHMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvdXRpbHMvdW5pdHMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7QUFBQSxNQUFNLFlBQVksR0FBRyxDQUFDLENBQUE7QUFDdEIsTUFBTSxPQUFPLEdBQUcsSUFBSSxHQUFHLFlBQVksQ0FBQTtBQUNuQyxNQUFNLE9BQU8sR0FBRyxFQUFFLEdBQUcsT0FBTyxDQUFBO0FBQzVCLE1BQU0sS0FBSyxHQUFHLEVBQUUsR0FBRyxPQUFPLENBQUE7QUFFMUIsa0JBQWU7SUFDYixXQUFXLEVBQUUsQ0FBQyxHQUFHLENBQUMsSUFBSSxHQUFHLElBQUksQ0FBQztJQUM5QixZQUFZLEVBQUUsQ0FBQyxHQUFHLElBQUk7SUFDdEIsWUFBWSxFQUFFLFlBQVk7SUFDMUIsT0FBTyxFQUFFLE9BQU87SUFDaEIsT0FBTyxFQUFFLE9BQU87SUFDaEIsS0FBSyxFQUFFLEtBQUs7SUFDWixJQUFJLEVBQUUsRUFBRSxHQUFHLEtBQUs7Q0FDakIsQ0FBQSJ9