@researchdatabox/redbox-core 0.0.0-bootstrap.0

package/dist/services/StandardDatastreamService.js

@@ -0,0 +1,297 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Services = void 0;
+const CoreService_1 = require("../CoreService");
+const DatastreamServiceResponse_1 = require("../DatastreamServiceResponse");
+const Datastream_1 = require("../Datastream");
+const rxjs_1 = require("rxjs");
+const operators_1 = require("rxjs/operators");
+const _ = __importStar(require("lodash"));
+/**
+ * StandardDatastreamService
+ *
+ * Implements the DatastreamService interface using Flydrive v2 disks
+ * managed by StorageManagerService. Files are read from the staging disk
+ * and written to the primary disk under the key `{oid}/{fileId}`.
+ */
+var Services;
+(function (Services) {
+    class StandardDatastream extends CoreService_1.Services.Core.Service {
+        _exportedMethods = [
+            'addDatastreams',
+            'updateDatastream',
+            'removeDatastream',
+            'addDatastream',
+            'addAndRemoveDatastreams',
+            'getDatastream',
+            'listDatastreams',
+        ];
+        logHeader = 'StandardDatastreamService::';
+        /**
+         * Build the storage key for a file: `{oid}/{fileId}`
+         */
+        storageKey(oid, fileId) {
+            return `${oid}/${fileId}`;
+        }
+        // ----------------------------------------------------------------
+        // DatastreamService interface implementation
+        // ----------------------------------------------------------------
+        /**
+         * Add multiple datastreams for a record.
+         * Each datastream is moved from the staging disk to the primary disk.
+         */
+        async addDatastreams(oid, datastreams) {
+            const response = new DatastreamServiceResponse_1.DatastreamServiceResponse();
+            response.message = '';
+            let hasFailure = false;
+            for (const ds of datastreams) {
+                try {
+                    await this.addDatastream(oid, ds, StorageManagerService.stagingDisk());
+                    const successMessage = `Successfully uploaded: ${JSON.stringify(ds)}`;
+                    response.message = _.isEmpty(response.message) ? successMessage : `${response.message}\n${successMessage}`;
+                }
+                catch (err) {
+                    hasFailure = true;
+                    const failureMessage = `Failed to upload: ${JSON.stringify(ds)}, error is:\n${JSON.stringify(err)}`;
+                    response.message = _.isEmpty(response.message) ? failureMessage : `${response.message}\n${failureMessage}`;
+                }
+            }
+            response.success = !hasFailure;
+            return response;
+        }
+        /**
+         * Diff the old/new attachment fields and add/remove datastreams accordingly.
+         * Follows the same pattern as MongoStorageService.updateDatastream.
+         */
+        updateDatastream(oid, record, newMetadata, stagingDisk, fileIdsAdded) {
+            const typedRecord = this.coerceRecord(record);
+            const typedNewMetadata = this.coerceMetadata(newMetadata);
+            return FormsService
+                .getFormByName(typedRecord.metaMetadata.form, true, typedRecord.metaMetadata.brandId)
+                .pipe((0, operators_1.mergeMap)(form => {
+                const reqs = [];
+                if (form?.attachmentFields) {
+                    typedRecord.metaMetadata.attachmentFields = form.attachmentFields;
+                    for (const attField of form.attachmentFields) {
+                        const perFieldFileIdsAdded = [];
+                        const oldAttachments = this.getAttachments(typedRecord.metadata, attField);
+                        const newAttachments = this.getAttachments(typedNewMetadata, attField);
+                        const removeIds = [];
+                        const toRemove = this.diffAttachments(oldAttachments, newAttachments);
+                        for (const removeAtt of toRemove) {
+                            if (this.isAttachment(removeAtt)) {
+                                removeIds.push(new Datastream_1.Datastream(removeAtt));
+                            }
+                        }
+                        const toAdd = this.diffAttachments(newAttachments, oldAttachments);
+                        for (const addAtt of toAdd) {
+                            if (this.isAttachment(addAtt)) {
+                                perFieldFileIdsAdded.push(new Datastream_1.Datastream(addAtt));
+                            }
+                        }
+                        fileIdsAdded.push(...perFieldFileIdsAdded);
+                        reqs.push(this.addAndRemoveDatastreams(oid, perFieldFileIdsAdded, removeIds, stagingDisk));
+                    }
+                }
+                return (0, rxjs_1.of)(reqs);
+            }));
+        }
+        coerceRecord(record) {
+            if (!record || typeof record !== 'object') {
+                throw new Error(`${this.logHeader} updateDatastream requires a record object`);
+            }
+            const rec = record;
+            const metaMetadata = rec.metaMetadata;
+            const metadata = rec.metadata;
+            const form = typeof metaMetadata?.form === 'string' ? metaMetadata.form : '';
+            const brandId = typeof metaMetadata?.brandId === 'string' ? metaMetadata.brandId : undefined;
+            const attachmentFields = Array.isArray(metaMetadata?.attachmentFields)
+                ? metaMetadata?.attachmentFields
+                : undefined;
+            return {
+                metaMetadata: { form, brandId, attachmentFields },
+                metadata: metadata ?? {},
+            };
+        }
+        coerceMetadata(value) {
+            if (!value || typeof value !== 'object') {
+                return {};
+            }
+            return value;
+        }
+        getAttachments(metadata, field) {
+            const value = metadata[field];
+            if (!Array.isArray(value)) {
+                return [];
+            }
+            return value.filter((item) => !!item && typeof item === 'object');
+        }
+        diffAttachments(source, comparison) {
+            return _.differenceBy(source, comparison ?? [], 'fileId');
+        }
+        isAttachment(value) {
+            return value['type'] === 'attachment' && typeof value['fileId'] === 'string';
+        }
+        /**
+         * Add a single datastream: read from staging disk, write to primary disk.
+         */
+        async addDatastream(oid, datastream, stagingDisk) {
+            const fileId = datastream.fileId;
+            this.logger.verbose(`${this.logHeader} addDatastream() -> fileId: ${fileId}`);
+            const effectiveStagingDisk = stagingDisk ?? StorageManagerService.stagingDisk();
+            const primaryDisk = StorageManagerService.primaryDisk();
+            const destKey = this.storageKey(oid, fileId);
+            const exists = await effectiveStagingDisk.exists(fileId);
+            if (!exists) {
+                throw new Error(`Attachment not found in staging: ${fileId}`);
+            }
+            try {
+                await effectiveStagingDisk.move(fileId, destKey);
+            }
+            catch {
+                const readable = await effectiveStagingDisk.getStream(fileId);
+                await primaryDisk.putStream(destKey, readable);
+                await effectiveStagingDisk.delete(fileId);
+            }
+            this.logger.verbose(`${this.logHeader} addDatastream() -> Successfully added: ${destKey}`);
+            return { success: true, key: destKey };
+        }
+        /**
+         * Remove a single datastream from the primary disk.
+         */
+        async removeDatastream(oid, datastream) {
+            const fileId = datastream.fileId;
+            const destKey = this.storageKey(oid, fileId);
+            this.logger.verbose(`${this.logHeader} removeDatastream() -> Deleting: ${destKey}`);
+            const primaryDisk = StorageManagerService.primaryDisk();
+            try {
+                await primaryDisk.delete(destKey);
+                this.logger.verbose(`${this.logHeader} removeDatastream() -> Delete successful: ${destKey}`);
+            }
+            catch {
+                // Flydrive may throw if the file doesn't exist; log and continue
+                this.logger.verbose(`${this.logHeader} removeDatastream() -> File not found or error deleting: ${destKey}`);
+            }
+            return { success: true };
+        }
+        /**
+         * Add and remove datastreams in sequence (additions first, then removals).
+         */
+        async addAndRemoveDatastreams(oid, addDatastreams, removeDatastreams, stagingDisk) {
+            for (const ds of addDatastreams) {
+                await this.addDatastream(oid, ds, stagingDisk);
+            }
+            for (const ds of removeDatastreams) {
+                await this.removeDatastream(oid, ds);
+            }
+            return { success: true };
+        }
+        /**
+         * Get a datastream (file contents) from the primary disk.
+         * Returns an Attachment with a readstream.
+         */
+        async getDatastream(oid, fileId) {
+            const destKey = this.storageKey(oid, fileId);
+            this.logger.verbose(`${this.logHeader} getDatastream() -> Key: ${destKey}`);
+            const primaryDisk = StorageManagerService.primaryDisk();
+            // Check existence
+            const exists = await primaryDisk.exists(destKey);
+            if (!exists) {
+                throw new Error(`Attachment not found: ${destKey}`);
+            }
+            const readstream = await primaryDisk.getStream(destKey);
+            // Try to get metadata for content type / size
+            let contentType = '';
+            let size = 0;
+            try {
+                const meta = await primaryDisk.getMetaData(destKey);
+                contentType = meta.contentType ?? '';
+                size = meta.contentLength ?? 0;
+            }
+            catch {
+                // Metadata may not be available for all drivers
+            }
+            return {
+                readstream,
+                contentType,
+                size,
+            };
+        }
+        /**
+         * List datastreams for a record.
+         * If fileId is provided, lists that specific file; otherwise lists all files for the oid.
+         */
+        async listDatastreams(oid, fileId) {
+            const primaryDisk = StorageManagerService.primaryDisk();
+            if (!_.isEmpty(fileId)) {
+                const destKey = this.storageKey(oid, fileId);
+                const exists = await primaryDisk.exists(destKey);
+                if (!exists) {
+                    return [];
+                }
+                try {
+                    const meta = await primaryDisk.getMetaData(destKey);
+                    return [
+                        {
+                            filename: destKey,
+                            contentType: meta.contentType,
+                            contentLength: meta.contentLength,
+                            lastModified: meta.lastModified,
+                            etag: meta.etag,
+                        },
+                    ];
+                }
+                catch {
+                    return [{ filename: destKey }];
+                }
+            }
+            // List all files under the oid prefix
+            const prefix = `${oid}/`;
+            const result = await primaryDisk.listAll(prefix, { recursive: true });
+            const files = [];
+            for (const obj of result.objects) {
+                const fileObj = obj;
+                files.push({
+                    filename: fileObj['key'] ?? fileObj['name'] ?? String(obj),
+                    ...fileObj,
+                });
+            }
+            return files;
+        }
+    }
+    Services.StandardDatastream = StandardDatastream;
+})(Services || (exports.Services = Services = {}));
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"StandardDatastreamService.js","sourceRoot":"","sources":["../../src/services/StandardDatastreamService.ts"],"names":[],"mappings":"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"}

