@lopatnov/express-reverse-proxy 1.0.1 → 1.2.0

package/node_modules/@pm2/io/build/main/census/plugins/pg.js

@@ -0,0 +1,148 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const EventEmitter = require("events");
+const core_1 = require("@opencensus/core");
+const shimmer = require("shimmer");
+class PGPlugin extends core_1.BasePlugin {
+    constructor(moduleName) {
+        super(moduleName);
+        this.internalFileList = {
+            '6 - 7': {
+                'client': 'lib/client'
+            }
+        };
+    }
+    applyPatch() {
+        this.logger.debug('Patched PG');
+        if (this.internalFilesExports.client) {
+            this.logger.debug('patching pq.client.prototype.query');
+            shimmer.wrap(this.internalFilesExports.client.prototype, 'query', this.getPatchCreateQuery());
+        }
+        return this.moduleExports;
+    }
+    applyUnpatch() {
+        shimmer.unwrap(this.internalFilesExports.client.prototype, 'query');
+    }
+    getPatchCreateQuery() {
+        const plugin = this;
+        return (original) => {
+            return function (...args) {
+                const span = plugin.tracer.startChildSpan('pg-query', core_1.SpanKind.CLIENT);
+                if (span === null)
+                    return original.apply(this, arguments);
+                let pgQuery;
+                if (arguments.length >= 1) {
+                    const args = Array.prototype.slice.call(arguments, 0);
+                    plugin.populateLabelsFromInputs(span, args);
+                    const callback = args[args.length - 1];
+                    if (typeof callback === 'function') {
+                        args[args.length - 1] = plugin.patchCallback(callback, span);
+                    }
+                    else if (typeof args[0] === 'object') {
+                        plugin.patchSubmittable(args[0], span);
+                    }
+                    pgQuery = original.apply(this, args);
+                }
+                else {
+                    pgQuery = original.apply(this, arguments);
+                }
+                if (pgQuery) {
+                    if (pgQuery instanceof EventEmitter) {
+                        plugin.tracer.wrapEmitter(pgQuery);
+                    }
+                    else if (typeof pgQuery.then === 'function') {
+                        plugin.patchPromise(pgQuery, span);
+                    }
+                }
+                return pgQuery;
+            };
+        };
+    }
+    patchCallback(callback, span) {
+        const plugin = this;
+        return plugin.tracer.wrap((err, res) => {
+            plugin.populateLabelsFromOutputs(span, err, res);
+            span.end();
+            callback(err, res);
+        });
+    }
+    patchSubmittable(pgQuery, span) {
+        const plugin = this;
+        let spanEnded = false;
+        if (pgQuery.handleError) {
+            shimmer.wrap(pgQuery, 'handleError', (origCallback) => {
+                return this.tracer.wrap(function (...args) {
+                    if (!spanEnded) {
+                        const err = args[0];
+                        plugin.populateLabelsFromOutputs(span, err);
+                        span.end();
+                        spanEnded = true;
+                    }
+                    if (origCallback) {
+                        origCallback.apply(this, args);
+                    }
+                });
+            });
+        }
+        if (pgQuery.handleReadyForQuery) {
+            shimmer.wrap(pgQuery, 'handleReadyForQuery', (origCallback) => {
+                return this.tracer.wrap(function (...args) {
+                    if (!spanEnded) {
+                        plugin.populateLabelsFromOutputs(span, null, this._result);
+                        span.end();
+                        spanEnded = true;
+                    }
+                    if (origCallback) {
+                        origCallback.apply(this, args);
+                    }
+                });
+            });
+        }
+        return pgQuery;
+    }
+    patchPromise(promise, span) {
+        return promise = promise.then((res) => {
+            plugin.populateLabelsFromOutputs(span, null, res);
+            span.end();
+            return res;
+        }, (err) => {
+            plugin.populateLabelsFromOutputs(span, err);
+            span.end();
+            throw err;
+        });
+    }
+    populateLabelsFromInputs(span, args) {
+        const queryObj = args[0];
+        if (typeof queryObj === 'object') {
+            if (queryObj.text) {
+                span.addAttribute('query', queryObj.text);
+            }
+            if (plugin.options.detailedCommands === true && queryObj.values) {
+                span.addAttribute('values', queryObj.values);
+            }
+        }
+        else if (typeof queryObj === 'string') {
+            span.addAttribute('query', queryObj);
+            if (plugin.options.detailedCommands === true && args.length >= 2 && typeof args[1] !== 'function') {
+                span.addAttribute('values', args[1]);
+            }
+        }
+    }
+    populateLabelsFromOutputs(span, err, res) {
+        if (plugin.options.detailedCommands !== true)
+            return;
+        if (err) {
+            span.addAttribute('error', err.toString());
+        }
+        if (res) {
+            span.addAttribute('row_count', res.rowCount);
+            span.addAttribute('oid', res.oid);
+            span.addAttribute('rows', res.rows);
+            span.addAttribute('fields', res.fields);
+        }
+    }
+}
+exports.PGPlugin = PGPlugin;
+const plugin = new PGPlugin('pg');
+exports.plugin = plugin;
+//# sourceMappingURL=data:application/json;base64,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

