@wener/common 2.0.1 → 2.0.3

package/lib/fs/s3/s3mini.test.js

@@ -0,0 +1,584 @@
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg);
+        var value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    if (info.done) {
+        resolve(value);
+    } else {
+        Promise.resolve(value).then(_next, _throw);
+    }
+}
+function _async_to_generator(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
+function _ts_generator(thisArg, body) {
+    var f, y, t, _ = {
+        label: 0,
+        sent: function() {
+            if (t[0] & 1) throw t[1];
+            return t[1];
+        },
+        trys: [],
+        ops: []
+    }, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype), d = Object.defineProperty;
+    return d(g, "next", {
+        value: verb(0)
+    }), d(g, "throw", {
+        value: verb(1)
+    }), d(g, "return", {
+        value: verb(2)
+    }), typeof Symbol === "function" && d(g, Symbol.iterator, {
+        value: function() {
+            return this;
+        }
+    }), g;
+    function verb(n) {
+        return function(v) {
+            return step([
+                n,
+                v
+            ]);
+        };
+    }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while(g && (g = 0, op[0] && (_ = 0)), _)try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [
+                op[0] & 2,
+                t.value
+            ];
+            switch(op[0]){
+                case 0:
+                case 1:
+                    t = op;
+                    break;
+                case 4:
+                    _.label++;
+                    return {
+                        value: op[1],
+                        done: false
+                    };
+                case 5:
+                    _.label++;
+                    y = op[1];
+                    op = [
+                        0
+                    ];
+                    continue;
+                case 7:
+                    op = _.ops.pop();
+                    _.trys.pop();
+                    continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+                        _ = 0;
+                        continue;
+                    }
+                    if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
+                        _.label = op[1];
+                        break;
+                    }
+                    if (op[0] === 6 && _.label < t[1]) {
+                        _.label = t[1];
+                        t = op;
+                        break;
+                    }
+                    if (t && _.label < t[2]) {
+                        _.label = t[2];
+                        _.ops.push(op);
+                        break;
+                    }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop();
+                    continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) {
+            op = [
+                6,
+                e
+            ];
+            y = 0;
+        } finally{
+            f = t = 0;
+        }
+        if (op[0] & 5) throw op[1];
+        return {
+            value: op[0] ? op[1] : void 0,
+            done: true
+        };
+    }
+}
+import { S3mini } from 's3mini';
+import { afterAll, beforeAll, describe, expect, test } from 'vitest';
+/**
+ * Tests for s3mini and S3 filesystem behavior
+ *
+ * Uses MinIO Play server for integration testing:
+ * - Endpoint: play.min.io
+ * - Access Key: Q3AM3UQ867SPQQA43P2F
+ * - Secret Key: zuf+tfteSlswRu7BJ86wekitnifILbZam1KYY3TG
+ *
+ * Note: s3mini expects bucket name to be part of the endpoint URL.
+ * e.g., https://play.min.io/bucket-name
+ *
+ * s3mini does not support anonymous access to public S3 buckets.
+ */ // Set to true to run network tests
+var RUN_NETWORK_TESTS = process.env.RUN_S3_NETWORK_TESTS === 'true';
+// Generate unique bucket name for this test run
+var TEST_BUCKET = "s3mini-test-".concat(Date.now());
+describe('s3mini with MinIO Play', function() {
+    var client;
+    beforeAll(function() {
+        return _async_to_generator(function() {
+            var e;
+            return _ts_generator(this, function(_state) {
+                switch(_state.label){
+                    case 0:
+                        if (!RUN_NETWORK_TESTS) return [
+                            2
+                        ];
+                        // s3mini expects bucket name in the endpoint URL
+                        client = new S3mini({
+                            endpoint: "https://play.min.io/".concat(TEST_BUCKET),
+                            accessKeyId: 'Q3AM3UQ867SPQQA43P2F',
+                            secretAccessKey: 'zuf+tfteSlswRu7BJ86wekitnifILbZam1KYY3TG',
+                            region: 'us-east-1'
+                        });
+                        _state.label = 1;
+                    case 1:
+                        _state.trys.push([
+                            1,
+                            3,
+                            ,
+                            4
+                        ]);
+                        return [
+                            4,
+                            client.createBucket()
+                        ];
+                    case 2:
+                        _state.sent();
+                        console.log("Created bucket: ".concat(TEST_BUCKET));
+                        return [
+                            3,
+                            4
+                        ];
+                    case 3:
+                        e = _state.sent();
+                        console.log('Bucket creation error:', e);
+                        return [
+                            3,
+                            4
+                        ];
+                    case 4:
+                        return [
+                            2
+                        ];
+                }
+            });
+        })();
+    });
+    afterAll(function() {
+        return _async_to_generator(function() {
+            var objects, keys, e;
+            return _ts_generator(this, function(_state) {
+                switch(_state.label){
+                    case 0:
+                        if (!RUN_NETWORK_TESTS || !client) return [
+                            2
+                        ];
+                        _state.label = 1;
+                    case 1:
+                        _state.trys.push([
+                            1,
+                            5,
+                            ,
+                            6
+                        ]);
+                        return [
+                            4,
+                            client.listObjects('/', '', 1000)
+                        ];
+                    case 2:
+                        objects = _state.sent();
+                        if (!(objects && objects.length > 0)) return [
+                            3,
+                            4
+                        ];
+                        keys = objects.map(function(o) {
+                            return o.Key;
+                        }).filter(Boolean);
+                        if (!(keys.length > 0)) return [
+                            3,
+                            4
+                        ];
+                        return [
+                            4,
+                            client.deleteObjects(keys)
+                        ];
+                    case 3:
+                        _state.sent();
+                        _state.label = 4;
+                    case 4:
+                        return [
+                            3,
+                            6
+                        ];
+                    case 5:
+                        e = _state.sent();
+                        console.log('Cleanup error:', e);
+                        return [
+                            3,
+                            6
+                        ];
+                    case 6:
+                        return [
+                            2
+                        ];
+                }
+            });
+        })();
+    });
+    describe.skipIf(!RUN_NETWORK_TESTS)('listObjects with delimiter', function() {
+        test('should list objects and detect directories', function() {
+            return _async_to_generator(function() {
+                var objects, dirs, files, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, dir, _iteratorNormalCompletion1, _didIteratorError1, _iteratorError1, _iterator1, _step1, file;
+                return _ts_generator(this, function(_state) {
+                    switch(_state.label){
+                        case 0:
+                            // Create test structure
+                            return [
+                                4,
+                                client.putObject('file1.txt', 'content1')
+                            ];
+                        case 1:
+                            _state.sent();
+                            return [
+                                4,
+                                client.putObject('file2.txt', 'content2')
+                            ];
+                        case 2:
+                            _state.sent();
+                            return [
+                                4,
+                                client.putObject('dir1/', '')
+                            ];
+                        case 3:
+                            _state.sent(); // Directory marker
+                            return [
+                                4,
+                                client.putObject('dir1/nested.txt', 'nested content')
+                            ];
+                        case 4:
+                            _state.sent();
+                            return [
+                                4,
+                                client.putObject('dir2/', '')
+                            ];
+                        case 5:
+                            _state.sent(); // Another directory marker
+                            return [
+                                4,
+                                client.listObjects('/', '', 100, {
+                                    delimiter: '/'
+                                })
+                            ];
+                        case 6:
+                            objects = _state.sent();
+                            console.log('MinIO Play listing with delimiter:', JSON.stringify(objects, null, 2));
+                            expect(objects).toBeDefined();
+                            expect(Array.isArray(objects)).toBe(true);
+                            if (objects && objects.length > 0) {
+                                // Check for files and directories
+                                dirs = objects.filter(function(o) {
+                                    var _o_Key;
+                                    return (_o_Key = o.Key) === null || _o_Key === void 0 ? void 0 : _o_Key.endsWith('/');
+                                });
+                                files = objects.filter(function(o) {
+                                    var _o_Key;
+                                    return !((_o_Key = o.Key) === null || _o_Key === void 0 ? void 0 : _o_Key.endsWith('/'));
+                                });
+                                console.log("Found ".concat(dirs.length, " directories and ").concat(files.length, " files"));
+                                console.log('Directories:', dirs.map(function(d) {
+                                    return d.Key;
+                                }));
+                                console.log('Files:', files.map(function(f) {
+                                    return f.Key;
+                                }));
+                                _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+                                try {
+                                    // Directories should have Size: 0
+                                    for(_iterator = dirs[Symbol.iterator](); !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                                        dir = _step.value;
+                                        expect(Number(dir.Size)).toBe(0);
+                                        expect(dir.Key).toMatch(/\/$/);
+                                    }
+                                } catch (err) {
+                                    _didIteratorError = true;
+                                    _iteratorError = err;
+                                } finally{
+                                    try {
+                                        if (!_iteratorNormalCompletion && _iterator.return != null) {
+                                            _iterator.return();
+                                        }
+                                    } finally{
+                                        if (_didIteratorError) {
+                                            throw _iteratorError;
+                                        }
+                                    }
+                                }
+                                _iteratorNormalCompletion1 = true, _didIteratorError1 = false, _iteratorError1 = undefined;
+                                try {
+                                    // Files should have Size > 0
+                                    for(_iterator1 = files[Symbol.iterator](); !(_iteratorNormalCompletion1 = (_step1 = _iterator1.next()).done); _iteratorNormalCompletion1 = true){
+                                        file = _step1.value;
+                                        expect(Number(file.Size)).toBeGreaterThan(0);
+                                        expect(file.Key).not.toMatch(/\/$/);
+                                    }
+                                } catch (err) {
+                                    _didIteratorError1 = true;
+                                    _iteratorError1 = err;
+                                } finally{
+                                    try {
+                                        if (!_iteratorNormalCompletion1 && _iterator1.return != null) {
+                                            _iterator1.return();
+                                        }
+                                    } finally{
+                                        if (_didIteratorError1) {
+                                            throw _iteratorError1;
+                                        }
+                                    }
+                                }
+                            }
+                            return [
+                                2
+                            ];
+                    }
+                });
+            })();
+        });
+        test('should list nested directory contents', function() {
+            return _async_to_generator(function() {
+                var objects, files;
+                return _ts_generator(this, function(_state) {
+                    switch(_state.label){
+                        case 0:
+                            return [
+                                4,
+                                client.listObjects('/', 'dir1/', 100, {
+                                    delimiter: '/'
+                                })
+                            ];
+                        case 1:
+                            objects = _state.sent();
+                            console.log('MinIO Play dir1/ listing:', JSON.stringify(objects, null, 2));
+                            expect(objects).toBeDefined();
+                            expect(Array.isArray(objects)).toBe(true);
+                            // Should find nested.txt
+                            files = (objects === null || objects === void 0 ? void 0 : objects.filter(function(o) {
+                                var _o_Key;
+                                return !((_o_Key = o.Key) === null || _o_Key === void 0 ? void 0 : _o_Key.endsWith('/'));
+                            })) || [];
+                            expect(files.some(function(f) {
+                                var _f_Key;
+                                return (_f_Key = f.Key) === null || _f_Key === void 0 ? void 0 : _f_Key.includes('nested.txt');
+                            })).toBe(true);
+                            return [
+                                2
+                            ];
+                    }
+                });
+            })();
+        });
+    });
+});
+/**
+ * Unit tests for S3 directory detection logic (no network required)
+ *
+ * When using delimiter: '/' with listObjects, S3 returns:
+ * - Files: Key without trailing /, Size > 0
+ * - Directories: Key with trailing /, Size: 0
+ */ describe('s3mini listObjects behavior', function() {
+    test('directory detection logic - directories end with / and have Size: 0', function() {
+        // Mock response similar to user's example
+        var mockResponse = [
+            {
+                Key: 'fusion/README.md',
+                LastModified: '2025-12-18T01:51:09.000Z',
+                ETag: '"adc69293e8fd256b2609664f1e11cb53"',
+                Size: 6,
+                StorageClass: 'STANDARD'
+            },
+            {
+                Key: 'fusion/home/',
+                Size: 0,
+                LastModified: new Date('1970-01-01T00:00:00.000Z'),
+                ETag: '',
+                StorageClass: ''
+            },
+            {
+                Key: 'fusion/mcp/',
+                Size: 0,
+                LastModified: new Date('1970-01-01T00:00:00.000Z'),
+                ETag: '',
+                StorageClass: ''
+            }
+        ];
+        var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+        try {
+            // Test directory detection logic
+            for(var _iterator = mockResponse[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                var obj = _step.value;
+                var isDir = obj.Key.endsWith('/');
+                if (isDir) {
+                    expect(obj.Size).toBe(0);
+                    expect(obj.Key).toMatch(/\/$/);
+                } else {
+                    expect(obj.Size).toBeGreaterThan(0);
+                    expect(obj.Key).not.toMatch(/\/$/);
+                }
+            }
+        } catch (err) {
+            _didIteratorError = true;
+            _iteratorError = err;
+        } finally{
+            try {
+                if (!_iteratorNormalCompletion && _iterator.return != null) {
+                    _iterator.return();
+                }
+            } finally{
+                if (_didIteratorError) {
+                    throw _iteratorError;
+                }
+            }
+        }
+        // Count directories and files
+        var dirs = mockResponse.filter(function(o) {
+            return o.Key.endsWith('/');
+        });
+        var files = mockResponse.filter(function(o) {
+            return !o.Key.endsWith('/');
+        });
+        expect(dirs).toHaveLength(2);
+        expect(files).toHaveLength(1);
+    });
+    test('readdir should properly identify directories from S3 response', function() {
+        var s3Response = [
+            {
+                Key: 'fusion/README.md',
+                Size: 6,
+                LastModified: new Date(),
+                ETag: '"abc"'
+            },
+            {
+                Key: 'fusion/home/',
+                Size: 0,
+                LastModified: new Date(0),
+                ETag: ''
+            },
+            {
+                Key: 'fusion/mcp/',
+                Size: 0,
+                LastModified: new Date(0),
+                ETag: ''
+            }
+        ];
+        var results = s3Response.map(function(obj) {
+            var key = obj.Key;
+            var isDir = key.endsWith('/');
+            var name = isDir ? key.slice(0, -1).split('/').pop() : key.split('/').pop();
+            return {
+                name: name,
+                kind: isDir ? 'directory' : 'file',
+                size: obj.Size
+            };
+        });
+        expect(results).toEqual([
+            {
+                name: 'README.md',
+                kind: 'file',
+                size: 6
+            },
+            {
+                name: 'home',
+                kind: 'directory',
+                size: 0
+            },
+            {
+                name: 'mcp',
+                kind: 'directory',
+                size: 0
+            }
+        ]);
+    });
+    test('should handle nested paths correctly', function() {
+        var s3Response = [
+            {
+                Key: 'data/2024/01/file.csv',
+                Size: 1024
+            },
+            {
+                Key: 'data/2024/02/',
+                Size: 0
+            },
+            {
+                Key: 'data/config.json',
+                Size: 256
+            }
+        ];
+        var prefix = 'data/';
+        var results = s3Response.map(function(obj) {
+            var key = obj.Key;
+            var relativeKey = key.startsWith(prefix) ? key.slice(prefix.length) : key;
+            var isDir = key.endsWith('/');
+            var parts = relativeKey.split('/').filter(Boolean);
+            var name = parts[0];
+            return {
+                key: key,
+                relativeKey: relativeKey,
+                name: name,
+                isDir: isDir
+            };
+        });
+        // For non-recursive listing, only want immediate children
+        var immediateChildren = results.filter(function(r) {
+            var keyWithoutTrailingSlash = r.relativeKey.replace(/\/$/, '');
+            return !keyWithoutTrailingSlash.includes('/');
+        });
+        expect(immediateChildren).toHaveLength(1);
+        expect(immediateChildren[0].name).toBe('config.json');
+    });
+    test('should correctly strip prefix and build file stat', function() {
+        var prefix = 'myapp/data';
+        var normalizedPrefix = prefix.replace(/^\/+/, '').replace(/\/+$/, '');
+        var stripPrefix = function(key) {
+            if (!normalizedPrefix || !key.startsWith(normalizedPrefix + '/')) {
+                return key.startsWith('/') ? key : '/' + key;
+            }
+            var withoutPrefix = key.slice(normalizedPrefix.length);
+            return withoutPrefix || '/';
+        };
+        expect(stripPrefix('myapp/data/file.txt')).toBe('/file.txt');
+        expect(stripPrefix('myapp/data/subdir/')).toBe('/subdir/');
+        expect(stripPrefix('myapp/data/')).toBe('/');
+        expect(stripPrefix('other/path')).toBe('/other/path');
+    });
+});

package/lib/fs/scandir.js

@@ -0,0 +1,59 @@
+import pathe from "pathe";
+export async function* scandir(options) {
+    const { readdir, path: startPath, signal, depth = 1, limit, strategy = 'depth', filter = ()=>true } = options;
+    let cursor = options.cursor;
+    if (cursor && !cursor.startsWith('/')) {
+        cursor = pathe.join(startPath, cursor);
+    }
+    if (cursor && !cursor.startsWith(startPath)) {
+        throw new Error(`Cursor path "${cursor}" is not within the start path "${startPath}"`);
+    }
+    if (signal?.aborted) return;
+    // Collection to manage which directories to visit next.
+    // For 'depth'-first, it acts as a Stack (LIFO).
+    // For 'breadth'-first, it acts as a Queue (FIFO).
+    const collection = [
+        {
+            path: startPath,
+            level: 1
+        }
+    ];
+    let yielded = 0;
+    let cursorFound = !cursor; // If no cursor is provided, we can start yielding immediately.
+    while(collection.length > 0){
+        if (signal?.aborted) return;
+        if (limit && yielded >= limit) return;
+        // Get the next directory to process based on the strategy.
+        const { path: currentPath, level: currentLevel } = strategy === 'depth' ? collection.pop() : collection.shift(); // FIFO for breadth-first
+        let entries;
+        try {
+            entries = await readdir(currentPath);
+        } catch (error) {
+            // Could not read directory, skip it. You might want to log this error.
+            console.warn(`scandir: Could not read directory ${currentPath}`, error);
+            continue;
+        }
+        for (const file of entries){
+            if (signal?.aborted) return;
+            if (!cursorFound) {
+                if (file.path === cursor) {
+                    cursorFound = true;
+                }
+                continue;
+            }
+            if (filter(file)) {
+                yield file;
+                yielded++;
+                if (limit && yielded >= limit) return;
+            }
+            if (file.kind === 'directory' && currentLevel < depth) {
+                collection.push({
+                    path: file.path,
+                    level: currentLevel + 1
+                });
+            }
+        }
+    }
+}
+
+//# sourceMappingURL=scandir.js.map

package/lib/fs/scandir.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/fs/scandir.ts"],"sourcesContent":["import pathe from 'pathe';\nimport type { IFileStat } from './IFileSystem';\n\nexport type ScandirOptions = {\n\treaddir: (path: string) => Promise<IFileStat[]>;\n\tpath: string;\n\tsignal?: AbortSignal;\n\tcursor?: string;\n\tdepth?: number;\n\tlimit?: number;\n\tstrategy?: 'depth' | 'breadth';\n\tfilter?: (file: IFileStat) => boolean;\n};\n\nexport async function* scandir(options: ScandirOptions): AsyncGenerator<IFileStat> {\n\tconst { readdir, path: startPath, signal, depth = 1, limit, strategy = 'depth', filter = () => true } = options;\n\tlet cursor = options.cursor;\n\tif (cursor && !cursor.startsWith('/')) {\n\t\tcursor = pathe.join(startPath, cursor);\n\t}\n\tif (cursor && !cursor.startsWith(startPath)) {\n\t\tthrow new Error(`Cursor path \"${cursor}\" is not within the start path \"${startPath}\"`);\n\t}\n\n\tif (signal?.aborted) return;\n\n\t// Collection to manage which directories to visit next.\n\t// For 'depth'-first, it acts as a Stack (LIFO).\n\t// For 'breadth'-first, it acts as a Queue (FIFO).\n\tconst collection: { path: string; level: number }[] = [{ path: startPath, level: 1 }];\n\n\tlet yielded = 0;\n\tlet cursorFound = !cursor; // If no cursor is provided, we can start yielding immediately.\n\n\twhile (collection.length > 0) {\n\t\tif (signal?.aborted) return;\n\t\tif (limit && yielded >= limit) return;\n\n\t\t// Get the next directory to process based on the strategy.\n\t\tconst { path: currentPath, level: currentLevel } =\n\t\t\tstrategy === 'depth'\n\t\t\t\t? collection.pop()! // LIFO for depth-first\n\t\t\t\t: collection.shift()!; // FIFO for breadth-first\n\n\t\tlet entries: IFileStat[];\n\t\ttry {\n\t\t\tentries = await readdir(currentPath);\n\t\t} catch (error) {\n\t\t\t// Could not read directory, skip it. You might want to log this error.\n\t\t\tconsole.warn(`scandir: Could not read directory ${currentPath}`, error);\n\t\t\tcontinue;\n\t\t}\n\n\t\tfor (const file of entries) {\n\t\t\tif (signal?.aborted) return;\n\n\t\t\tif (!cursorFound) {\n\t\t\t\tif (file.path === cursor) {\n\t\t\t\t\tcursorFound = true;\n\t\t\t\t}\n\t\t\t\tcontinue;\n\t\t\t}\n\n\t\t\tif (filter(file)) {\n\t\t\t\tyield file;\n\t\t\t\tyielded++;\n\t\t\t\tif (limit && yielded >= limit) return;\n\t\t\t}\n\n\t\t\tif (file.kind === 'directory' && currentLevel < depth) {\n\t\t\t\tcollection.push({ path: file.path, level: currentLevel + 1 });\n\t\t\t}\n\t\t}\n\t}\n}\n"],"names":["pathe","scandir","options","readdir","path","startPath","signal","depth","limit","strategy","filter","cursor","startsWith","join","Error","aborted","collection","level","yielded","cursorFound","length","currentPath","currentLevel","pop","shift","entries","error","console","warn","file","kind","push"],"mappings":"AAAA,OAAOA,WAAW,QAAQ;AAc1B,OAAO,gBAAgBC,QAAQC,OAAuB;IACrD,MAAM,EAAEC,OAAO,EAAEC,MAAMC,SAAS,EAAEC,MAAM,EAAEC,QAAQ,CAAC,EAAEC,KAAK,EAAEC,WAAW,OAAO,EAAEC,SAAS,IAAM,IAAI,EAAE,GAAGR;IACxG,IAAIS,SAAST,QAAQS,MAAM;IAC3B,IAAIA,UAAU,CAACA,OAAOC,UAAU,CAAC,MAAM;QACtCD,SAASX,MAAMa,IAAI,CAACR,WAAWM;IAChC;IACA,IAAIA,UAAU,CAACA,OAAOC,UAAU,CAACP,YAAY;QAC5C,MAAM,IAAIS,MAAM,CAAC,aAAa,EAAEH,OAAO,gCAAgC,EAAEN,UAAU,CAAC,CAAC;IACtF;IAEA,IAAIC,QAAQS,SAAS;IAErB,wDAAwD;IACxD,gDAAgD;IAChD,kDAAkD;IAClD,MAAMC,aAAgD;QAAC;YAAEZ,MAAMC;YAAWY,OAAO;QAAE;KAAE;IAErF,IAAIC,UAAU;IACd,IAAIC,cAAc,CAACR,QAAQ,+DAA+D;IAE1F,MAAOK,WAAWI,MAAM,GAAG,EAAG;QAC7B,IAAId,QAAQS,SAAS;QACrB,IAAIP,SAASU,WAAWV,OAAO;QAE/B,2DAA2D;QAC3D,MAAM,EAAEJ,MAAMiB,WAAW,EAAEJ,OAAOK,YAAY,EAAE,GAC/Cb,aAAa,UACVO,WAAWO,GAAG,KACdP,WAAWQ,KAAK,IAAK,yBAAyB;QAElD,IAAIC;QACJ,IAAI;YACHA,UAAU,MAAMtB,QAAQkB;QACzB,EAAE,OAAOK,OAAO;YACf,uEAAuE;YACvEC,QAAQC,IAAI,CAAC,CAAC,kCAAkC,EAAEP,aAAa,EAAEK;YACjE;QACD;QAEA,KAAK,MAAMG,QAAQJ,QAAS;YAC3B,IAAInB,QAAQS,SAAS;YAErB,IAAI,CAACI,aAAa;gBACjB,IAAIU,KAAKzB,IAAI,KAAKO,QAAQ;oBACzBQ,cAAc;gBACf;gBACA;YACD;YAEA,IAAIT,OAAOmB,OAAO;gBACjB,MAAMA;gBACNX;gBACA,IAAIV,SAASU,WAAWV,OAAO;YAChC;YAEA,IAAIqB,KAAKC,IAAI,KAAK,eAAeR,eAAef,OAAO;gBACtDS,WAAWe,IAAI,CAAC;oBAAE3B,MAAMyB,KAAKzB,IAAI;oBAAEa,OAAOK,eAAe;gBAAE;YAC5D;QACD;IACD;AACD"}