@eggjs/multipart 4.0.0

package/dist/commonjs/lib/utils.js

@@ -0,0 +1,93 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.whitelist = void 0;
+exports.humanizeBytes = humanizeBytes;
+exports.normalizeOptions = normalizeOptions;
+const node_path_1 = __importDefault(require("node:path"));
+const node_assert_1 = __importDefault(require("node:assert"));
+const bytes_1 = __importDefault(require("bytes"));
+exports.whitelist = [
+    // images
+    '.jpg', '.jpeg', // image/jpeg
+    '.png', // image/png, image/x-png
+    '.gif', // image/gif
+    '.bmp', // image/bmp
+    '.wbmp', // image/vnd.wap.wbmp
+    '.webp',
+    '.tif',
+    '.psd',
+    // text
+    '.svg',
+    '.js', '.jsx',
+    '.json',
+    '.css', '.less',
+    '.html', '.htm',
+    '.xml',
+    // tar
+    '.zip',
+    '.gz', '.tgz', '.gzip',
+    // video
+    '.mp3',
+    '.mp4',
+    '.avi',
+];
+function humanizeBytes(size) {
+    if (typeof size === 'number') {
+        return size;
+    }
+    return (0, bytes_1.default)(size);
+}
+function normalizeOptions(options) {
+    // make sure to cast the value of config **Size to number
+    options.fileSize = humanizeBytes(options.fileSize);
+    options.fieldSize = humanizeBytes(options.fieldSize);
+    options.fieldNameSize = humanizeBytes(options.fieldNameSize);
+    // validate mode
+    options.mode = options.mode || 'stream';
+    (0, node_assert_1.default)(['stream', 'file'].includes(options.mode), `Expect mode to be 'stream' or 'file', but got '${options.mode}'`);
+    if (options.mode === 'file') {
+        (0, node_assert_1.default)(!options.fileModeMatch, '`fileModeMatch` options only work on stream mode, please remove it');
+    }
+    // normalize whitelist
+    if (Array.isArray(options.whitelist)) {
+        options.whitelist = options.whitelist.map(extname => extname.toLowerCase());
+    }
+    // normalize fileExtensions
+    if (Array.isArray(options.fileExtensions)) {
+        options.fileExtensions = options.fileExtensions.map(extname => {
+            return (extname.startsWith('.') || extname === '') ? extname.toLowerCase() : `.${extname.toLowerCase()}`;
+        });
+    }
+    function checkExt(fileName) {
+        if (typeof options.whitelist === 'function') {
+            return options.whitelist(fileName);
+        }
+        const extname = node_path_1.default.extname(fileName).toLowerCase();
+        if (Array.isArray(options.whitelist)) {
+            return options.whitelist.includes(extname);
+        }
+        // only if user don't provide whitelist, we will use default whitelist + fileExtensions
+        return exports.whitelist.includes(extname) || options.fileExtensions.includes(extname);
+    }
+    options.checkFile = (_fieldName, fileStream, fileName) => {
+        // just ignore, if no file
+        if (!fileStream || !fileName)
+            return;
+        try {
+            if (!checkExt(fileName)) {
+                const err = new Error('Invalid filename: ' + fileName);
+                Reflect.set(err, 'status', 400);
+                return err;
+            }
+        }
+        catch (err) {
+            err.status = 400;
+            return err;
+        }
+    };
+    return options;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/commonjs/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "commonjs"
+}

package/dist/esm/app/extend/context.d.ts