package/node_modules/@pm2/io/build/main/census/plugins/redis.d.ts

@@ -0,0 +1,19 @@
+import { BasePlugin, Span } from '@opencensus/core';
+import * as redis from 'redis';
+export declare type Redis = typeof redis;
+export declare type IgnoreMatcher = string | RegExp;
+export declare type RedisPluginConfig = {
+    detailedCommands: boolean;
+};
+export declare class RedisPlugin extends BasePlugin {
+    protected options: RedisPluginConfig;
+    constructor(moduleName: string);
+    protected applyPatch(): any;
+    applyUnpatch(): void;
+    private getPatchCreateStream;
+    private getPatchCreateClient;
+    private getPatchSendCommand;
+    patchEnd(span: Span, resultHandler: Function): Function;
+}
+declare const plugin: RedisPlugin;
+export { plugin };

package/node_modules/@pm2/io/build/main/census/plugins/redis.js

@@ -0,0 +1,114 @@
+'use strict';
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@opencensus/core");
+const shimmer = require("shimmer");
+const semver = require("semver");
+class RedisPlugin extends core_1.BasePlugin {
+    constructor(moduleName) {
+        super(moduleName);
+    }
+    applyPatch() {
+        this.logger.debug('Patched redis');
+        if (semver.lt(this.version, '2.4.0')) {
+            this.logger.info('disabling redis plugin because version isnt supported');
+            return this.moduleExports;
+        }
+        if (this.moduleExports.RedisClient) {
+            this.logger.debug('patching redis.RedisClient.prototype.create_stream');
+            shimmer.wrap(this.moduleExports.RedisClient.prototype, 'create_stream', this.getPatchCreateStream());
+            this.logger.debug('patching redis.RedisClient.prototype.internal_send');
+            shimmer.wrap(this.moduleExports.RedisClient.prototype, 'internal_send_command', this.getPatchSendCommand());
+            this.logger.debug('patching redis.RedisClient.prototype.createClient');
+            shimmer.wrap(this.moduleExports, 'createClient', this.getPatchCreateClient());
+        }
+        return this.moduleExports;
+    }
+    applyUnpatch() {
+        if (semver.lt(this.version, '2.4.0'))
+            return;
+        shimmer.unwrap(this.moduleExports.RedisClient.prototype, 'internal_send_command');
+        shimmer.unwrap(this.moduleExports, 'createClient');
+        shimmer.unwrap(this.moduleExports.RedisClient.prototype, 'create_stream');
+    }
+    getPatchCreateStream() {
+        const plugin = this;
+        return function createStreamWrap(original) {
+            return function create_stream_trace() {
+                if (!this.stream) {
+                    Object.defineProperty(this, 'stream', {
+                        get: function () { return this._patched_redis_stream; },
+                        set: function (val) {
+                            plugin.tracer.wrapEmitter(val);
+                            this._patched_redis_stream = val;
+                        }
+                    });
+                }
+                return original.apply(this, arguments);
+            };
+        };
+    }
+    getPatchCreateClient() {
+        const plugin = this;
+        return function createClientWrap(original) {
+            return function createClientTrace() {
+                const client = original.apply(this, arguments);
+                plugin.tracer.wrapEmitter(client);
+                return client;
+            };
+        };
+    }
+    getPatchSendCommand() {
+        const plugin = this;
+        const addArguments = typeof this.options === 'object'
+            && this.options.detailedCommands === true;
+        return function internalSendCommandWrap(original) {
+            return function internal_send_command_trace(cmd, args, cb) {
+                if (!plugin.tracer.currentRootSpan) {
+                    return original.apply(this, arguments);
+                }
+                if (arguments.length === 1 && typeof cmd === 'object') {
+                    const span = plugin.tracer.startChildSpan(`redis-${cmd.command}`, core_1.SpanKind.CLIENT);
+                    if (span === null)
+                        return original.apply(this, arguments);
+                    span.addAttribute('command', cmd.command);
+                    if (addArguments) {
+                        span.addAttribute('arguments', JSON.stringify(cmd.args || []));
+                    }
+                    cmd.callback = plugin.patchEnd(span, cmd.callback);
+                    return original.apply(this, arguments);
+                }
+                if (typeof cmd === 'string' && Array.isArray(args) && typeof cb === 'function') {
+                    const span = plugin.tracer.startChildSpan(`redis-${cmd}`, core_1.SpanKind.CLIENT);
+                    if (span === null)
+                        return original.apply(this, arguments);
+                    span.addAttribute('command', cmd);
+                    if (addArguments) {
+                        span.addAttribute('arguments', JSON.stringify(args));
+                    }
+                    cb = plugin.patchEnd(span, cb);
+                    return original.apply(this, arguments);
+                }
+                return original.apply(this, arguments);
+            };
+        };
+    }
+    patchEnd(span, resultHandler) {
+        const plugin = this;
+        const patchedEnd = function (err) {
+            if (plugin.options.detailedCommands === true && err instanceof Error) {
+                span.addAttribute('error', err.message);
+            }
+            if (span.ended === false) {
+                span.end();
+            }
+            if (typeof resultHandler === 'function') {
+                return resultHandler.apply(this, arguments);
+            }
+        };
+        return this.tracer.wrap(patchedEnd);
+    }
+}
+exports.RedisPlugin = RedisPlugin;
+const plugin = new RedisPlugin('redis');
+exports.plugin = plugin;
+//# sourceMappingURL=data:application/json;base64,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