package/dist/services/StorageManagerService.d.ts

@@ -0,0 +1,90 @@
+import { Services as services } from '../CoreService';
+/**
+ * StorageManagerService
+ *
+ * Wraps Flydrive v2 to provide a multi-disk storage abstraction.
+ * Configures disks based on sails.config.storage and exposes
+ * accessors for staging and primary disks.
+ *
+ * Flydrive is ESM-only; we load it via processDynamicImports().
+ */
+export declare namespace Services {
+    /**
+     * Internal interface matching the Flydrive Disk public API surface
+     * that we actually use. This avoids referencing ESM-only types at
+     * compile-time while preserving type-safety for callers.
+     */
+    interface IDisk {
+        exists(key: string): Promise<boolean>;
+        get(key: string): Promise<string>;
+        getStream(key: string): Promise<import('node:stream').Readable>;
+        getBytes(key: string): Promise<Uint8Array>;
+        getMetaData(key: string): Promise<{
+            contentType?: string;
+            contentLength: number;
+            etag: string;
+            lastModified: Date;
+        }>;
+        put(key: string, contents: string | Uint8Array, options?: Record<string, unknown>): Promise<void>;
+        putStream(key: string, contents: import('node:stream').Readable, options?: Record<string, unknown>): Promise<void>;
+        copy(source: string, destination: string, options?: Record<string, unknown>): Promise<void>;
+        copyFromFs(source: string | URL, destination: string, options?: Record<string, unknown>): Promise<void>;
+        move(source: string, destination: string, options?: Record<string, unknown>): Promise<void>;
+        moveFromFs(source: string | URL, destination: string, options?: Record<string, unknown>): Promise<void>;
+        delete(key: string): Promise<void>;
+        deleteAll(prefix?: string): Promise<void>;
+        listAll(prefix?: string, options?: {
+            recursive?: boolean;
+            paginationToken?: string;
+        }): Promise<{
+            paginationToken?: string;
+            objects: Iterable<unknown>;
+        }>;
+    }
+    class StorageManager extends services.Core.Service {
+        protected _exportedMethods: string[];
+        protected logHeader: string;
+        private _DiskConstructor;
+        private _FSDriver;
+        private _S3Driver;
+        private _disks;
+        private _bootstrapped;
+        private _bootstrapPromise;
+        private _initRegistered;
+        init(): void;
+        protected processDynamicImports(): Promise<void>;
+        /**
+         * Bootstrap the storage manager.
+         * Validates config and creates Disk instances for each configured disk.
+         * Called during service initialization (after Sails is ready).
+         */
+        bootstrap(): Promise<void>;
+        private getMergedStorageConfig;
+        private performBootstrap;
+        /**
+         * Create a Flydrive driver from a DiskConfig entry.
+         */
+        private createDriver;
+        /**
+         * Get a disk by name.
+         * @throws Error if disk is not found.
+         */
+        disk(name: string): IDisk;
+        /**
+         * Get the staging disk (where TUS uploads land).
+         */
+        stagingDisk(): IDisk;
+        /**
+         * Get the primary disk (permanent file storage).
+         */
+        primaryDisk(): IDisk;
+        /**
+         * Check if the manager has been bootstrapped.
+         */
+        isBootstrapped(): boolean;
+    }
+}
+declare global {
+    const StorageManagerService: Services.StorageManager;
+}
+//# sourceMappingURL=StorageManagerService.d.ts.map