@@ -0,0 +1,110 @@
+import { Readable } from 'node:stream';
+import { Context } from '@eggjs/core';
+export interface EggFile {
+    field: string;
+    filename: string;
+    encoding: string;
+    mime: string;
+    filepath: string;
+}
+export interface MultipartFileStream extends Readable {
+    fields: Record<string, any>;
+    filename: string;
+    fieldname: string;
+    mime: string;
+    mimeType: string;
+    transferEncoding: string;
+    encoding: string;
+    truncated: boolean;
+}
+export interface MultipartOptions {
+    autoFields?: boolean;
+    /**
+     * required file submit, default is true
+     */
+    requireFile?: boolean;
+    /**
+     * default charset encoding
+     */
+    defaultCharset?: string;
+    /**
+     * compatible with defaultCharset
+     * @deprecated use `defaultCharset` instead
+     */
+    defCharset?: string;
+    defaultParamCharset?: string;
+    /**
+     * compatible with defaultParamCharset
+     * @deprecated use `defaultParamCharset` instead
+     */
+    defParamCharset?: string;
+    limits?: {
+        fieldNameSize?: number;
+        fieldSize?: number;
+        fields?: number;
+        fileSize?: number;
+        files?: number;
+        parts?: number;
+        headerPairs?: number;
+    };
+    checkFile?(fieldname: string, file: any, filename: string, encoding: string, mimetype: string): void | Error;
+}
+export default class MultipartContext extends Context {
+    /**
+     * create multipart.parts instance, to get separated files.
+     * @function Context#multipart
+     * @param {Object} [options] - override default multipart configurations
+     *  - {Boolean} options.autoFields
+     *  - {String} options.defaultCharset
+     *  - {String} options.defaultParamCharset
+     *  - {Object} options.limits
+     *  - {Function} options.checkFile
+     * @return {Yieldable | AsyncIterable<Yieldable>} parts
+     */
+    multipart(options?: MultipartOptions): AsyncIterable<MultipartFileStream>;
+    /**
+     * save request multipart data and files to `ctx.request`
+     * @function Context#saveRequestFiles
+     * @param {Object} options - { limits, checkFile, ... }
+     */
+    saveRequestFiles(options?: MultipartOptions): Promise<void>;
+    /**
+     * get upload file stream
+     * @example
+     * ```js
+     * const stream = await ctx.getFileStream();
+     * // get other fields
+     * console.log(stream.fields);
+     * ```
+     * @function Context#getFileStream
+     * @param {Object} options
+     *  - {Boolean} options.requireFile - required file submit, default is true
+     *  - {String} options.defaultCharset
+     *  - {String} options.defaultParamCharset
+     *  - {Object} options.limits
+     *  - {Function} options.checkFile
+     * @return {ReadStream} stream
+     * @since 1.0.0
+     * @deprecated Not safe enough, use `ctx.multipart()` instead
+     */
+    getFileStream(options?: MultipartOptions): Promise<MultipartFileStream>;
+    /**
+     * clean up request tmp files helper
+     * @function Context#cleanupRequestFiles
+     * @param {Array<String>} [files] - file paths need to cleanup, default is `ctx.request.files`.
+     */
+    cleanupRequestFiles(files?: EggFile[]): Promise<void>;
+}
+declare module '@eggjs/core' {
+    interface Request {
+        /**
+         * Files Object Array
+         */
+        files?: EggFile[];
+    }
+    interface Context {
+        saveRequestFiles(options?: MultipartOptions): Promise<void>;
+        getFileStream(options?: MultipartOptions): Promise<MultipartFileStream>;
+        cleanupRequestFiles(files?: EggFile[]): Promise<void>;
+    }
+}

package/dist/esm/app/extend/context.js