package/node_modules/@pm2/io/build/main/census/plugins/vue.d.ts

@@ -0,0 +1,12 @@
+import { BasePlugin, Span } from '@opencensus/core';
+export declare class VuePlugin extends BasePlugin {
+    private rendererResults;
+    constructor(moduleName: string);
+    protected applyPatch(): any;
+    applyUnpatch(): void;
+    private getPatchCreateRenderer;
+    private getPatchRenderToString;
+    patchEnd(span: Span): () => void;
+}
+declare const plugin: VuePlugin;
+export { plugin };

package/node_modules/@pm2/io/build/main/census/plugins/vue.js

@@ -0,0 +1,78 @@
+'use strict';
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@opencensus/core");
+const shimmer = require("shimmer");
+var RendererType;
+(function (RendererType) {
+    RendererType["NORMAL"] = "normal";
+    RendererType["BUNDLE"] = "bundle";
+})(RendererType || (RendererType = {}));
+class VuePlugin extends core_1.BasePlugin {
+    constructor(moduleName) {
+        super(moduleName);
+        this.rendererResults = [];
+    }
+    applyPatch() {
+        this.logger.debug('Patched vue-server-renderer');
+        if (this.moduleExports) {
+            this.logger.debug('patching vue-server-renderer.prototype.createRenderer');
+            shimmer.wrap(this.moduleExports, 'createRenderer', this.getPatchCreateRenderer(RendererType.NORMAL));
+            this.logger.debug('patching vue-server-renderer.prototype.createBundleRenderer');
+            shimmer.wrap(this.moduleExports, 'createBundleRenderer', this.getPatchCreateRenderer(RendererType.BUNDLE));
+        }
+        return this.moduleExports;
+    }
+    applyUnpatch() {
+        shimmer.unwrap(this.moduleExports, 'createRenderer');
+        shimmer.unwrap(this.moduleExports, 'createBundleRenderer');
+        for (let result of this.rendererResults) {
+            shimmer.unwrap(result, 'renderToString');
+        }
+    }
+    getPatchCreateRenderer(type) {
+        const plugin = this;
+        return function createRendererWrap(original) {
+            return function create_renderer_trace() {
+                const result = original.apply(this, arguments);
+                plugin.logger.debug(`patching ${type}.renderToString`);
+                shimmer.wrap(result, 'renderToString', plugin.getPatchRenderToString(type));
+                plugin.rendererResults.push(result);
+                return result;
+            };
+        };
+    }
+    getPatchRenderToString(type) {
+        const plugin = this;
+        return function renderToStringWrap(original) {
+            return function render_string_trace() {
+                if (!plugin.tracer.currentRootSpan) {
+                    return original.apply(this, arguments);
+                }
+                const span = plugin.tracer.startChildSpan(`vue-renderer`, core_1.SpanKind.CLIENT);
+                if (span === null)
+                    return original.apply(this, arguments);
+                const promise = original.apply(this, arguments);
+                if (promise instanceof Promise) {
+                    promise.then(plugin.patchEnd(span)).catch(plugin.patchEnd(span));
+                }
+                return promise;
+            };
+        };
+    }
+    patchEnd(span) {
+        const plugin = this;
+        const patchedEnd = function (err) {
+            if (plugin.options.detailedCommands === true && err instanceof Error) {
+                span.addAttribute('error', err.message);
+            }
+            if (span.ended === false) {
+                span.end();
+            }
+        };
+        return this.tracer.wrap(patchedEnd);
+    }
+}
+exports.VuePlugin = VuePlugin;
+const plugin = new VuePlugin('vue-server-renderer');
+exports.plugin = plugin;
+//# sourceMappingURL=data:application/json;base64,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