package/dist/services/StorageManagerService.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"StorageManagerService.d.ts","sourceRoot":"","sources":["../../src/services/StorageManagerService.ts"],"names":[],"mappings":"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"}

package/dist/services/StorageManagerService.js

@@ -0,0 +1,234 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Services = void 0;
+const CoreService_1 = require("../CoreService");
+const storage_config_1 = require("../config/storage.config");
+/**
+ * StorageManagerService
+ *
+ * Wraps Flydrive v2 to provide a multi-disk storage abstraction.
+ * Configures disks based on sails.config.storage and exposes
+ * accessors for staging and primary disks.
+ *
+ * Flydrive is ESM-only; we load it via processDynamicImports().
+ */
+var Services;
+(function (Services) {
+    const isFlydriveModule = (value) => {
+        if (typeof value !== 'object' || value === null) {
+            return false;
+        }
+        const record = value;
+        return typeof record.Disk === 'function';
+    };
+    const isFSDriverModule = (value) => {
+        if (typeof value !== 'object' || value === null) {
+            return false;
+        }
+        const record = value;
+        return typeof record.FSDriver === 'function';
+    };
+    const isS3DriverModule = (value) => {
+        if (typeof value !== 'object' || value === null) {
+            return false;
+        }
+        const record = value;
+        return typeof record.S3Driver === 'function';
+    };
+    class StorageManager extends CoreService_1.Services.Core.Service {
+        _exportedMethods = ['init', 'bootstrap', 'disk', 'stagingDisk', 'primaryDisk', 'isBootstrapped'];
+        logHeader = 'StorageManagerService::';
+        // Flydrive module references (loaded dynamically since ESM-only)
+        _DiskConstructor = null;
+        _FSDriver = null;
+        _S3Driver = null;
+        // Map of instantiated disks, keyed by disk name
+        _disks = new Map();
+        _bootstrapped = false;
+        _bootstrapPromise = null;
+        _initRegistered = false;
+        init() {
+            if (this._initRegistered) {
+                return;
+            }
+            this._initRegistered = true;
+            this.registerSailsHook('after', 'ready', async () => {
+                try {
+                    await this.bootstrap();
+                }
+                catch (err) {
+                    this.logger.error(`${this.logHeader} Failed during bootstrap from init():`, err);
+                }
+            });
+        }
+        async processDynamicImports() {
+            try {
+                const flydriveModule = await import('flydrive');
+                if (isFlydriveModule(flydriveModule)) {
+                    this._DiskConstructor = flydriveModule.Disk;
+                }
+                else {
+                    this.logger.verbose(`${this.logHeader} Flydrive module missing Disk export`);
+                }
+            }
+            catch (err) {
+                this._DiskConstructor = null;
+                this.logger.error(`${this.logHeader} Failed to import flydrive module`, err);
+            }
+            // Use variables for subpath imports to prevent TypeScript from trying to resolve
+            // them at compile-time (flydrive uses package.json exports which require moduleResolution: nodenext)
+            const fsDriverPath = 'flydrive/drivers/fs';
+            const s3DriverPath = 'flydrive/drivers/s3';
+            try {
+                const fsModule = await import(/* webpackIgnore: true */ fsDriverPath);
+                if (isFSDriverModule(fsModule)) {
+                    this._FSDriver = fsModule.FSDriver;
+                }
+            }
+            catch {
+                this.logger.verbose(`${this.logHeader} FSDriver not available`);
+            }
+            try {
+                const s3Module = await import(/* webpackIgnore: true */ s3DriverPath);
+                if (isS3DriverModule(s3Module)) {
+                    this._S3Driver = s3Module.S3Driver;
+                }
+            }
+            catch {
+                this.logger.verbose(`${this.logHeader} S3Driver not available`);
+            }
+        }
+        /**
+         * Bootstrap the storage manager.
+         * Validates config and creates Disk instances for each configured disk.
+         * Called during service initialization (after Sails is ready).
+         */
+        async bootstrap() {
+            if (this._bootstrapped) {
+                return;
+            }
+            if (this._bootstrapPromise) {
+                await this._bootstrapPromise;
+                return;
+            }
+            this._bootstrapPromise = this.performBootstrap();
+            try {
+                await this._bootstrapPromise;
+            }
+            catch (err) {
+                this._bootstrapPromise = null;
+                throw err;
+            }
+        }
+        getMergedStorageConfig() {
+            const rawStorageConfig = (sails.config?.storage || {});
+            return {
+                ...storage_config_1.storage,
+                ...rawStorageConfig,
+                disks: rawStorageConfig.disks && Object.keys(rawStorageConfig.disks).length > 0
+                    ? rawStorageConfig.disks
+                    : storage_config_1.storage.disks,
+            };
+        }
+        async performBootstrap() {
+            if (this._bootstrapped) {
+                return;
+            }
+            const storageConfig = this.getMergedStorageConfig();
+            if (!storageConfig.disks || Object.keys(storageConfig.disks).length === 0) {
+                throw new Error('StorageManagerService: no disks configured in storage.disks and no defaults available');
+            }
+            // Validate that staging and primary disk names reference configured disks
+            const diskNames = Object.keys(storageConfig.disks);
+            if (storageConfig.stagingDisk && !diskNames.includes(storageConfig.stagingDisk)) {
+                throw new Error(`StorageManagerService: stagingDisk '${storageConfig.stagingDisk}' is not defined in storage.disks`);
+            }
+            if (storageConfig.primaryDisk && !diskNames.includes(storageConfig.primaryDisk)) {
+                throw new Error(`StorageManagerService: primaryDisk '${storageConfig.primaryDisk}' is not defined in storage.disks`);
+            }
+            // Create disks
+            for (const [name, diskConf] of Object.entries(storageConfig.disks)) {
+                const driver = this.createDriver(name, diskConf);
+                if (this._DiskConstructor) {
+                    const disk = new this._DiskConstructor(driver);
+                    this._disks.set(name, disk);
+                }
+                else {
+                    throw new Error('StorageManagerService: Flydrive Disk constructor unavailable');
+                }
+            }
+            this._bootstrapped = true;
+            this.logger.verbose(`${this.logHeader} Bootstrapped with disks: ${Array.from(this._disks.keys()).join(', ')}`);
+        }
+        /**
+         * Create a Flydrive driver from a DiskConfig entry.
+         */
+        createDriver(name, diskConf) {
+            switch (diskConf.driver) {
+                case 'fs': {
+                    if (!this._FSDriver) {
+                        throw new Error(`StorageManagerService: FSDriver not available but disk '${name}' requires it`);
+                    }
+                    return new this._FSDriver({
+                        location: diskConf.config.root,
+                        visibility: diskConf.config.visibility || 'public',
+                    });
+                }
+                case 's3': {
+                    if (!this._S3Driver) {
+                        throw new Error(`StorageManagerService: S3Driver not available but disk '${name}' requires it`);
+                    }
+                    return new this._S3Driver({
+                        credentials: {
+                            accessKeyId: diskConf.config.key,
+                            secretAccessKey: diskConf.config.secret,
+                        },
+                        region: diskConf.config.region,
+                        bucket: diskConf.config.bucket,
+                        endpoint: diskConf.config.endpoint,
+                        visibility: diskConf.config.visibility || 'public',
+                    });
+                }
+                default: {
+                    const unknownConfig = diskConf;
+                    throw new Error(`StorageManagerService: Unknown driver '${unknownConfig.driver}' for disk '${name}'`);
+                }
+            }
+        }
+        /**
+         * Get a disk by name.
+         * @throws Error if disk is not found.
+         */
+        disk(name) {
+            const d = this._disks.get(name);
+            if (!d) {
+                throw new Error(`StorageManagerService: disk '${name}' is not registered. Available: ${Array.from(this._disks.keys()).join(', ')}`);
+            }
+            return d;
+        }
+        /**
+         * Get the staging disk (where TUS uploads land).
+         */
+        stagingDisk() {
+            const mergedStorage = this.getMergedStorageConfig();
+            const stagingName = mergedStorage.stagingDisk ?? 'staging';
+            return this.disk(stagingName);
+        }
+        /**
+         * Get the primary disk (permanent file storage).
+         */
+        primaryDisk() {
+            const mergedStorage = this.getMergedStorageConfig();
+            const primaryName = mergedStorage.primaryDisk ?? 'primary';
+            return this.disk(primaryName);
+        }
+        /**
+         * Check if the manager has been bootstrapped.
+         */
+        isBootstrapped() {
+            return this._bootstrapped;
+        }
+    }
+    Services.StorageManager = StorageManager;
+})(Services || (exports.Services = Services = {}));
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"StorageManagerService.js","sourceRoot":"","sources":["../../src/services/StorageManagerService.ts"],"names":[],"mappings":";;;AAAA,gDAAsD;AACtD,6DAAsG;AAEtG;;;;;;;;GAQG;AACH,IAAiB,QAAQ,CAsRxB;AAtRD,WAAiB,QAAQ;IASvB,MAAM,gBAAgB,GAAG,CAAC,KAAc,EAA2B,EAAE;QACnE,IAAI,OAAO,KAAK,KAAK,QAAQ,IAAI,KAAK,KAAK,IAAI,EAAE,CAAC;YAChD,OAAO,KAAK,CAAC;QACf,CAAC;QACD,MAAM,MAAM,GAAG,KAAgC,CAAC;QAChD,OAAO,OAAO,MAAM,CAAC,IAAI,KAAK,UAAU,CAAC;IAC3C,CAAC,CAAC;IAEF,MAAM,gBAAgB,GAAG,CAAC,KAAc,EAA2B,EAAE;QACnE,IAAI,OAAO,KAAK,KAAK,QAAQ,IAAI,KAAK,KAAK,IAAI,EAAE,CAAC;YAChD,OAAO,KAAK,CAAC;QACf,CAAC;QACD,MAAM,MAAM,GAAG,KAAgC,CAAC;QAChD,OAAO,OAAO,MAAM,CAAC,QAAQ,KAAK,UAAU,CAAC;IAC/C,CAAC,CAAC;IAEF,MAAM,gBAAgB,GAAG,CAAC,KAAc,EAA2B,EAAE;QACnE,IAAI,OAAO,KAAK,KAAK,QAAQ,IAAI,KAAK,KAAK,IAAI,EAAE,CAAC;YAChD,OAAO,KAAK,CAAC;QACf,CAAC;QACD,MAAM,MAAM,GAAG,KAAgC,CAAC;QAChD,OAAO,OAAO,MAAM,CAAC,QAAQ,KAAK,UAAU,CAAC;IAC/C,CAAC,CAAC;IAgCF,MAAa,cAAe,SAAQ,sBAAQ,CAAC,IAAI,CAAC,OAAO;QAC7C,gBAAgB,GAAa,CAAC,MAAM,EAAE,WAAW,EAAE,MAAM,EAAE,aAAa,EAAE,aAAa,EAAE,gBAAgB,CAAC,CAAC;QAE3G,SAAS,GAAW,yBAAyB,CAAC;QAExD,iEAAiE;QACzD,gBAAgB,GAA2B,IAAI,CAAC;QAChD,SAAS,GAA+B,IAAI,CAAC;QAC7C,SAAS,GAA+B,IAAI,CAAC;QAErD,gDAAgD;QACxC,MAAM,GAAuB,IAAI,GAAG,EAAE,CAAC;QACvC,aAAa,GAAY,KAAK,CAAC;QAC/B,iBAAiB,GAAyB,IAAI,CAAC;QAC/C,eAAe,GAAY,KAAK,CAAC;QAEzB,IAAI;YAClB,IAAI,IAAI,CAAC,eAAe,EAAE,CAAC;gBACzB,OAAO;YACT,CAAC;YAED,IAAI,CAAC,eAAe,GAAG,IAAI,CAAC;YAC5B,IAAI,CAAC,iBAAiB,CAAC,OAAO,EAAE,OAAO,EAAE,KAAK,IAAI,EAAE;gBAClD,IAAI,CAAC;oBACH,MAAM,IAAI,CAAC,SAAS,EAAE,CAAC;gBACzB,CAAC;gBAAC,OAAO,GAAG,EAAE,CAAC;oBACb,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,GAAG,IAAI,CAAC,SAAS,uCAAuC,EAAE,GAAG,CAAC,CAAC;gBACnF,CAAC;YACH,CAAC,CAAC,CAAC;QACL,CAAC;QAEkB,KAAK,CAAC,qBAAqB;YAC5C,IAAI,CAAC;gBACH,MAAM,cAAc,GAAY,MAAM,MAAM,CAAC,UAAU,CAAC,CAAC;gBACzD,IAAI,gBAAgB,CAAC,cAAc,CAAC,EAAE,CAAC;oBACrC,IAAI,CAAC,gBAAgB,GAAG,cAAc,CAAC,IAAI,CAAC;gBAC9C,CAAC;qBAAM,CAAC;oBACN,IAAI,CAAC,MAAM,CAAC,OAAO,CAAC,GAAG,IAAI,CAAC,SAAS,sCAAsC,CAAC,CAAC;gBAC/E,CAAC;YACH,CAAC;YAAC,OAAO,GAAG,EAAE,CAAC;gBACb,IAAI,CAAC,gBAAgB,GAAG,IAAI,CAAC;gBAC7B,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,GAAG,IAAI,CAAC,SAAS,mCAAmC,EAAE,GAAG,CAAC,CAAC;YAC/E,CAAC;YACD,iFAAiF;YACjF,qGAAqG;YACrG,MAAM,YAAY,GAAG,qBAAqB,CAAC;YAC3C,MAAM,YAAY,GAAG,qBAAqB,CAAC;YAC3C,IAAI,CAAC;gBACH,MAAM,QAAQ,GAAY,MAAM,MAAM,CAAC,yBAAyB,CAAC,YAAY,CAAC,CAAC;gBAC/E,IAAI,gBAAgB,CAAC,QAAQ,CAAC,EAAE,CAAC;oBAC/B,IAAI,CAAC,SAAS,GAAG,QAAQ,CAAC,QAAQ,CAAC;gBACrC,CAAC;YACH,CAAC;YAAC,MAAM,CAAC;gBACP,IAAI,CAAC,MAAM,CAAC,OAAO,CAAC,GAAG,IAAI,CAAC,SAAS,yBAAyB,CAAC,CAAC;YAClE,CAAC;YACD,IAAI,CAAC;gBACH,MAAM,QAAQ,GAAY,MAAM,MAAM,CAAC,yBAAyB,CAAC,YAAY,CAAC,CAAC;gBAC/E,IAAI,gBAAgB,CAAC,QAAQ,CAAC,EAAE,CAAC;oBAC/B,IAAI,CAAC,SAAS,GAAG,QAAQ,CAAC,QAAQ,CAAC;gBACrC,CAAC;YACH,CAAC;YAAC,MAAM,CAAC;gBACP,IAAI,CAAC,MAAM,CAAC,OAAO,CAAC,GAAG,IAAI,CAAC,SAAS,yBAAyB,CAAC,CAAC;YAClE,CAAC;QACH,CAAC;QAED;;;;WAIG;QACI,KAAK,CAAC,SAAS;YACpB,IAAI,IAAI,CAAC,aAAa,EAAE,CAAC;gBACvB,OAAO;YACT,CAAC;YAED,IAAI,IAAI,CAAC,iBAAiB,EAAE,CAAC;gBAC3B,MAAM,IAAI,CAAC,iBAAiB,CAAC;gBAC7B,OAAO;YACT,CAAC;YAED,IAAI,CAAC,iBAAiB,GAAG,IAAI,CAAC,gBAAgB,EAAE,CAAC;YACjD,IAAI,CAAC;gBACH,MAAM,IAAI,CAAC,iBAAiB,CAAC;YAC/B,CAAC;YAAC,OAAO,GAAG,EAAE,CAAC;gBACb,IAAI,CAAC,iBAAiB,GAAG,IAAI,CAAC;gBAC9B,MAAM,GAAG,CAAC;YACZ,CAAC;QACH,CAAC;QAEO,sBAAsB;YAC5B,MAAM,gBAAgB,GAAG,CAAC,KAAK,CAAC,MAAM,EAAE,OAAO,IAAI,EAAE,CAAkB,CAAC;YACxE,OAAO;gBACL,GAAG,wBAAoB;gBACvB,GAAG,gBAAgB;gBACnB,KAAK,EACH,gBAAgB,CAAC,KAAK,IAAI,MAAM,CAAC,IAAI,CAAC,gBAAgB,CAAC,KAAK,CAAC,CAAC,MAAM,GAAG,CAAC;oBACtE,CAAC,CAAC,gBAAgB,CAAC,KAAK;oBACxB,CAAC,CAAC,wBAAoB,CAAC,KAAK;aACjC,CAAC;QACJ,CAAC;QAEO,KAAK,CAAC,gBAAgB;YAC5B,IAAI,IAAI,CAAC,aAAa,EAAE,CAAC;gBACvB,OAAO;YACT,CAAC;YAED,MAAM,aAAa,GAAG,IAAI,CAAC,sBAAsB,EAAE,CAAC;YAEpD,IAAI,CAAC,aAAa,CAAC,KAAK,IAAI,MAAM,CAAC,IAAI,CAAC,aAAa,CAAC,KAAK,CAAC,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;gBAC1E,MAAM,IAAI,KAAK,CAAC,uFAAuF,CAAC,CAAC;YAC3G,CAAC;YAED,0EAA0E;YAC1E,MAAM,SAAS,GAAG,MAAM,CAAC,IAAI,CAAC,aAAa,CAAC,KAAK,CAAC,CAAC;YACnD,IAAI,aAAa,CAAC,WAAW,IAAI,CAAC,SAAS,CAAC,QAAQ,CAAC,aAAa,CAAC,WAAW,CAAC,EAAE,CAAC;gBAChF,MAAM,IAAI,KAAK,CACb,uCAAuC,aAAa,CAAC,WAAW,mCAAmC,CACpG,CAAC;YACJ,CAAC;YACD,IAAI,aAAa,CAAC,WAAW,IAAI,CAAC,SAAS,CAAC,QAAQ,CAAC,aAAa,CAAC,WAAW,CAAC,EAAE,CAAC;gBAChF,MAAM,IAAI,KAAK,CACb,uCAAuC,aAAa,CAAC,WAAW,mCAAmC,CACpG,CAAC;YACJ,CAAC;YAED,eAAe;YACf,KAAK,MAAM,CAAC,IAAI,EAAE,QAAQ,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,aAAa,CAAC,KAAK,CAAC,EAAE,CAAC;gBACnE,MAAM,MAAM,GAAG,IAAI,CAAC,YAAY,CAAC,IAAI,EAAE,QAAQ,CAAC,CAAC;gBACjD,IAAI,IAAI,CAAC,gBAAgB,EAAE,CAAC;oBAC1B,MAAM,IAAI,GAAG,IAAI,IAAI,CAAC,gBAAgB,CAAC,MAAM,CAAC,CAAC;oBAC/C,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC;gBAC9B,CAAC;qBAAM,CAAC;oBACN,MAAM,IAAI,KAAK,CAAC,8DAA8D,CAAC,CAAC;gBAClF,CAAC;YACH,CAAC;YAED,IAAI,CAAC,aAAa,GAAG,IAAI,CAAC;YAC1B,IAAI,CAAC,MAAM,CAAC,OAAO,CAAC,GAAG,IAAI,CAAC,SAAS,6BAA6B,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,IAAI,EAAE,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;QACjH,CAAC;QAED;;WAEG;QACK,YAAY,CAAC,IAAY,EAAE,QAAoB;YACrD,QAAQ,QAAQ,CAAC,MAAM,EAAE,CAAC;gBACxB,KAAK,IAAI,CAAC,CAAC,CAAC;oBACV,IAAI,CAAC,IAAI,CAAC,SAAS,EAAE,CAAC;wBACpB,MAAM,IAAI,KAAK,CAAC,2DAA2D,IAAI,eAAe,CAAC,CAAC;oBAClG,CAAC;oBACD,OAAO,IAAI,IAAI,CAAC,SAAS,CAAC;wBACxB,QAAQ,EAAE,QAAQ,CAAC,MAAM,CAAC,IAAI;wBAC9B,UAAU,EAAE,QAAQ,CAAC,MAAM,CAAC,UAAU,IAAI,QAAQ;qBACnD,CAAC,CAAC;gBACL,CAAC;gBACD,KAAK,IAAI,CAAC,CAAC,CAAC;oBACV,IAAI,CAAC,IAAI,CAAC,SAAS,EAAE,CAAC;wBACpB,MAAM,IAAI,KAAK,CAAC,2DAA2D,IAAI,eAAe,CAAC,CAAC;oBAClG,CAAC;oBACD,OAAO,IAAI,IAAI,CAAC,SAAS,CAAC;wBACxB,WAAW,EAAE;4BACX,WAAW,EAAE,QAAQ,CAAC,MAAM,CAAC,GAAG;4BAChC,eAAe,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM;yBACxC;wBACD,MAAM,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM;wBAC9B,MAAM,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM;wBAC9B,QAAQ,EAAE,QAAQ,CAAC,MAAM,CAAC,QAAQ;wBAClC,UAAU,EAAE,QAAQ,CAAC,MAAM,CAAC,UAAU,IAAI,QAAQ;qBACnD,CAAC,CAAC;gBACL,CAAC;gBACD,OAAO,CAAC,CAAC,CAAC;oBACR,MAAM,aAAa,GAAG,QAAsB,CAAC;oBAC7C,MAAM,IAAI,KAAK,CAAC,0CAA0C,aAAa,CAAC,MAAM,eAAe,IAAI,GAAG,CAAC,CAAC;gBACxG,CAAC;YACH,CAAC;QACH,CAAC;QAED;;;WAGG;QACI,IAAI,CAAC,IAAY;YACtB,MAAM,CAAC,GAAG,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;YAChC,IAAI,CAAC,CAAC,EAAE,CAAC;gBACP,MAAM,IAAI,KAAK,CACb,gCAAgC,IAAI,mCAAmC,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,IAAI,EAAE,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CACnH,CAAC;YACJ,CAAC;YACD,OAAO,CAAC,CAAC;QACX,CAAC;QAED;;WAEG;QACI,WAAW;YAChB,MAAM,aAAa,GAAG,IAAI,CAAC,sBAAsB,EAAE,CAAC;YACpD,MAAM,WAAW,GAAG,aAAa,CAAC,WAAW,IAAI,SAAS,CAAC;YAC3D,OAAO,IAAI,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC;QAChC,CAAC;QAED;;WAEG;QACI,WAAW;YAChB,MAAM,aAAa,GAAG,IAAI,CAAC,sBAAsB,EAAE,CAAC;YACpD,MAAM,WAAW,GAAG,aAAa,CAAC,WAAW,IAAI,SAAS,CAAC;YAC3D,OAAO,IAAI,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC;QAChC,CAAC;QAED;;WAEG;QACI,cAAc;YACnB,OAAO,IAAI,CAAC,aAAa,CAAC;QAC5B,CAAC;KACF;IAtNY,uBAAc,iBAsN1B,CAAA;AACH,CAAC,EAtRgB,QAAQ,wBAAR,QAAQ,QAsRxB"}