@@ -0,0 +1,273 @@
+import assert from 'node:assert';
+import path from 'node:path';
+import { randomUUID } from 'node:crypto';
+import fs from 'node:fs/promises';
+import { createWriteStream } from 'node:fs';
+import { Readable, PassThrough } from 'node:stream';
+import { pipeline } from 'node:stream/promises';
+// @ts-expect-error no types
+import parse from 'co-busboy';
+import dayjs from 'dayjs';
+import { Context } from '@eggjs/core';
+import { humanizeBytes } from '../../lib/utils.js';
+import { LimitError } from '../../lib/LimitError.js';
+import { MultipartFileTooLargeError } from '../../lib/MultipartFileTooLargeError.js';
+const HAS_CONSUMED = Symbol('Context#multipartHasConsumed');
+export default class MultipartContext extends Context {
+    /**
+     * create multipart.parts instance, to get separated files.
+     * @function Context#multipart
+     * @param {Object} [options] - override default multipart configurations
+     *  - {Boolean} options.autoFields
+     *  - {String} options.defaultCharset
+     *  - {String} options.defaultParamCharset
+     *  - {Object} options.limits
+     *  - {Function} options.checkFile
+     * @return {Yieldable | AsyncIterable<Yieldable>} parts
+     */
+    multipart(options = {}) {
+        // eslint-disable-next-line @typescript-eslint/no-this-alias
+        const ctx = this;
+        // multipart/form-data
+        if (!ctx.is('multipart'))
+            ctx.throw(400, 'Content-Type must be multipart/*');
+        assert(!ctx[HAS_CONSUMED], 'the multipart request can\'t be consumed twice');
+        ctx[HAS_CONSUMED] = true;
+        const { autoFields, defaultCharset, defaultParamCharset, checkFile } = ctx.app.config.multipart;
+        const { fieldNameSize, fieldSize, fields, fileSize, files } = ctx.app.config.multipart;
+        options = extractOptions(options);
+        const parseOptions = Object.assign({
+            autoFields,
+            defCharset: defaultCharset,
+            defParamCharset: defaultParamCharset,
+            checkFile,
+        }, options);
+        // https://github.com/mscdex/busboy#busboy-methods
+        // merge limits
+        parseOptions.limits = Object.assign({
+            fieldNameSize,
+            fieldSize,
+            fields,
+            fileSize,
+            files,
+        }, options.limits);
+        // mount asyncIterator, so we can use `for await` to get parts
+        const parts = parse(this, parseOptions);
+        parts[Symbol.asyncIterator] = async function* () {
+            let part;
+            do {
+                part = await parts();
+                if (!part)
+                    continue;
+                if (Array.isArray(part)) {
+                    if (part[3])
+                        throw new LimitError('Request_fieldSize_limit', 'Reach fieldSize limit');
+                    // TODO: still not support at busboy 1.x (only support at urlencoded)
+                    // https://github.com/mscdex/busboy/blob/v0.3.1/lib/types/multipart.js#L5
+                    // https://github.com/mscdex/busboy/blob/master/lib/types/multipart.js#L251
+                    // if (part[2]) throw new LimitError('Request_fieldNameSize_limit', 'Reach fieldNameSize limit');
+                }
+                else {
+                    // user click `upload` before choose a file, `part` will be file stream, but `part.filename` is empty must handler this, such as log error.
+                    if (!part.filename) {
+                        ctx.coreLogger.debug('[egg-multipart] file field `%s` is upload without file stream, will drop it.', part.fieldname);
+                        await pipeline(part, new PassThrough());
+                        continue;
+                    }
+                    // TODO: check whether filename is malicious input
+                    // busboy only set truncated when consume the stream
+                    if (part.truncated) {
+                        // in case of emit 'limit' too fast
+                        throw new LimitError('Request_fileSize_limit', 'Reach fileSize limit');
+                    }
+                    else {
+                        part.once('limit', function () {
+                            this.emit('error', new LimitError('Request_fileSize_limit', 'Reach fileSize limit'));
+                            this.resume();
+                        });
+                    }
+                }
+                // dispatch part to outter logic such as for-await-of
+                yield part;
+            } while (part !== undefined);
+        };
+        return parts;
+    }
+    /**
+     * save request multipart data and files to `ctx.request`
+     * @function Context#saveRequestFiles
+     * @param {Object} options - { limits, checkFile, ... }
+     */
+    async saveRequestFiles(options = {}) {
+        // eslint-disable-next-line @typescript-eslint/no-this-alias
+        const ctx = this;
+        const allowArrayField = ctx.app.config.multipart.allowArrayField;
+        let storeDir;
+        const requestBody = {};
+        const requestFiles = [];
+        options.autoFields = false;
+        const parts = ctx.multipart(options);
+        try {
+            for await (const part of parts) {
+                if (Array.isArray(part)) {
+                    // fields
+                    const [fieldName, fieldValue] = part;
+                    if (!allowArrayField) {
+                        requestBody[fieldName] = fieldValue;
+                    }
+                    else {
+                        if (!requestBody[fieldName]) {
+                            requestBody[fieldName] = fieldValue;
+                        }
+                        else if (!Array.isArray(requestBody[fieldName])) {
+                            requestBody[fieldName] = [requestBody[fieldName], fieldValue];
+                        }
+                        else {
+                            requestBody[fieldName].push(fieldValue);
+                        }
+                    }
+                }
+                else {
+                    // stream
+                    const { filename, fieldname, encoding, mime } = part;
+                    if (!storeDir) {
+                        // ${tmpdir}/YYYY/MM/DD/HH
+                        storeDir = path.join(ctx.app.config.multipart.tmpdir, dayjs().format('YYYY/MM/DD/HH'));
+                        await fs.mkdir(storeDir, { recursive: true });
+                    }
+                    // write to tmp file
+                    const filepath = path.join(storeDir, randomUUID() + path.extname(filename));
+                    const target = createWriteStream(filepath);
+                    await pipeline(part, target);
+                    const meta = {
+                        filepath,
+                        field: fieldname,
+                        filename,
+                        encoding,
+                        mime,
+                        // keep same property name as file stream, https://github.com/cojs/busboy/blob/master/index.js#L114
+                        fieldname,
+                        transferEncoding: encoding,
+                        mimeType: mime,
+                    };
+                    requestFiles.push(meta);
+                }
+            }
+        }
+        catch (err) {
+            await ctx.cleanupRequestFiles(requestFiles);
+            throw err;
+        }
+        ctx.request.body = requestBody;
+        ctx.request.files = requestFiles;
+    }
+    /**
+     * get upload file stream
+     * @example
+     * ```js
+     * const stream = await ctx.getFileStream();
+     * // get other fields
+     * console.log(stream.fields);
+     * ```
+     * @function Context#getFileStream
+     * @param {Object} options
+     *  - {Boolean} options.requireFile - required file submit, default is true
+     *  - {String} options.defaultCharset
+     *  - {String} options.defaultParamCharset
+     *  - {Object} options.limits
+     *  - {Function} options.checkFile
+     * @return {ReadStream} stream
+     * @since 1.0.0
+     * @deprecated Not safe enough, use `ctx.multipart()` instead
+     */
+    async getFileStream(options = {}) {
+        options.autoFields = true;
+        const parts = this.multipart(options);
+        let stream = await parts();
+        if (options.requireFile !== false) {
+            // stream not exists, treat as an exception
+            if (!stream || !stream.filename) {
+                this.throw(400, 'Can\'t found upload file');
+            }
+        }
+        if (!stream) {
+            stream = Readable.from([]);
+        }
+        if (stream.truncated) {
+            throw new LimitError('Request_fileSize_limit', 'Request file too large, please check multipart config');
+        }
+        stream.fields = parts.field;
+        stream.once('limit', () => {
+            const err = new MultipartFileTooLargeError('Request file too large, please check multipart config', stream.fields, stream.filename);
+            if (stream.listenerCount('error') > 0) {
+                stream.emit('error', err);
+                this.coreLogger.warn(err);
+            }
+            else {
+                this.coreLogger.error(err);
+                // ignore next error event
+                stream.on('error', () => { });
+            }
+            // ignore all data
+            stream.resume();
+        });
+        return stream;
+    }
+    /**
+     * clean up request tmp files helper
+     * @function Context#cleanupRequestFiles
+     * @param {Array<String>} [files] - file paths need to cleanup, default is `ctx.request.files`.
+     */
+    async cleanupRequestFiles(files) {
+        if (!files || !files.length) {
+            files = this.request.files;
+        }
+        if (Array.isArray(files)) {
+            for (const file of files) {
+                try {
+                    await fs.rm(file.filepath, { force: true, recursive: true });
+                }
+                catch (err) {
+                    // warning log
+                    this.coreLogger.warn('[egg-multipart-cleanupRequestFiles-error] file: %j, error: %s', file, err);
+                }
+            }
+        }
+    }
+}
+function extractOptions(options = {}) {
+    const opts = {};
+    if (typeof options.autoFields === 'boolean') {
+        opts.autoFields = options.autoFields;
+    }
+    if (options.limits) {
+        opts.limits = options.limits;
+    }
+    if (options.checkFile) {
+        opts.checkFile = options.checkFile;
+    }
+    if (options.defCharset) {
+        opts.defCharset = options.defCharset;
+    }
+    if (options.defParamCharset) {
+        opts.defParamCharset = options.defParamCharset;
+    }
+    // compatible with config names
+    if (options.defaultCharset) {
+        opts.defCharset = options.defaultCharset;
+    }
+    if (options.defaultParamCharset) {
+        opts.defParamCharset = options.defaultParamCharset;
+    }
+    // limits
+    if (options.limits) {
+        const limits = opts.limits = { ...options.limits };
+        for (const key in limits) {
+            if (key.endsWith('Size') && limits[key]) {
+                limits[key] = humanizeBytes(limits[key]);
+            }
+        }
+    }
+    return opts;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"context.js","sourceRoot":"","sources":["../../../../src/app/extend/context.ts"],"names":[],"mappings":"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"}