package/node_modules/@pm2/io/build/main/census/tracer.d.ts

@@ -0,0 +1,19 @@
+import * as core from '@opencensus/core';
+export declare class Tracing implements core.Tracing {
+    readonly tracer: core.Tracer;
+    private pluginLoader;
+    private defaultPlugins;
+    private configLocal;
+    private logger;
+    private static singletonInstance;
+    private activeLocal;
+    constructor();
+    static readonly instance: core.Tracing;
+    readonly active: boolean;
+    readonly config: core.Config;
+    start(userConfig?: core.Config): core.Tracing;
+    stop(): void;
+    readonly exporter: core.Exporter;
+    registerExporter(exporter: core.Exporter): core.Tracing;
+    unregisterExporter(exporter: core.Exporter): core.Tracing;
+}

package/node_modules/@pm2/io/build/main/census/tracer.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core = require("@opencensus/core");
+const default_config_1 = require("./config/default-config");
+const constants_1 = require("./constants");
+const plugin_loader_1 = require("./instrumentation/plugin-loader");
+class Tracing {
+    constructor() {
+        this.configLocal = {};
+        this.tracer = new core.CoreTracer();
+        this.defaultPlugins = plugin_loader_1.PluginLoader.defaultPluginsFromArray(constants_1.Constants.DEFAULT_INSTRUMENTATION_MODULES);
+    }
+    static get instance() {
+        return this.singletonInstance || (this.singletonInstance = new this());
+    }
+    get active() {
+        return this.activeLocal;
+    }
+    get config() {
+        return this.configLocal;
+    }
+    start(userConfig) {
+        this.configLocal = Object.assign(default_config_1.defaultConfig, { plugins: this.defaultPlugins }, userConfig);
+        this.logger =
+            this.configLocal.logger || core.logger.logger(this.configLocal.logLevel);
+        this.configLocal.logger = this.logger;
+        this.logger.debug('config: %o', this.configLocal);
+        this.pluginLoader = new plugin_loader_1.PluginLoader(this.logger, this.tracer);
+        this.pluginLoader.loadPlugins(this.configLocal.plugins);
+        if (!this.configLocal.exporter) {
+            const exporter = new core.ConsoleExporter(this.configLocal);
+            this.registerExporter(exporter);
+        }
+        else {
+            this.registerExporter(this.configLocal.exporter);
+        }
+        this.activeLocal = true;
+        this.tracer.start(this.configLocal);
+        return this;
+    }
+    stop() {
+        this.activeLocal = false;
+        this.tracer.stop();
+        this.pluginLoader.unloadPlugins();
+        this.configLocal = {};
+    }
+    get exporter() {
+        return this.configLocal.exporter;
+    }
+    registerExporter(exporter) {
+        if (this.configLocal.exporter) {
+            this.unregisterExporter(this.configLocal.exporter);
+        }
+        if (exporter) {
+            this.configLocal.exporter = exporter;
+            this.tracer.registerSpanEventListener(exporter);
+        }
+        return this;
+    }
+    unregisterExporter(exporter) {
+        this.tracer.unregisterSpanEventListener(exporter);
+        this.configLocal.exporter = undefined;
+        return this;
+    }
+}
+exports.Tracing = Tracing;
+//# sourceMappingURL=data:application/json;base64,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

package/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;
+}

package/node_modules/@pm2/io/build/main/configuration.js

@@ -0,0 +1,125 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const debug_1 = require("debug");
+const debug = debug_1.default('axm:configuration');
+const serviceManager_1 = require("./serviceManager");
+const autocast_1 = require("./utils/autocast");
+const path = require("path");
+const fs = require("fs");
+const util = require("util");
+class Configuration {
+    static configureModule(opts) {
+        if (serviceManager_1.ServiceManager.get('transport'))
+            serviceManager_1.ServiceManager.get('transport').setOptions(opts);
+    }
+    static findPackageJson() {
+        try {
+            require.main = Configuration.getMain();
+        }
+        catch (_e) {
+        }
+        if (!require.main) {
+            return;
+        }
+        if (!require.main.paths) {
+            return;
+        }
+        let pkgPath = path.resolve(path.dirname(require.main.filename), 'package.json');
+        try {
+            fs.statSync(pkgPath);
+        }
+        catch (e) {
+            try {
+                pkgPath = path.resolve(path.dirname(require.main.filename), '..', 'package.json');
+                fs.statSync(pkgPath);
+            }
+            catch (e) {
+                debug('Cannot find package.json');
+                try {
+                    pkgPath = path.resolve(path.dirname(require.main.filename), '..', '..', 'package.json');
+                    fs.statSync(pkgPath);
+                }
+                catch (e) {
+                    debug('Cannot find package.json');
+                    return null;
+                }
+            }
+            return pkgPath;
+        }
+        return pkgPath;
+    }
+    static init(conf, doNotTellPm2) {
+        const packageFilepath = Configuration.findPackageJson();
+        let packageJson;
+        if (!conf.module_conf) {
+            conf.module_conf = {};
+        }
+        conf.apm = {
+            type: 'node',
+            version: null
+        };
+        try {
+            const prefix = __dirname.replace(/\\/g, '/').indexOf('/build/') >= 0 ? '../../' : '../';
+            const pkg = require(prefix + 'package.json');
+            conf.apm.version = pkg.version || null;
+        }
+        catch (err) {
+            debug('Failed to fetch current apm version: ', err.message);
+        }
+        if (conf.isModule === true) {
+            try {
+                packageJson = require(packageFilepath || '');
+                conf.module_version = packageJson.version;
+                conf.module_name = packageJson.name;
+                conf.description = packageJson.description;
+                if (packageJson.config) {
+                    conf = util['_extend'](conf, packageJson.config);
+                    conf.module_conf = packageJson.config;
+                }
+            }
+            catch (e) {
+                throw new Error(e);
+            }
+        }
+        else {
+            conf.module_name = process.env.name || 'outside-pm2';
+            try {
+                packageJson = require(packageFilepath || '');
+                conf.module_version = packageJson.version;
+                if (packageJson.config) {
+                    conf = util['_extend'](conf, packageJson.config);
+                    conf.module_conf = packageJson.config;
+                }
+            }
+            catch (e) {
+                debug(e.message);
+            }
+        }
+        try {
+            if (process.env[conf.module_name]) {
+                const castedConf = new autocast_1.default().autocast(JSON.parse(process.env[conf.module_name] || ''));
+                conf = util['_extend'](conf, castedConf);
+                delete castedConf.probes;
+                conf.module_conf = JSON.parse(JSON.stringify(util['_extend'](conf.module_conf, castedConf)));
+                Object.keys(conf.module_conf).forEach(function (key) {
+                    if ((key === 'password' || key === 'passwd') &&
+                        conf.module_conf[key].length >= 1) {
+                        conf.module_conf[key] = 'Password hidden';
+                    }
+                });
+            }
+        }
+        catch (e) {
+            debug(e);
+        }
+        if (doNotTellPm2 === true)
+            return conf;
+        Configuration.configureModule(conf);
+        return conf;
+    }
+    static getMain() {
+        return require.main || { filename: './somefile.js' };
+    }
+}
+exports.default = Configuration;
+//# sourceMappingURL=data:application/json;base64,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