package/dist/esm/app/middleware/multipart.d.ts

@@ -0,0 +1,4 @@
+import type { Context, Next, EggCore } from '@eggjs/core';
+import type { MultipartConfig } from '../../config/config.default.js';
+declare const _default: (options: MultipartConfig, _app: EggCore) => (ctx: Context, next: Next) => Promise<void>;
+export default _default;

package/dist/esm/app/middleware/multipart.js

@@ -0,0 +1,18 @@
+import { pathMatching } from 'egg-path-matching';
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+export default (options, _app) => {
+    // normalize options
+    const matchFn = options.fileModeMatch && pathMatching({
+        match: options.fileModeMatch,
+        // pathToRegexpModule: app.options.pathToRegexpModule,
+    });
+    return async function multipart(ctx, next) {
+        if (!ctx.is('multipart'))
+            return next();
+        if (matchFn && !matchFn(ctx))
+            return next();
+        await ctx.saveRequestFiles();
+        return next();
+    };
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibXVsdGlwYXJ0LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vc3JjL2FwcC9taWRkbGV3YXJlL211bHRpcGFydC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsWUFBWSxFQUFFLE1BQU0sbUJBQW1CLENBQUM7QUFJakQsNkRBQTZEO0FBQzdELGVBQWUsQ0FBQyxPQUF3QixFQUFFLElBQWEsRUFBRSxFQUFFO0lBQ3pELG9CQUFvQjtJQUNwQixNQUFNLE9BQU8sR0FBRyxPQUFPLENBQUMsYUFBYSxJQUFJLFlBQVksQ0FBQztRQUNwRCxLQUFLLEVBQUUsT0FBTyxDQUFDLGFBQWE7UUFDNUIsc0RBQXNEO0tBQ3ZELENBQUMsQ0FBQztJQUVILE9BQU8sS0FBSyxVQUFVLFNBQVMsQ0FBQyxHQUFZLEVBQUUsSUFBVTtRQUN0RCxJQUFJLENBQUMsR0FBRyxDQUFDLEVBQUUsQ0FBQyxXQUFXLENBQUM7WUFBRSxPQUFPLElBQUksRUFBRSxDQUFDO1FBQ3hDLElBQUksT0FBTyxJQUFJLENBQUMsT0FBTyxDQUFDLEdBQUcsQ0FBQztZQUFFLE9BQU8sSUFBSSxFQUFFLENBQUM7UUFFNUMsTUFBTSxHQUFHLENBQUMsZ0JBQWdCLEVBQUUsQ0FBQztRQUM3QixPQUFPLElBQUksRUFBRSxDQUFDO0lBQ2hCLENBQUMsQ0FBQztBQUNKLENBQUMsQ0FBQyJ9

package/dist/esm/app/schedule/clean_tmpdir.d.ts

@@ -0,0 +1,3 @@
+import { EggCore } from '@eggjs/core';
+declare const _default: (app: EggCore) => any;
+export default _default;

package/dist/esm/app/schedule/clean_tmpdir.js

@@ -0,0 +1,53 @@
+import path from 'node:path';
+import fs from 'node:fs/promises';
+import dayjs from 'dayjs';
+export default (app) => {
+    return class CleanTmpdir extends app.Subscription {
+        static get schedule() {
+            return {
+                type: 'worker',
+                cron: app.config.multipart.cleanSchedule.cron,
+                disable: app.config.multipart.cleanSchedule.disable,
+                immediate: false,
+            };
+        }
+        async _remove(dir) {
+            const { ctx } = this;
+            if (await fs.access(dir).then(() => true, () => false)) {
+                ctx.coreLogger.info('[@eggjs/multipart:CleanTmpdir] removing tmpdir: %j', dir);
+                try {
+                    await fs.rm(dir, { force: true, recursive: true });
+                    ctx.coreLogger.info('[@eggjs/multipart:CleanTmpdir:success] tmpdir: %j has been removed', dir);
+                }
+                catch (err) {
+                    /* c8 ignore next 3 */
+                    ctx.coreLogger.error('[@eggjs/multipart:CleanTmpdir:error] remove tmpdir: %j error: %s', dir, err);
+                    ctx.coreLogger.error(err);
+                }
+            }
+        }
+        async subscribe() {
+            const { ctx } = this;
+            const config = ctx.app.config;
+            ctx.coreLogger.info('[@eggjs/multipart:CleanTmpdir] start clean tmpdir: %j', config.multipart.tmpdir);
+            // last year
+            const lastYear = dayjs().subtract(1, 'years');
+            const lastYearDir = path.join(config.multipart.tmpdir, lastYear.format('YYYY'));
+            await this._remove(lastYearDir);
+            // 3 months
+            for (let i = 1; i <= 3; i++) {
+                const date = dayjs().subtract(i, 'months');
+                const dir = path.join(config.multipart.tmpdir, date.format('YYYY/MM'));
+                await this._remove(dir);
+            }
+            // 7 days
+            for (let i = 1; i <= 7; i++) {
+                const date = dayjs().subtract(i, 'days');
+                const dir = path.join(config.multipart.tmpdir, date.format('YYYY/MM/DD'));
+                await this._remove(dir);
+            }
+            ctx.coreLogger.info('[@eggjs/multipart:CleanTmpdir] end');
+        }
+    };
+};
+//# sourceMappingURL=data:application/json;base64,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

package/dist/esm/app.d.ts

@@ -0,0 +1,6 @@
+import type { EggCore, ILifecycleBoot } from '@eggjs/core';
+export default class AppBootHook implements ILifecycleBoot {
+    private app;
+    constructor(app: EggCore);
+    configWillLoad(): void;
+}

package/dist/esm/app.js

@@ -0,0 +1,18 @@
+import { normalizeOptions } from './lib/utils.js';
+export default class AppBootHook {
+    app;
+    constructor(app) {
+        this.app = app;
+    }
+    configWillLoad() {
+        this.app.config.multipart = normalizeOptions(this.app.config.multipart);
+        const options = this.app.config.multipart;
+        this.app.coreLogger.info('[@eggjs/multipart] %s mode enable', options.mode);
+        if (options.mode === 'file' || options.fileModeMatch) {
+            this.app.coreLogger.info('[@eggjs/multipart] will save temporary files to %j, cleanup job cron: %j', options.tmpdir, options.cleanSchedule.cron);
+            // enable multipart middleware
+            this.app.config.coreMiddleware.push('multipart');
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXBwLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL2FwcC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFDQSxPQUFPLEVBQUUsZ0JBQWdCLEVBQUUsTUFBTSxnQkFBZ0IsQ0FBQztBQUVsRCxNQUFNLENBQUMsT0FBTyxPQUFPLFdBQVc7SUFDVjtJQUFwQixZQUFvQixHQUFZO1FBQVosUUFBRyxHQUFILEdBQUcsQ0FBUztJQUFHLENBQUM7SUFFcEMsY0FBYztRQUNaLElBQUksQ0FBQyxHQUFHLENBQUMsTUFBTSxDQUFDLFNBQVMsR0FBRyxnQkFBZ0IsQ0FBQyxJQUFJLENBQUMsR0FBRyxDQUFDLE1BQU0sQ0FBQyxTQUFTLENBQUMsQ0FBQztRQUN4RSxNQUFNLE9BQU8sR0FBRyxJQUFJLENBQUMsR0FBRyxDQUFDLE1BQU0sQ0FBQyxTQUFTLENBQUM7UUFFMUMsSUFBSSxDQUFDLEdBQUcsQ0FBQyxVQUFVLENBQUMsSUFBSSxDQUFDLG1DQUFtQyxFQUFFLE9BQU8sQ0FBQyxJQUFJLENBQUMsQ0FBQztRQUM1RSxJQUFJLE9BQU8sQ0FBQyxJQUFJLEtBQUssTUFBTSxJQUFJLE9BQU8sQ0FBQyxhQUFhLEVBQUUsQ0FBQztZQUNyRCxJQUFJLENBQUMsR0FBRyxDQUFDLFVBQVUsQ0FBQyxJQUFJLENBQUMsMEVBQTBFLEVBQ2pHLE9BQU8sQ0FBQyxNQUFNLEVBQUUsT0FBTyxDQUFDLGFBQWEsQ0FBQyxJQUFJLENBQUMsQ0FBQztZQUM5Qyw4QkFBOEI7WUFDOUIsSUFBSSxDQUFDLEdBQUcsQ0FBQyxNQUFNLENBQUMsY0FBYyxDQUFDLElBQUksQ0FBQyxXQUFXLENBQUMsQ0FBQztRQUNuRCxDQUFDO0lBQ0gsQ0FBQztDQUNGIn0=