package/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;

package/node_modules/@pm2/io/build/main/constants.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29uc3RhbnRzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL2NvbnN0YW50cy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOztBQUFBLGlDQUFnQztBQUVoQyxrQkFBZTtJQUNiLGVBQWUsRUFBRSxHQUFHO0NBQ3JCLENBQUE7QUFFRCxTQUFnQixlQUFlO0lBQzdCLE1BQU0sYUFBYSxHQUFHLE1BQU0sQ0FBQyxTQUFTLENBQUMsT0FBTyxDQUFDLE9BQU8sRUFBRSxXQUFXLENBQUMsQ0FBQTtJQUNwRSxNQUFNLFlBQVksR0FBRyxNQUFNLENBQUMsU0FBUyxDQUFDLE9BQU8sQ0FBQyxPQUFPLEVBQUUsVUFBVSxDQUFDLENBQUE7SUFDbEUsTUFBTSxhQUFhLEdBQUcsT0FBTyxDQUFDLEdBQUcsQ0FBQyxlQUFlLEtBQUssR0FBRztXQUNwRCxPQUFPLENBQUMsR0FBRyxDQUFDLGVBQWUsS0FBSyxNQUFNLElBQUksT0FBTyxDQUFDLEdBQUcsQ0FBQyxRQUFRLEtBQUssWUFBWSxDQUFBO0lBQ3BGLE9BQU8sYUFBYSxJQUFJLENBQUMsWUFBWSxJQUFJLGFBQWEsQ0FBQyxDQUFBO0FBQ3pELENBQUM7QUFORCwwQ0FNQyJ9