Index: imaps-frontend/node_modules/@discoveryjs/json-ext/LICENSE
===================================================================
--- imaps-frontend/node_modules/@discoveryjs/json-ext/LICENSE	(revision 79a03170cdde4e801d12257ee86723774970427b)
+++ imaps-frontend/node_modules/@discoveryjs/json-ext/LICENSE	(revision 79a03170cdde4e801d12257ee86723774970427b)
@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2020-2024 Roman Dvornov <rdvornov@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
Index: imaps-frontend/node_modules/@discoveryjs/json-ext/README.md
===================================================================
--- imaps-frontend/node_modules/@discoveryjs/json-ext/README.md	(revision 79a03170cdde4e801d12257ee86723774970427b)
+++ imaps-frontend/node_modules/@discoveryjs/json-ext/README.md	(revision 79a03170cdde4e801d12257ee86723774970427b)
@@ -0,0 +1,290 @@
+# json-ext
+
+[![NPM version](https://img.shields.io/npm/v/@discoveryjs/json-ext.svg)](https://www.npmjs.com/package/@discoveryjs/json-ext)
+[![Build Status](https://github.com/discoveryjs/json-ext/actions/workflows/ci.yml/badge.svg)](https://github.com/discoveryjs/json-ext/actions/workflows/ci.yml)
+[![Coverage Status](https://coveralls.io/repos/github/discoveryjs/json-ext/badge.svg?branch=master)](https://coveralls.io/github/discoveryjs/json-ext)
+[![NPM Downloads](https://img.shields.io/npm/dm/@discoveryjs/json-ext.svg)](https://www.npmjs.com/package/@discoveryjs/json-ext)
+
+A set of utilities designed to extend JSON's capabilities, especially for handling large JSON data (over 100MB) efficiently:
+
+- [parseChunked()](#parsechunked) – Parses JSON incrementally; similar to [`JSON.parse()`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/JSON/parse), but processing JSON data in chunks.
+- [stringifyChunked()](#stringifychunked) – Converts JavaScript objects to JSON incrementally; similar to [`JSON.stringify()`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/JSON/stringify), but returns a generator that yields JSON strings in parts.
+- [stringifyInfo()](#stringifyinfo) – Estimates the size of the `JSON.stringify()` result and identifies circular references without generating the JSON.
+- [parseFromWebStream()](#parsefromwebstream) – A helper function to parse JSON chunks directly from a Web Stream.
+- [createStringifyWebStream()](#createstringifywebstream) – A helper function to generate JSON data as a Web Stream.
+
+### Key Features
+
+- Optimized to handle large JSON data with minimal resource usage (see [benchmarks](./benchmarks/README.md))
+- Works seamlessly with browsers, Node.js, Deno, and Bun
+- Supports both Node.js and Web streams
+- Available in both ESM and CommonJS
+- TypeScript typings included
+- No external dependencies
+- Compact size: 9.4Kb (minified), 3.8Kb (min+gzip)
+
+### Why json-ext?
+
+- **Handles large JSON files**: Overcomes the limitations of V8 for strings larger than ~500MB, enabling the processing of huge JSON data.
+- **Prevents main thread blocking**: Distributes parsing and stringifying over time, ensuring the main thread remains responsive during heavy JSON operations.
+- **Reduces memory usage**: Traditional `JSON.parse()` and `JSON.stringify()` require loading entire data into memory, leading to high memory consumption and increased garbage collection pressure. `parseChunked()` and `stringifyChunked()` process data incrementally, optimizing memory usage.
+- **Size estimation**: `stringifyInfo()` allows estimating the size of resulting JSON before generating it, enabling better decision-making for JSON generation strategies.
+
+## Install
+
+```bash
+npm install @discoveryjs/json-ext
+```
+
+## API
+
+### parseChunked()
+
+Functions like [`JSON.parse()`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/JSON/parse), iterating over chunks to reconstruct the result object, and returns a [Promise](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise).
+
+> Note: `reviver` parameter is not supported yet.
+
+```ts
+function parseChunked(input: Iterable<Chunk> | AsyncIterable<Chunk>): Promise<any>;
+function parseChunked(input: () => (Iterable<Chunk> | AsyncIterable<Chunk>)): Promise<any>;
+
+type Chunk = string | Buffer | Uint8Array;
+```
+
+[Benchmark](https://github.com/discoveryjs/json-ext/tree/master/benchmarks#parse-chunked)
+
+Usage:
+
+```js
+import { parseChunked } from '@discoveryjs/json-ext';
+
+const data = await parseChunked(chunkEmitter);
+```
+
+Parameter `chunkEmitter` can be an iterable or async iterable that iterates over chunks, or a function returning such a value. A chunk can be a `string`, `Uint8Array`, or Node.js `Buffer`.
+
+Examples:
+
+- Generator:
+    ```js
+    parseChunked(function*() {
+        yield '{ "hello":';
+        yield Buffer.from(' "wor'); // Node.js only
+        yield new TextEncoder().encode('ld" }'); // returns Uint8Array
+    });
+    ```
+- Async generator:
+    ```js
+    parseChunked(async function*() {
+        for await (const chunk of someAsyncSource) {
+            yield chunk;
+        }
+    });
+    ```
+- Array:
+    ```js
+    parseChunked(['{ "hello":', ' "world"}'])
+    ```
+- Function returning iterable:
+    ```js
+    parseChunked(() => ['{ "hello":', ' "world"}'])
+    ```
+- Node.js [`Readable`](https://nodejs.org/dist/latest-v14.x/docs/api/stream.html#stream_readable_streams) stream:
+    ```js
+    import fs from 'node:fs';
+
+    parseChunked(fs.createReadStream('path/to/file.json'))
+    ```
+- Web stream (e.g., using [fetch()](https://developer.mozilla.org/en-US/docs/Web/API/Fetch_API)):
+    > Note: Iterability for Web streams was added later in the Web platform, not all environments support it. Consider using `parseFromWebStream()` for broader compatibility.
+    ```js
+    const response = await fetch('https://example.com/data.json');
+    const data = await parseChunked(response.body); // body is ReadableStream
+    ```
+
+### stringifyChunked()
+
+Functions like [`JSON.stringify()`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/JSON/stringify), but returns a generator yielding strings instead of a single string.
+
+> Note: Returns `"null"` when `JSON.stringify()` returns `undefined` (since a chunk cannot be `undefined`).
+
+```ts
+function stringifyChunked(value: any, replacer?: Replacer, space?: Space): Generator<string, void, unknown>;
+function stringifyChunked(value: any, options: StringifyOptions): Generator<string, void, unknown>;
+
+type Replacer =
+    | ((this: any, key: string, value: any) => any)
+    | (string | number)[]
+    | null;
+type Space = string | number | null;
+type StringifyOptions = {
+    replacer?: Replacer;
+    space?: Space;
+    highWaterMark?: number;
+};
+```
+
+[Benchmark](https://github.com/discoveryjs/json-ext/tree/master/benchmarks#stream-stringifying)
+
+Usage:
+
+- Getting an array of chunks:
+    ```js
+    const chunks = [...stringifyChunked(data)];
+    ```
+- Iterating over chunks:
+    ```js
+    for (const chunk of stringifyChunked(data)) {
+        console.log(chunk);
+    }
+    ```
+- Specifying the minimum size of a chunk with `highWaterMark` option:
+    ```js
+    const data = [1, "hello world", 42];
+
+    console.log([...stringifyChunked(data)]); // default 16kB
+    // ['[1,"hello world",42]']
+
+    console.log([...stringifyChunked(data, { highWaterMark: 16 })]);
+    // ['[1,"hello world"', ',42]']
+
+    console.log([...stringifyChunked(data, { highWaterMark: 1 })]);
+    // ['[1', ',"hello world"', ',42', ']']
+    ```
+- Streaming into a stream with a `Promise` (modern Node.js):
+    ```js
+    import { pipeline } from 'node:stream/promises';
+    import fs from 'node:fs';
+
+    await pipeline(
+        stringifyChunked(data),
+        fs.createWriteStream('path/to/file.json')
+    );
+    ```
+- Wrapping into a `Promise` streaming into a stream (legacy Node.js):
+    ```js
+    import { Readable } from 'node:stream';
+
+    new Promise((resolve, reject) => {
+        Readable.from(stringifyChunked(data))
+            .on('error', reject)
+            .pipe(stream)
+            .on('error', reject)
+            .on('finish', resolve);
+    });
+    ```
+- Writing into a file synchronously:
+    > Note: Slower than `JSON.stringify()` but uses much less heap space and has no limitation on string length
+    ```js
+    import fs from 'node:fs';
+
+    const fd = fs.openSync('output.json', 'w');
+
+    for (const chunk of stringifyChunked(data)) {
+        fs.writeFileSync(fd, chunk);
+    }
+
+    fs.closeSync(fd);
+    ```
+- Using with fetch (JSON streaming):
+    > Note: This feature has limited support in browsers, see [Streaming requests with the fetch API](https://developer.chrome.com/docs/capabilities/web-apis/fetch-streaming-requests)
+
+    > Note: `ReadableStream.from()` has limited [support in browsers](https://developer.mozilla.org/en-US/docs/Web/API/ReadableStream/from_static), use [`createStringifyWebStream()`](#createstringifywebstream) instead.
+    ```js
+    fetch('http://example.com', {
+        method: 'POST',
+        duplex: 'half',
+        body: ReadableStream.from(stringifyChunked(data))
+    });
+    ```
+- Wrapping into `ReadableStream`:
+    > Note: Use `ReadableStream.from()` or [`createStringifyWebStream()`](#createstringifywebstream) when no extra logic is needed
+    ```js
+    new ReadableStream({
+        start() {
+            this.generator = stringifyChunked(data);
+        },
+        pull(controller) {
+            const { value, done } = this.generator.next();
+
+            if (done) {
+                controller.close();
+            } else {
+                controller.enqueue(value);
+            }
+        },
+        cancel() {
+            this.generator = null;
+        }
+    });
+    ```
+
+### stringifyInfo()
+
+```ts
+export function stringifyInfo(value: any, replacer?: Replacer, space?: Space): StringifyInfoResult;
+export function stringifyInfo(value: any, options?: StringifyInfoOptions): StringifyInfoResult;
+
+type StringifyInfoOptions = {
+    replacer?: Replacer;
+    space?: Space;
+    continueOnCircular?: boolean;
+}
+type StringifyInfoResult = {
+    bytes: number;      // size of JSON in bytes
+    spaceBytes: number; // size of white spaces in bytes (when space option used)
+    circular: object[]; // list of circular references
+};
+```
+
+Functions like [`JSON.stringify()`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/JSON/stringify), but returns an object with the expected overall size of the stringify operation and a list of circular references.
+
+Example:
+
+```js
+import { stringifyInfo } from '@discoveryjs/json-ext';
+
+console.log(stringifyInfo({ test: true }, null, 4));
+// {
+//   bytes: 20,     // Buffer.byteLength('{\n    "test": true\n}')
+//   spaceBytes: 7,
+//   circular: []    
+// }
+```
+
+#### Options
+
+##### continueOnCircular
+
+Type: `Boolean`  
+Default: `false`
+
+Determines whether to continue collecting info for a value when a circular reference is found. Setting this option to `true` allows finding all circular references.
+
+### parseFromWebStream()
+
+A helper function to consume JSON from a Web Stream. You can use `parseChunked(stream)` instead, but `@@asyncIterator` on `ReadableStream` has limited support in browsers (see [ReadableStream](https://developer.mozilla.org/en-US/docs/Web/API/ReadableStream) compatibility table).
+
+```js
+import { parseFromWebStream } from '@discoveryjs/json-ext';
+
+const data = await parseFromWebStream(readableStream);
+// equivalent to (when ReadableStream[@@asyncIterator] is supported):
+// await parseChunked(readableStream);
+```
+
+### createStringifyWebStream()
+
+A helper function to convert `stringifyChunked()` into a `ReadableStream` (Web Stream). You can use `ReadableStream.from()` instead, but this method has limited support in browsers (see [ReadableStream.from()](https://developer.mozilla.org/en-US/docs/Web/API/ReadableStream/from_static) compatibility table).
+
+```js
+import { createStringifyWebStream } from '@discoveryjs/json-ext';
+
+createStringifyWebStream({ test: true });
+// equivalent to (when ReadableStream.from() is supported):
+// ReadableStream.from(stringifyChunked({ test: true }))
+```
+
+## License
+
+MIT
Index: imaps-frontend/node_modules/@discoveryjs/json-ext/cjs/index.cjs
===================================================================
--- imaps-frontend/node_modules/@discoveryjs/json-ext/cjs/index.cjs	(revision 79a03170cdde4e801d12257ee86723774970427b)
+++ imaps-frontend/node_modules/@discoveryjs/json-ext/cjs/index.cjs	(revision 79a03170cdde4e801d12257ee86723774970427b)
@@ -0,0 +1,14 @@
+'use strict';
+
+const parseChunked = require('./parse-chunked.cjs');
+const stringifyChunked = require('./stringify-chunked.cjs');
+const stringifyInfo = require('./stringify-info.cjs');
+const webStreams = require('./web-streams.cjs');
+
+
+
+exports.parseChunked = parseChunked.parseChunked;
+exports.stringifyChunked = stringifyChunked.stringifyChunked;
+exports.stringifyInfo = stringifyInfo.stringifyInfo;
+exports.createStringifyWebStream = webStreams.createStringifyWebStream;
+exports.parseFromWebStream = webStreams.parseFromWebStream;
Index: imaps-frontend/node_modules/@discoveryjs/json-ext/cjs/parse-chunked.cjs
===================================================================
--- imaps-frontend/node_modules/@discoveryjs/json-ext/cjs/parse-chunked.cjs	(revision 79a03170cdde4e801d12257ee86723774970427b)
+++ imaps-frontend/node_modules/@discoveryjs/json-ext/cjs/parse-chunked.cjs	(revision 79a03170cdde4e801d12257ee86723774970427b)
@@ -0,0 +1,355 @@
+'use strict';
+
+const utils = require('./utils.cjs');
+
+const STACK_OBJECT = 1;
+const STACK_ARRAY = 2;
+const decoder = new TextDecoder();
+
+function adjustPosition(error, parser) {
+    if (error.name === 'SyntaxError' && parser.jsonParseOffset) {
+        error.message = error.message.replace(/at position (\d+)/, (_, pos) =>
+            'at position ' + (Number(pos) + parser.jsonParseOffset)
+        );
+    }
+
+    return error;
+}
+
+function append(array, elements) {
+    // Note: Avoid to use array.push(...elements) since it may lead to
+    // "RangeError: Maximum call stack size exceeded" for a long arrays
+    const initialLength = array.length;
+    array.length += elements.length;
+
+    for (let i = 0; i < elements.length; i++) {
+        array[initialLength + i] = elements[i];
+    }
+}
+
+async function parseChunked(chunkEmitter) {
+    const iterable = typeof chunkEmitter === 'function'
+        ? chunkEmitter()
+        : chunkEmitter;
+
+    if (utils.isIterable(iterable)) {
+        let parser = new ChunkParser();
+
+        try {
+            for await (const chunk of iterable) {
+                if (typeof chunk !== 'string' && !ArrayBuffer.isView(chunk)) {
+                    throw new TypeError('Invalid chunk: Expected string, TypedArray or Buffer');
+                }
+
+                parser.push(chunk);
+            }
+
+            return parser.finish();
+        } catch (e) {
+            throw adjustPosition(e, parser);
+        }
+    }
+
+    throw new TypeError(
+        'Invalid chunk emitter: Expected an Iterable, AsyncIterable, generator, ' +
+        'async generator, or a function returning an Iterable or AsyncIterable'
+    );
+}
+class ChunkParser {
+    constructor() {
+        this.value = undefined;
+        this.valueStack = null;
+
+        this.stack = new Array(100);
+        this.lastFlushDepth = 0;
+        this.flushDepth = 0;
+        this.stateString = false;
+        this.stateStringEscape = false;
+        this.pendingByteSeq = null;
+        this.pendingChunk = null;
+        this.chunkOffset = 0;
+        this.jsonParseOffset = 0;
+    }
+
+    parseAndAppend(fragment, wrap) {
+        // Append new entries or elements
+        if (this.stack[this.lastFlushDepth - 1] === STACK_OBJECT) {
+            if (wrap) {
+                this.jsonParseOffset--;
+                fragment = '{' + fragment + '}';
+            }
+
+            Object.assign(this.valueStack.value, JSON.parse(fragment));
+        } else {
+            if (wrap) {
+                this.jsonParseOffset--;
+                fragment = '[' + fragment + ']';
+            }
+
+            append(this.valueStack.value, JSON.parse(fragment));
+        }
+    }
+
+    prepareAddition(fragment) {
+        const { value } = this.valueStack;
+        const expectComma = Array.isArray(value)
+            ? value.length !== 0
+            : Object.keys(value).length !== 0;
+
+        if (expectComma) {
+            // Skip a comma at the beginning of fragment, otherwise it would
+            // fail to parse
+            if (fragment[0] === ',') {
+                this.jsonParseOffset++;
+                return fragment.slice(1);
+            }
+
+            // When value (an object or array) is not empty and a fragment
+            // doesn't start with a comma, a single valid fragment starting
+            // is a closing bracket. If it's not, a prefix is adding to fail
+            // parsing. Otherwise, the sequence of chunks can be successfully
+            // parsed, although it should not, e.g. ["[{}", "{}]"]
+            if (fragment[0] !== '}' && fragment[0] !== ']') {
+                this.jsonParseOffset -= 3;
+                return '[[]' + fragment;
+            }
+        }
+
+        return fragment;
+    }
+
+    flush(chunk, start, end) {
+        let fragment = chunk.slice(start, end);
+
+        // Save position correction an error in JSON.parse() if any
+        this.jsonParseOffset = this.chunkOffset + start;
+
+        // Prepend pending chunk if any
+        if (this.pendingChunk !== null) {
+            fragment = this.pendingChunk + fragment;
+            this.jsonParseOffset -= this.pendingChunk.length;
+            this.pendingChunk = null;
+        }
+
+        if (this.flushDepth === this.lastFlushDepth) {
+            // Depth didn't changed, so it's a root value or entry/element set
+            if (this.flushDepth > 0) {
+                this.parseAndAppend(this.prepareAddition(fragment), true);
+            } else {
+                // That's an entire value on a top level
+                this.value = JSON.parse(fragment);
+                this.valueStack = {
+                    value: this.value,
+                    prev: null
+                };
+            }
+        } else if (this.flushDepth > this.lastFlushDepth) {
+            // Add missed closing brackets/parentheses
+            for (let i = this.flushDepth - 1; i >= this.lastFlushDepth; i--) {
+                fragment += this.stack[i] === STACK_OBJECT ? '}' : ']';
+            }
+
+            if (this.lastFlushDepth === 0) {
+                // That's a root value
+                this.value = JSON.parse(fragment);
+                this.valueStack = {
+                    value: this.value,
+                    prev: null
+                };
+            } else {
+                this.parseAndAppend(this.prepareAddition(fragment), true);
+            }
+
+            // Move down to the depths to the last object/array, which is current now
+            for (let i = this.lastFlushDepth || 1; i < this.flushDepth; i++) {
+                let value = this.valueStack.value;
+
+                if (this.stack[i - 1] === STACK_OBJECT) {
+                    // find last entry
+                    let key;
+                    // eslint-disable-next-line curly
+                    for (key in value);
+                    value = value[key];
+                } else {
+                    // last element
+                    value = value[value.length - 1];
+                }
+
+                this.valueStack = {
+                    value,
+                    prev: this.valueStack
+                };
+            }
+        } else /* this.flushDepth < this.lastFlushDepth */ {
+            fragment = this.prepareAddition(fragment);
+
+            // Add missed opening brackets/parentheses
+            for (let i = this.lastFlushDepth - 1; i >= this.flushDepth; i--) {
+                this.jsonParseOffset--;
+                fragment = (this.stack[i] === STACK_OBJECT ? '{' : '[') + fragment;
+            }
+
+            this.parseAndAppend(fragment, false);
+
+            for (let i = this.lastFlushDepth - 1; i >= this.flushDepth; i--) {
+                this.valueStack = this.valueStack.prev;
+            }
+        }
+
+        this.lastFlushDepth = this.flushDepth;
+    }
+
+    push(chunk) {
+        if (typeof chunk !== 'string') {
+            // Suppose chunk is Buffer or Uint8Array
+
+            // Prepend uncompleted byte sequence if any
+            if (this.pendingByteSeq !== null) {
+                const origRawChunk = chunk;
+                chunk = new Uint8Array(this.pendingByteSeq.length + origRawChunk.length);
+                chunk.set(this.pendingByteSeq);
+                chunk.set(origRawChunk, this.pendingByteSeq.length);
+                this.pendingByteSeq = null;
+            }
+
+            // In case Buffer/Uint8Array, an input is encoded in UTF8
+            // Seek for parts of uncompleted UTF8 symbol on the ending
+            // This makes sense only if we expect more chunks and last char is not multi-bytes
+            if (chunk[chunk.length - 1] > 127) {
+                for (let seqLength = 0; seqLength < chunk.length; seqLength++) {
+                    const byte = chunk[chunk.length - 1 - seqLength];
+
+                    // 10xxxxxx - 2nd, 3rd or 4th byte
+                    // 110xxxxx – first byte of 2-byte sequence
+                    // 1110xxxx - first byte of 3-byte sequence
+                    // 11110xxx - first byte of 4-byte sequence
+                    if (byte >> 6 === 3) {
+                        seqLength++;
+
+                        // If the sequence is really incomplete, then preserve it
+                        // for the future chunk and cut off it from the current chunk
+                        if ((seqLength !== 4 && byte >> 3 === 0b11110) ||
+                            (seqLength !== 3 && byte >> 4 === 0b1110) ||
+                            (seqLength !== 2 && byte >> 5 === 0b110)) {
+                            this.pendingByteSeq = chunk.slice(chunk.length - seqLength);
+                            chunk = chunk.slice(0, -seqLength);
+                        }
+
+                        break;
+                    }
+                }
+            }
+
+            // Convert chunk to a string, since single decode per chunk
+            // is much effective than decode multiple small substrings
+            chunk = decoder.decode(chunk);
+        }
+
+        const chunkLength = chunk.length;
+        let lastFlushPoint = 0;
+        let flushPoint = 0;
+
+        // Main scan loop
+        scan: for (let i = 0; i < chunkLength; i++) {
+            if (this.stateString) {
+                for (; i < chunkLength; i++) {
+                    if (this.stateStringEscape) {
+                        this.stateStringEscape = false;
+                    } else {
+                        switch (chunk.charCodeAt(i)) {
+                            case 0x22: /* " */
+                                this.stateString = false;
+                                continue scan;
+
+                            case 0x5C: /* \ */
+                                this.stateStringEscape = true;
+                        }
+                    }
+                }
+
+                break;
+            }
+
+            switch (chunk.charCodeAt(i)) {
+                case 0x22: /* " */
+                    this.stateString = true;
+                    this.stateStringEscape = false;
+                    break;
+
+                case 0x2C: /* , */
+                    flushPoint = i;
+                    break;
+
+                case 0x7B: /* { */
+                    // Open an object
+                    flushPoint = i + 1;
+                    this.stack[this.flushDepth++] = STACK_OBJECT;
+                    break;
+
+                case 0x5B: /* [ */
+                    // Open an array
+                    flushPoint = i + 1;
+                    this.stack[this.flushDepth++] = STACK_ARRAY;
+                    break;
+
+                case 0x5D: /* ] */
+                case 0x7D: /* } */
+                    // Close an object or array
+                    flushPoint = i + 1;
+                    this.flushDepth--;
+
+                    if (this.flushDepth < this.lastFlushDepth) {
+                        this.flush(chunk, lastFlushPoint, flushPoint);
+                        lastFlushPoint = flushPoint;
+                    }
+
+                    break;
+
+                case 0x09: /* \t */
+                case 0x0A: /* \n */
+                case 0x0D: /* \r */
+                case 0x20: /* space */
+                    // Move points forward when they points on current position and it's a whitespace
+                    if (lastFlushPoint === i) {
+                        lastFlushPoint++;
+                    }
+
+                    if (flushPoint === i) {
+                        flushPoint++;
+                    }
+
+                    break;
+            }
+        }
+
+        if (flushPoint > lastFlushPoint) {
+            this.flush(chunk, lastFlushPoint, flushPoint);
+        }
+
+        // Produce pendingChunk if something left
+        if (flushPoint < chunkLength) {
+            if (this.pendingChunk !== null) {
+                // When there is already a pending chunk then no flush happened,
+                // appending entire chunk to pending one
+                this.pendingChunk += chunk;
+            } else {
+                // Create a pending chunk, it will start with non-whitespace since
+                // flushPoint was moved forward away from whitespaces on scan
+                this.pendingChunk = chunk.slice(flushPoint, chunkLength);
+            }
+        }
+
+        this.chunkOffset += chunkLength;
+    }
+
+    finish() {
+        if (this.pendingChunk !== null) {
+            this.flush('', 0, 0);
+            this.pendingChunk = null;
+        }
+
+        return this.value;
+    }
+}
+
+exports.parseChunked = parseChunked;
Index: imaps-frontend/node_modules/@discoveryjs/json-ext/cjs/stringify-chunked.cjs
===================================================================
--- imaps-frontend/node_modules/@discoveryjs/json-ext/cjs/stringify-chunked.cjs	(revision 79a03170cdde4e801d12257ee86723774970427b)
+++ imaps-frontend/node_modules/@discoveryjs/json-ext/cjs/stringify-chunked.cjs	(revision 79a03170cdde4e801d12257ee86723774970427b)
@@ -0,0 +1,175 @@
+'use strict';
+
+const utils = require('./utils.cjs');
+
+function encodeString(value) {
+    if (/[^\x20\x21\x23-\x5B\x5D-\uD799]/.test(value)) { // [^\x20-\uD799]|[\x22\x5c]
+        return JSON.stringify(value);
+    }
+
+    return '"' + value + '"';
+}
+
+function* stringifyChunked(value, ...args) {
+    const { replacer, getKeys, space, ...options } = utils.normalizeStringifyOptions(...args);
+    const highWaterMark = Number(options.highWaterMark) || 0x4000; // 16kb by default
+
+    const keyStrings = new Map();
+    const stack = [];
+    const rootValue = { '': value };
+    let prevState = null;
+    let state = () => printEntry('', value);
+    let stateValue = rootValue;
+    let stateEmpty = true;
+    let stateKeys = [''];
+    let stateIndex = 0;
+    let buffer = '';
+
+    while (true) {
+        state();
+
+        if (buffer.length >= highWaterMark || prevState === null) {
+            // flush buffer
+            yield buffer;
+            buffer = '';
+
+            if (prevState === null) {
+                break;
+            }
+        }
+    }
+
+    function printObject() {
+        if (stateIndex === 0) {
+            stateKeys = getKeys(stateValue);
+            buffer += '{';
+        }
+
+        // when no keys left
+        if (stateIndex === stateKeys.length) {
+            buffer += space && !stateEmpty
+                ? `\n${space.repeat(stack.length - 1)}}`
+                : '}';
+
+            popState();
+            return;
+        }
+
+        const key = stateKeys[stateIndex++];
+        printEntry(key, stateValue[key]);
+    }
+
+    function printArray() {
+        if (stateIndex === 0) {
+            buffer += '[';
+        }
+
+        if (stateIndex === stateValue.length) {
+            buffer += space && !stateEmpty
+                ? `\n${space.repeat(stack.length - 1)}]`
+                : ']';
+
+            popState();
+            return;
+        }
+
+        printEntry(stateIndex, stateValue[stateIndex++]);
+    }
+
+    function printEntryPrelude(key) {
+        if (stateEmpty) {
+            stateEmpty = false;
+        } else {
+            buffer += ',';
+        }
+
+        if (space && prevState !== null) {
+            buffer += `\n${space.repeat(stack.length)}`;
+        }
+
+        if (state === printObject) {
+            let keyString = keyStrings.get(key);
+
+            if (keyString === undefined) {
+                keyStrings.set(key, keyString = encodeString(key) + (space ? ': ' : ':'));
+            }
+
+            buffer += keyString;
+        }
+    }
+
+    function printEntry(key, value) {
+        value = utils.replaceValue(stateValue, key, value, replacer);
+
+        if (value === null || typeof value !== 'object') {
+            // primitive
+            if (state !== printObject || value !== undefined) {
+                printEntryPrelude(key);
+                pushPrimitive(value);
+            }
+        } else {
+            // If the visited set does not change after adding a value, then it is already in the set
+            if (stack.includes(value)) {
+                throw new TypeError('Converting circular structure to JSON');
+            }
+
+            printEntryPrelude(key);
+            stack.push(value);
+
+            pushState();
+            state = Array.isArray(value) ? printArray : printObject;
+            stateValue = value;
+            stateEmpty = true;
+            stateIndex = 0;
+        }
+    }
+
+    function pushPrimitive(value) {
+        switch (typeof value) {
+            case 'string':
+                buffer += encodeString(value);
+                break;
+
+            case 'number':
+                buffer += Number.isFinite(value) ? String(value) : 'null';
+                break;
+
+            case 'boolean':
+                buffer += value ? 'true' : 'false';
+                break;
+
+            case 'undefined':
+            case 'object': // typeof null === 'object'
+                buffer += 'null';
+                break;
+
+            default:
+                throw new TypeError(`Do not know how to serialize a ${value.constructor?.name || typeof value}`);
+        }
+    }
+
+    function pushState() {
+        prevState = {
+            keys: stateKeys,
+            index: stateIndex,
+            prev: prevState
+        };
+    }
+
+    function popState() {
+        stack.pop();
+        const value = stack.length > 0 ? stack[stack.length - 1] : rootValue;
+
+        // restore state
+        state = Array.isArray(value) ? printArray : printObject;
+        stateValue = value;
+        stateEmpty = false;
+        stateKeys = prevState.keys;
+        stateIndex = prevState.index;
+
+        // pop state
+        prevState = prevState.prev;
+    }
+}
+
+exports.stringifyChunked = stringifyChunked;
Index: imaps-frontend/node_modules/@discoveryjs/json-ext/cjs/stringify-info.cjs
===================================================================
--- imaps-frontend/node_modules/@discoveryjs/json-ext/cjs/stringify-info.cjs	(revision 79a03170cdde4e801d12257ee86723774970427b)
+++ imaps-frontend/node_modules/@discoveryjs/json-ext/cjs/stringify-info.cjs	(revision 79a03170cdde4e801d12257ee86723774970427b)
@@ -0,0 +1,250 @@
+'use strict';
+
+const utils = require('./utils.cjs');
+
+const hasOwn = typeof Object.hasOwn === 'function'
+    ? Object.hasOwn
+    : (object, key) => Object.hasOwnProperty.call(object, key);
+
+// https://tc39.es/ecma262/#table-json-single-character-escapes
+const escapableCharCodeSubstitution = { // JSON Single Character Escape Sequences
+    0x08: '\\b',
+    0x09: '\\t',
+    0x0a: '\\n',
+    0x0c: '\\f',
+    0x0d: '\\r',
+    0x22: '\\\"',
+    0x5c: '\\\\'
+};
+
+const charLength2048 = Uint8Array.from({ length: 2048 }, (_, code) => {
+    if (hasOwn(escapableCharCodeSubstitution, code)) {
+        return 2; // \X
+    }
+
+    if (code < 0x20) {
+        return 6; // \uXXXX
+    }
+
+    return code < 128 ? 1 : 2; // UTF8 bytes
+});
+
+function isLeadingSurrogate(code) {
+    return code >= 0xD800 && code <= 0xDBFF;
+}
+
+function isTrailingSurrogate(code) {
+    return code >= 0xDC00 && code <= 0xDFFF;
+}
+
+function stringLength(str) {
+    // Fast path to compute length when a string contains only characters encoded as single bytes
+    if (!/[^\x20\x21\x23-\x5B\x5D-\x7F]/.test(str)) {
+        return str.length + 2;
+    }
+
+    let len = 0;
+    let prevLeadingSurrogate = false;
+
+    for (let i = 0; i < str.length; i++) {
+        const code = str.charCodeAt(i);
+
+        if (code < 2048) {
+            len += charLength2048[code];
+        } else if (isLeadingSurrogate(code)) {
+            len += 6; // \uXXXX since no pair with trailing surrogate yet
+            prevLeadingSurrogate = true;
+            continue;
+        } else if (isTrailingSurrogate(code)) {
+            len = prevLeadingSurrogate
+                ? len - 2  // surrogate pair (4 bytes), since we calculate prev leading surrogate as 6 bytes, substruct 2 bytes
+                : len + 6; // \uXXXX
+        } else {
+            len += 3; // code >= 2048 is 3 bytes length for UTF8
+        }
+
+        prevLeadingSurrogate = false;
+    }
+
+    return len + 2; // +2 for quotes
+}
+
+// avoid producing a string from a number
+function intLength(num) {
+    let len = 0;
+
+    if (num < 0) {
+        len = 1;
+        num = -num;
+    }
+
+    if (num >= 1e9) {
+        len += 9;
+        num = (num - num % 1e9) / 1e9;
+    }
+
+    if (num >= 1e4) {
+        if (num >= 1e6) {
+            return len + (num >= 1e8
+                ? 9
+                : num >= 1e7 ? 8 : 7
+            );
+        }
+        return len + (num >= 1e5 ? 6 : 5);
+    }
+
+    return len + (num >= 1e2
+        ? num >= 1e3 ? 4 : 3
+        : num >= 10 ? 2 : 1
+    );
+}
+function primitiveLength(value) {
+    switch (typeof value) {
+        case 'string':
+            return stringLength(value);
+
+        case 'number':
+            return Number.isFinite(value)
+                ? Number.isInteger(value)
+                    ? intLength(value)
+                    : String(value).length
+                : 4 /* null */;
+
+        case 'boolean':
+            return value ? 4 /* true */ : 5 /* false */;
+
+        case 'undefined':
+        case 'object':
+            return 4; /* null */
+
+        default:
+            return 0;
+    }
+}
+
+function stringifyInfo(value, ...args) {
+    const { replacer, getKeys, ...options } = utils.normalizeStringifyOptions(...args);
+    const continueOnCircular = Boolean(options.continueOnCircular);
+    const space = options.space?.length || 0;
+
+    const keysLength = new Map();
+    const visited = new Map();
+    const circular = new Set();
+    const stack = [];
+    const root = { '': value };
+    let stop = false;
+    let bytes = 0;
+    let spaceBytes = 0;
+    let objects = 0;
+
+    walk(root, '', value);
+
+    // when value is undefined or replaced for undefined
+    if (bytes === 0) {
+        bytes += 9; // FIXME: that's the length of undefined, should we normalize behaviour to convert it to null?
+    }
+
+    return {
+        bytes: isNaN(bytes) ? Infinity : bytes + spaceBytes,
+        spaceBytes: space > 0 && isNaN(bytes) ? Infinity : spaceBytes,
+        circular: [...circular]
+    };
+
+    function walk(holder, key, value) {
+        if (stop) {
+            return;
+        }
+
+        value = utils.replaceValue(holder, key, value, replacer);
+
+        if (value === null || typeof value !== 'object') {
+            // primitive
+            if (value !== undefined || Array.isArray(holder)) {
+                bytes += primitiveLength(value);
+            }
+        } else {
+            // check for circular references
+            if (stack.includes(value)) {
+                circular.add(value);
+                bytes += 4; // treat as null
+
+                if (!continueOnCircular) {
+                    stop = true;
+                }
+
+                return;
+            }
+
+            // Using 'visited' allows avoiding hang-ups in cases of highly interconnected object graphs;
+            // for example, a list of git commits with references to parents can lead to N^2 complexity for traversal,
+            // and N when 'visited' is used
+            if (visited.has(value)) {
+                bytes += visited.get(value);
+
+                return;
+            }
+
+            objects++;
+
+            const prevObjects = objects;
+            const valueBytes = bytes;
+            let valueLength = 0;
+
+            stack.push(value);
+
+            if (Array.isArray(value)) {
+                // array
+                valueLength = value.length;
+
+                for (let i = 0; i < valueLength; i++) {
+                    walk(value, i, value[i]);
+                }
+            } else {
+                // object
+                let prevLength = bytes;
+
+                for (const key of getKeys(value)) {
+                    walk(value, key, value[key]);
+
+                    if (prevLength !== bytes) {
+                        let keyLen = keysLength.get(key);
+
+                        if (keyLen === undefined) {
+                            keysLength.set(key, keyLen = stringLength(key) + 1); // "key":
+                        }
+
+                        // value is printed
+                        bytes += keyLen;
+                        valueLength++;
+                        prevLength = bytes;
+                    }
+                }
+            }
+
+            bytes += valueLength === 0
+                ? 2 // {} or []
+                : 1 + valueLength; // {} or [] + commas
+
+            if (space > 0 && valueLength > 0) {
+                spaceBytes +=
+                    // a space between ":" and a value for each object entry
+                    (Array.isArray(value) ? 0 : valueLength) +
+                    // the formula results from folding the following components:
+                    // - for each key-value or element: ident + newline
+                    //   (1 + stack.length * space) * valueLength
+                    // - ident (one space less) before "}" or "]" + newline
+                    //   (stack.length - 1) * space + 1
+                    (1 + stack.length * space) * (valueLength + 1) - space;
+            }
+
+            stack.pop();
+
+            // add to 'visited' only objects that contain nested objects
+            if (prevObjects !== objects) {
+                visited.set(value, bytes - valueBytes);
+            }
+        }
+    }
+}
+
+exports.stringifyInfo = stringifyInfo;
Index: imaps-frontend/node_modules/@discoveryjs/json-ext/cjs/utils.cjs
===================================================================
--- imaps-frontend/node_modules/@discoveryjs/json-ext/cjs/utils.cjs	(revision 79a03170cdde4e801d12257ee86723774970427b)
+++ imaps-frontend/node_modules/@discoveryjs/json-ext/cjs/utils.cjs	(revision 79a03170cdde4e801d12257ee86723774970427b)
@@ -0,0 +1,108 @@
+'use strict';
+
+function isIterable(value) {
+    return (
+        typeof value === 'object' &&
+        value !== null &&
+        (
+            typeof value[Symbol.iterator] === 'function' ||
+            typeof value[Symbol.asyncIterator] === 'function'
+        )
+    );
+}
+
+function replaceValue(holder, key, value, replacer) {
+    if (value && typeof value.toJSON === 'function') {
+        value = value.toJSON();
+    }
+
+    if (replacer !== null) {
+        value = replacer.call(holder, String(key), value);
+    }
+
+    switch (typeof value) {
+        case 'function':
+        case 'symbol':
+            value = undefined;
+            break;
+
+        case 'object':
+            if (value !== null) {
+                const cls = value.constructor;
+                if (cls === String || cls === Number || cls === Boolean) {
+                    value = value.valueOf();
+                }
+            }
+            break;
+    }
+
+    return value;
+}
+
+function normalizeReplacer(replacer) {
+    if (typeof replacer === 'function') {
+        return replacer;
+    }
+
+    if (Array.isArray(replacer)) {
+        const allowlist = new Set(replacer
+            .map(item => {
+                const cls = item && item.constructor;
+                return cls === String || cls === Number ? String(item) : null;
+            })
+            .filter(item => typeof item === 'string')
+        );
+
+        return [...allowlist];
+    }
+
+    return null;
+}
+
+function normalizeSpace(space) {
+    if (typeof space === 'number') {
+        if (!Number.isFinite(space) || space < 1) {
+            return false;
+        }
+
+        return ' '.repeat(Math.min(space, 10));
+    }
+
+    if (typeof space === 'string') {
+        return space.slice(0, 10) || false;
+    }
+
+    return false;
+}
+
+function normalizeStringifyOptions(optionsOrReplacer, space) {
+    if (optionsOrReplacer === null || Array.isArray(optionsOrReplacer) || typeof optionsOrReplacer !== 'object') {
+        optionsOrReplacer = {
+            replacer: optionsOrReplacer,
+            space
+        };
+    }
+
+    let replacer = normalizeReplacer(optionsOrReplacer.replacer);
+    let getKeys = Object.keys;
+
+    if (Array.isArray(replacer)) {
+        const allowlist = replacer;
+
+        getKeys = () => allowlist;
+        replacer = null;
+    }
+
+    return {
+        ...optionsOrReplacer,
+        replacer,
+        getKeys,
+        space: normalizeSpace(optionsOrReplacer.space)
+    };
+}
+
+exports.isIterable = isIterable;
+exports.normalizeReplacer = normalizeReplacer;
+exports.normalizeSpace = normalizeSpace;
+exports.normalizeStringifyOptions = normalizeStringifyOptions;
+exports.replaceValue = replaceValue;
Index: imaps-frontend/node_modules/@discoveryjs/json-ext/cjs/web-streams.cjs
===================================================================
--- imaps-frontend/node_modules/@discoveryjs/json-ext/cjs/web-streams.cjs	(revision 79a03170cdde4e801d12257ee86723774970427b)
+++ imaps-frontend/node_modules/@discoveryjs/json-ext/cjs/web-streams.cjs	(revision 79a03170cdde4e801d12257ee86723774970427b)
@@ -0,0 +1,60 @@
+'use strict';
+
+const parseChunked = require('./parse-chunked.cjs');
+const stringifyChunked = require('./stringify-chunked.cjs');
+const utils = require('./utils.cjs');
+
+/* eslint-env browser */
+
+function parseFromWebStream(stream) {
+    // 2024/6/17: currently, an @@asyncIterator on a ReadableStream is not widely supported,
+    // therefore use a fallback using a reader
+    // https://caniuse.com/mdn-api_readablestream_--asynciterator
+    return parseChunked.parseChunked(utils.isIterable(stream) ? stream : async function*() {
+        const reader = stream.getReader();
+
+        try {
+            while (true) {
+                const { value, done } = await reader.read();
+
+                if (done) {
+                    break;
+                }
+
+                yield value;
+            }
+        } finally {
+            reader.releaseLock();
+        }
+    });
+}
+
+function createStringifyWebStream(value, replacer, space) {
+    // 2024/6/17: the ReadableStream.from() static method is supported
+    // in Node.js 20.6+ and Firefox only
+    if (typeof ReadableStream.from === 'function') {
+        return ReadableStream.from(stringifyChunked.stringifyChunked(value, replacer, space));
+    }
+
+    // emulate ReadableStream.from()
+    return new ReadableStream({
+        start() {
+            this.generator = stringifyChunked.stringifyChunked(value, replacer, space);
+        },
+        pull(controller) {
+            const { value, done } = this.generator.next();
+
+            if (done) {
+                controller.close();
+            } else {
+                controller.enqueue(value);
+            }
+        },
+        cancel() {
+            this.generator = null;
+        }
+    });
+}
+
+exports.createStringifyWebStream = createStringifyWebStream;
+exports.parseFromWebStream = parseFromWebStream;
Index: imaps-frontend/node_modules/@discoveryjs/json-ext/dist/json-ext.js
===================================================================
--- imaps-frontend/node_modules/@discoveryjs/json-ext/dist/json-ext.js	(revision 79a03170cdde4e801d12257ee86723774970427b)
+++ imaps-frontend/node_modules/@discoveryjs/json-ext/dist/json-ext.js	(revision 79a03170cdde4e801d12257ee86723774970427b)
@@ -0,0 +1,705 @@
+(function (global, factory) {
+  typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :
+  typeof define === 'function' && define.amd ? define(factory) :
+  (global.jsonExt = factory());
+}(typeof globalThis != 'undefined' ? globalThis : typeof window != 'undefined' ? window : typeof global != 'undefined' ? global : typeof self != 'undefined' ? self : this, (function () {
+var exports = (() => {
+  var __defProp = Object.defineProperty;
+  var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+  var __getOwnPropNames = Object.getOwnPropertyNames;
+  var __hasOwnProp = Object.prototype.hasOwnProperty;
+  var __export = (target, all) => {
+    for (var name in all)
+      __defProp(target, name, { get: all[name], enumerable: true });
+  };
+  var __copyProps = (to, from, except, desc) => {
+    if (from && typeof from === "object" || typeof from === "function") {
+      for (let key of __getOwnPropNames(from))
+        if (!__hasOwnProp.call(to, key) && key !== except)
+          __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+    }
+    return to;
+  };
+  var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+  // src/index.js
+  var src_exports = {};
+  __export(src_exports, {
+    createStringifyWebStream: () => createStringifyWebStream,
+    parseChunked: () => parseChunked,
+    parseFromWebStream: () => parseFromWebStream,
+    stringifyChunked: () => stringifyChunked,
+    stringifyInfo: () => stringifyInfo
+  });
+
+  // src/utils.js
+  function isIterable(value) {
+    return typeof value === "object" && value !== null && (typeof value[Symbol.iterator] === "function" || typeof value[Symbol.asyncIterator] === "function");
+  }
+  function replaceValue(holder, key, value, replacer) {
+    if (value && typeof value.toJSON === "function") {
+      value = value.toJSON();
+    }
+    if (replacer !== null) {
+      value = replacer.call(holder, String(key), value);
+    }
+    switch (typeof value) {
+      case "function":
+      case "symbol":
+        value = void 0;
+        break;
+      case "object":
+        if (value !== null) {
+          const cls = value.constructor;
+          if (cls === String || cls === Number || cls === Boolean) {
+            value = value.valueOf();
+          }
+        }
+        break;
+    }
+    return value;
+  }
+  function normalizeReplacer(replacer) {
+    if (typeof replacer === "function") {
+      return replacer;
+    }
+    if (Array.isArray(replacer)) {
+      const allowlist = new Set(
+        replacer.map((item) => {
+          const cls = item && item.constructor;
+          return cls === String || cls === Number ? String(item) : null;
+        }).filter((item) => typeof item === "string")
+      );
+      return [...allowlist];
+    }
+    return null;
+  }
+  function normalizeSpace(space) {
+    if (typeof space === "number") {
+      if (!Number.isFinite(space) || space < 1) {
+        return false;
+      }
+      return " ".repeat(Math.min(space, 10));
+    }
+    if (typeof space === "string") {
+      return space.slice(0, 10) || false;
+    }
+    return false;
+  }
+  function normalizeStringifyOptions(optionsOrReplacer, space) {
+    if (optionsOrReplacer === null || Array.isArray(optionsOrReplacer) || typeof optionsOrReplacer !== "object") {
+      optionsOrReplacer = {
+        replacer: optionsOrReplacer,
+        space
+      };
+    }
+    let replacer = normalizeReplacer(optionsOrReplacer.replacer);
+    let getKeys = Object.keys;
+    if (Array.isArray(replacer)) {
+      const allowlist = replacer;
+      getKeys = () => allowlist;
+      replacer = null;
+    }
+    return {
+      ...optionsOrReplacer,
+      replacer,
+      getKeys,
+      space: normalizeSpace(optionsOrReplacer.space)
+    };
+  }
+
+  // src/parse-chunked.js
+  var STACK_OBJECT = 1;
+  var STACK_ARRAY = 2;
+  var decoder = new TextDecoder();
+  function adjustPosition(error, parser) {
+    if (error.name === "SyntaxError" && parser.jsonParseOffset) {
+      error.message = error.message.replace(
+        /at position (\d+)/,
+        (_, pos) => "at position " + (Number(pos) + parser.jsonParseOffset)
+      );
+    }
+    return error;
+  }
+  function append(array, elements) {
+    const initialLength = array.length;
+    array.length += elements.length;
+    for (let i = 0; i < elements.length; i++) {
+      array[initialLength + i] = elements[i];
+    }
+  }
+  async function parseChunked(chunkEmitter) {
+    const iterable = typeof chunkEmitter === "function" ? chunkEmitter() : chunkEmitter;
+    if (isIterable(iterable)) {
+      let parser = new ChunkParser();
+      try {
+        for await (const chunk of iterable) {
+          if (typeof chunk !== "string" && !ArrayBuffer.isView(chunk)) {
+            throw new TypeError("Invalid chunk: Expected string, TypedArray or Buffer");
+          }
+          parser.push(chunk);
+        }
+        return parser.finish();
+      } catch (e) {
+        throw adjustPosition(e, parser);
+      }
+    }
+    throw new TypeError(
+      "Invalid chunk emitter: Expected an Iterable, AsyncIterable, generator, async generator, or a function returning an Iterable or AsyncIterable"
+    );
+  }
+  var ChunkParser = class {
+    constructor() {
+      this.value = void 0;
+      this.valueStack = null;
+      this.stack = new Array(100);
+      this.lastFlushDepth = 0;
+      this.flushDepth = 0;
+      this.stateString = false;
+      this.stateStringEscape = false;
+      this.pendingByteSeq = null;
+      this.pendingChunk = null;
+      this.chunkOffset = 0;
+      this.jsonParseOffset = 0;
+    }
+    parseAndAppend(fragment, wrap) {
+      if (this.stack[this.lastFlushDepth - 1] === STACK_OBJECT) {
+        if (wrap) {
+          this.jsonParseOffset--;
+          fragment = "{" + fragment + "}";
+        }
+        Object.assign(this.valueStack.value, JSON.parse(fragment));
+      } else {
+        if (wrap) {
+          this.jsonParseOffset--;
+          fragment = "[" + fragment + "]";
+        }
+        append(this.valueStack.value, JSON.parse(fragment));
+      }
+    }
+    prepareAddition(fragment) {
+      const { value } = this.valueStack;
+      const expectComma = Array.isArray(value) ? value.length !== 0 : Object.keys(value).length !== 0;
+      if (expectComma) {
+        if (fragment[0] === ",") {
+          this.jsonParseOffset++;
+          return fragment.slice(1);
+        }
+        if (fragment[0] !== "}" && fragment[0] !== "]") {
+          this.jsonParseOffset -= 3;
+          return "[[]" + fragment;
+        }
+      }
+      return fragment;
+    }
+    flush(chunk, start, end) {
+      let fragment = chunk.slice(start, end);
+      this.jsonParseOffset = this.chunkOffset + start;
+      if (this.pendingChunk !== null) {
+        fragment = this.pendingChunk + fragment;
+        this.jsonParseOffset -= this.pendingChunk.length;
+        this.pendingChunk = null;
+      }
+      if (this.flushDepth === this.lastFlushDepth) {
+        if (this.flushDepth > 0) {
+          this.parseAndAppend(this.prepareAddition(fragment), true);
+        } else {
+          this.value = JSON.parse(fragment);
+          this.valueStack = {
+            value: this.value,
+            prev: null
+          };
+        }
+      } else if (this.flushDepth > this.lastFlushDepth) {
+        for (let i = this.flushDepth - 1; i >= this.lastFlushDepth; i--) {
+          fragment += this.stack[i] === STACK_OBJECT ? "}" : "]";
+        }
+        if (this.lastFlushDepth === 0) {
+          this.value = JSON.parse(fragment);
+          this.valueStack = {
+            value: this.value,
+            prev: null
+          };
+        } else {
+          this.parseAndAppend(this.prepareAddition(fragment), true);
+        }
+        for (let i = this.lastFlushDepth || 1; i < this.flushDepth; i++) {
+          let value = this.valueStack.value;
+          if (this.stack[i - 1] === STACK_OBJECT) {
+            let key;
+            for (key in value) ;
+            value = value[key];
+          } else {
+            value = value[value.length - 1];
+          }
+          this.valueStack = {
+            value,
+            prev: this.valueStack
+          };
+        }
+      } else {
+        fragment = this.prepareAddition(fragment);
+        for (let i = this.lastFlushDepth - 1; i >= this.flushDepth; i--) {
+          this.jsonParseOffset--;
+          fragment = (this.stack[i] === STACK_OBJECT ? "{" : "[") + fragment;
+        }
+        this.parseAndAppend(fragment, false);
+        for (let i = this.lastFlushDepth - 1; i >= this.flushDepth; i--) {
+          this.valueStack = this.valueStack.prev;
+        }
+      }
+      this.lastFlushDepth = this.flushDepth;
+    }
+    push(chunk) {
+      if (typeof chunk !== "string") {
+        if (this.pendingByteSeq !== null) {
+          const origRawChunk = chunk;
+          chunk = new Uint8Array(this.pendingByteSeq.length + origRawChunk.length);
+          chunk.set(this.pendingByteSeq);
+          chunk.set(origRawChunk, this.pendingByteSeq.length);
+          this.pendingByteSeq = null;
+        }
+        if (chunk[chunk.length - 1] > 127) {
+          for (let seqLength = 0; seqLength < chunk.length; seqLength++) {
+            const byte = chunk[chunk.length - 1 - seqLength];
+            if (byte >> 6 === 3) {
+              seqLength++;
+              if (seqLength !== 4 && byte >> 3 === 30 || seqLength !== 3 && byte >> 4 === 14 || seqLength !== 2 && byte >> 5 === 6) {
+                this.pendingByteSeq = chunk.slice(chunk.length - seqLength);
+                chunk = chunk.slice(0, -seqLength);
+              }
+              break;
+            }
+          }
+        }
+        chunk = decoder.decode(chunk);
+      }
+      const chunkLength = chunk.length;
+      let lastFlushPoint = 0;
+      let flushPoint = 0;
+      scan: for (let i = 0; i < chunkLength; i++) {
+        if (this.stateString) {
+          for (; i < chunkLength; i++) {
+            if (this.stateStringEscape) {
+              this.stateStringEscape = false;
+            } else {
+              switch (chunk.charCodeAt(i)) {
+                case 34:
+                  this.stateString = false;
+                  continue scan;
+                case 92:
+                  this.stateStringEscape = true;
+              }
+            }
+          }
+          break;
+        }
+        switch (chunk.charCodeAt(i)) {
+          case 34:
+            this.stateString = true;
+            this.stateStringEscape = false;
+            break;
+          case 44:
+            flushPoint = i;
+            break;
+          case 123:
+            flushPoint = i + 1;
+            this.stack[this.flushDepth++] = STACK_OBJECT;
+            break;
+          case 91:
+            flushPoint = i + 1;
+            this.stack[this.flushDepth++] = STACK_ARRAY;
+            break;
+          case 93:
+          /* ] */
+          case 125:
+            flushPoint = i + 1;
+            this.flushDepth--;
+            if (this.flushDepth < this.lastFlushDepth) {
+              this.flush(chunk, lastFlushPoint, flushPoint);
+              lastFlushPoint = flushPoint;
+            }
+            break;
+          case 9:
+          /* \t */
+          case 10:
+          /* \n */
+          case 13:
+          /* \r */
+          case 32:
+            if (lastFlushPoint === i) {
+              lastFlushPoint++;
+            }
+            if (flushPoint === i) {
+              flushPoint++;
+            }
+            break;
+        }
+      }
+      if (flushPoint > lastFlushPoint) {
+        this.flush(chunk, lastFlushPoint, flushPoint);
+      }
+      if (flushPoint < chunkLength) {
+        if (this.pendingChunk !== null) {
+          this.pendingChunk += chunk;
+        } else {
+          this.pendingChunk = chunk.slice(flushPoint, chunkLength);
+        }
+      }
+      this.chunkOffset += chunkLength;
+    }
+    finish() {
+      if (this.pendingChunk !== null) {
+        this.flush("", 0, 0);
+        this.pendingChunk = null;
+      }
+      return this.value;
+    }
+  };
+
+  // src/stringify-chunked.js
+  function encodeString(value) {
+    if (/[^\x20\x21\x23-\x5B\x5D-\uD799]/.test(value)) {
+      return JSON.stringify(value);
+    }
+    return '"' + value + '"';
+  }
+  function* stringifyChunked(value, ...args) {
+    const { replacer, getKeys, space, ...options } = normalizeStringifyOptions(...args);
+    const highWaterMark = Number(options.highWaterMark) || 16384;
+    const keyStrings = /* @__PURE__ */ new Map();
+    const stack = [];
+    const rootValue = { "": value };
+    let prevState = null;
+    let state = () => printEntry("", value);
+    let stateValue = rootValue;
+    let stateEmpty = true;
+    let stateKeys = [""];
+    let stateIndex = 0;
+    let buffer = "";
+    while (true) {
+      state();
+      if (buffer.length >= highWaterMark || prevState === null) {
+        yield buffer;
+        buffer = "";
+        if (prevState === null) {
+          break;
+        }
+      }
+    }
+    function printObject() {
+      if (stateIndex === 0) {
+        stateKeys = getKeys(stateValue);
+        buffer += "{";
+      }
+      if (stateIndex === stateKeys.length) {
+        buffer += space && !stateEmpty ? `
+${space.repeat(stack.length - 1)}}` : "}";
+        popState();
+        return;
+      }
+      const key = stateKeys[stateIndex++];
+      printEntry(key, stateValue[key]);
+    }
+    function printArray() {
+      if (stateIndex === 0) {
+        buffer += "[";
+      }
+      if (stateIndex === stateValue.length) {
+        buffer += space && !stateEmpty ? `
+${space.repeat(stack.length - 1)}]` : "]";
+        popState();
+        return;
+      }
+      printEntry(stateIndex, stateValue[stateIndex++]);
+    }
+    function printEntryPrelude(key) {
+      if (stateEmpty) {
+        stateEmpty = false;
+      } else {
+        buffer += ",";
+      }
+      if (space && prevState !== null) {
+        buffer += `
+${space.repeat(stack.length)}`;
+      }
+      if (state === printObject) {
+        let keyString = keyStrings.get(key);
+        if (keyString === void 0) {
+          keyStrings.set(key, keyString = encodeString(key) + (space ? ": " : ":"));
+        }
+        buffer += keyString;
+      }
+    }
+    function printEntry(key, value2) {
+      value2 = replaceValue(stateValue, key, value2, replacer);
+      if (value2 === null || typeof value2 !== "object") {
+        if (state !== printObject || value2 !== void 0) {
+          printEntryPrelude(key);
+          pushPrimitive(value2);
+        }
+      } else {
+        if (stack.includes(value2)) {
+          throw new TypeError("Converting circular structure to JSON");
+        }
+        printEntryPrelude(key);
+        stack.push(value2);
+        pushState();
+        state = Array.isArray(value2) ? printArray : printObject;
+        stateValue = value2;
+        stateEmpty = true;
+        stateIndex = 0;
+      }
+    }
+    function pushPrimitive(value2) {
+      switch (typeof value2) {
+        case "string":
+          buffer += encodeString(value2);
+          break;
+        case "number":
+          buffer += Number.isFinite(value2) ? String(value2) : "null";
+          break;
+        case "boolean":
+          buffer += value2 ? "true" : "false";
+          break;
+        case "undefined":
+        case "object":
+          buffer += "null";
+          break;
+        default:
+          throw new TypeError(`Do not know how to serialize a ${value2.constructor?.name || typeof value2}`);
+      }
+    }
+    function pushState() {
+      prevState = {
+        keys: stateKeys,
+        index: stateIndex,
+        prev: prevState
+      };
+    }
+    function popState() {
+      stack.pop();
+      const value2 = stack.length > 0 ? stack[stack.length - 1] : rootValue;
+      state = Array.isArray(value2) ? printArray : printObject;
+      stateValue = value2;
+      stateEmpty = false;
+      stateKeys = prevState.keys;
+      stateIndex = prevState.index;
+      prevState = prevState.prev;
+    }
+  }
+
+  // src/stringify-info.js
+  var hasOwn = typeof Object.hasOwn === "function" ? Object.hasOwn : (object, key) => Object.hasOwnProperty.call(object, key);
+  var escapableCharCodeSubstitution = {
+    // JSON Single Character Escape Sequences
+    8: "\\b",
+    9: "\\t",
+    10: "\\n",
+    12: "\\f",
+    13: "\\r",
+    34: '\\"',
+    92: "\\\\"
+  };
+  var charLength2048 = Uint8Array.from({ length: 2048 }, (_, code) => {
+    if (hasOwn(escapableCharCodeSubstitution, code)) {
+      return 2;
+    }
+    if (code < 32) {
+      return 6;
+    }
+    return code < 128 ? 1 : 2;
+  });
+  function isLeadingSurrogate(code) {
+    return code >= 55296 && code <= 56319;
+  }
+  function isTrailingSurrogate(code) {
+    return code >= 56320 && code <= 57343;
+  }
+  function stringLength(str) {
+    if (!/[^\x20\x21\x23-\x5B\x5D-\x7F]/.test(str)) {
+      return str.length + 2;
+    }
+    let len = 0;
+    let prevLeadingSurrogate = false;
+    for (let i = 0; i < str.length; i++) {
+      const code = str.charCodeAt(i);
+      if (code < 2048) {
+        len += charLength2048[code];
+      } else if (isLeadingSurrogate(code)) {
+        len += 6;
+        prevLeadingSurrogate = true;
+        continue;
+      } else if (isTrailingSurrogate(code)) {
+        len = prevLeadingSurrogate ? len - 2 : len + 6;
+      } else {
+        len += 3;
+      }
+      prevLeadingSurrogate = false;
+    }
+    return len + 2;
+  }
+  function intLength(num) {
+    let len = 0;
+    if (num < 0) {
+      len = 1;
+      num = -num;
+    }
+    if (num >= 1e9) {
+      len += 9;
+      num = (num - num % 1e9) / 1e9;
+    }
+    if (num >= 1e4) {
+      if (num >= 1e6) {
+        return len + (num >= 1e8 ? 9 : num >= 1e7 ? 8 : 7);
+      }
+      return len + (num >= 1e5 ? 6 : 5);
+    }
+    return len + (num >= 100 ? num >= 1e3 ? 4 : 3 : num >= 10 ? 2 : 1);
+  }
+  function primitiveLength(value) {
+    switch (typeof value) {
+      case "string":
+        return stringLength(value);
+      case "number":
+        return Number.isFinite(value) ? Number.isInteger(value) ? intLength(value) : String(value).length : 4;
+      case "boolean":
+        return value ? 4 : 5;
+      case "undefined":
+      case "object":
+        return 4;
+      /* null */
+      default:
+        return 0;
+    }
+  }
+  function stringifyInfo(value, ...args) {
+    const { replacer, getKeys, ...options } = normalizeStringifyOptions(...args);
+    const continueOnCircular = Boolean(options.continueOnCircular);
+    const space = options.space?.length || 0;
+    const keysLength = /* @__PURE__ */ new Map();
+    const visited = /* @__PURE__ */ new Map();
+    const circular = /* @__PURE__ */ new Set();
+    const stack = [];
+    const root = { "": value };
+    let stop = false;
+    let bytes = 0;
+    let spaceBytes = 0;
+    let objects = 0;
+    walk(root, "", value);
+    if (bytes === 0) {
+      bytes += 9;
+    }
+    return {
+      bytes: isNaN(bytes) ? Infinity : bytes + spaceBytes,
+      spaceBytes: space > 0 && isNaN(bytes) ? Infinity : spaceBytes,
+      circular: [...circular]
+    };
+    function walk(holder, key, value2) {
+      if (stop) {
+        return;
+      }
+      value2 = replaceValue(holder, key, value2, replacer);
+      if (value2 === null || typeof value2 !== "object") {
+        if (value2 !== void 0 || Array.isArray(holder)) {
+          bytes += primitiveLength(value2);
+        }
+      } else {
+        if (stack.includes(value2)) {
+          circular.add(value2);
+          bytes += 4;
+          if (!continueOnCircular) {
+            stop = true;
+          }
+          return;
+        }
+        if (visited.has(value2)) {
+          bytes += visited.get(value2);
+          return;
+        }
+        objects++;
+        const prevObjects = objects;
+        const valueBytes = bytes;
+        let valueLength = 0;
+        stack.push(value2);
+        if (Array.isArray(value2)) {
+          valueLength = value2.length;
+          for (let i = 0; i < valueLength; i++) {
+            walk(value2, i, value2[i]);
+          }
+        } else {
+          let prevLength = bytes;
+          for (const key2 of getKeys(value2)) {
+            walk(value2, key2, value2[key2]);
+            if (prevLength !== bytes) {
+              let keyLen = keysLength.get(key2);
+              if (keyLen === void 0) {
+                keysLength.set(key2, keyLen = stringLength(key2) + 1);
+              }
+              bytes += keyLen;
+              valueLength++;
+              prevLength = bytes;
+            }
+          }
+        }
+        bytes += valueLength === 0 ? 2 : 1 + valueLength;
+        if (space > 0 && valueLength > 0) {
+          spaceBytes += // a space between ":" and a value for each object entry
+          (Array.isArray(value2) ? 0 : valueLength) + // the formula results from folding the following components:
+          // - for each key-value or element: ident + newline
+          //   (1 + stack.length * space) * valueLength
+          // - ident (one space less) before "}" or "]" + newline
+          //   (stack.length - 1) * space + 1
+          (1 + stack.length * space) * (valueLength + 1) - space;
+        }
+        stack.pop();
+        if (prevObjects !== objects) {
+          visited.set(value2, bytes - valueBytes);
+        }
+      }
+    }
+  }
+
+  // src/web-streams.js
+  function parseFromWebStream(stream) {
+    return parseChunked(isIterable(stream) ? stream : async function* () {
+      const reader = stream.getReader();
+      try {
+        while (true) {
+          const { value, done } = await reader.read();
+          if (done) {
+            break;
+          }
+          yield value;
+        }
+      } finally {
+        reader.releaseLock();
+      }
+    });
+  }
+  function createStringifyWebStream(value, replacer, space) {
+    if (typeof ReadableStream.from === "function") {
+      return ReadableStream.from(stringifyChunked(value, replacer, space));
+    }
+    return new ReadableStream({
+      start() {
+        this.generator = stringifyChunked(value, replacer, space);
+      },
+      pull(controller) {
+        const { value: value2, done } = this.generator.next();
+        if (done) {
+          controller.close();
+        } else {
+          controller.enqueue(value2);
+        }
+      },
+      cancel() {
+        this.generator = null;
+      }
+    });
+  }
+  return __toCommonJS(src_exports);
+})();
+
+  return exports;
+})));
Index: imaps-frontend/node_modules/@discoveryjs/json-ext/dist/json-ext.min.js
===================================================================
--- imaps-frontend/node_modules/@discoveryjs/json-ext/dist/json-ext.min.js	(revision 79a03170cdde4e801d12257ee86723774970427b)
+++ imaps-frontend/node_modules/@discoveryjs/json-ext/dist/json-ext.min.js	(revision 79a03170cdde4e801d12257ee86723774970427b)
@@ -0,0 +1,13 @@
+(function (global, factory) {
+  typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :
+  typeof define === 'function' && define.amd ? define(factory) :
+  (global.jsonExt = factory());
+}(typeof globalThis != 'undefined' ? globalThis : typeof window != 'undefined' ? window : typeof global != 'undefined' ? global : typeof self != 'undefined' ? self : this, (function () {
+var exports=(()=>{var P=Object.defineProperty;var K=Object.getOwnPropertyDescriptor;var M=Object.getOwnPropertyNames;var V=Object.prototype.hasOwnProperty;var W=(t,e)=>{for(var n in e)P(t,n,{get:e[n],enumerable:!0})},_=(t,e,n,s)=>{if(e&&typeof e=="object"||typeof e=="function")for(let i of M(e))!V.call(t,i)&&i!==n&&P(t,i,{get:()=>e[i],enumerable:!(s=K(e,i))||s.enumerable});return t};var $=t=>_(P({},"__esModule",{value:!0}),t);var st={};W(st,{createStringifyWebStream:()=>z,parseChunked:()=>N,parseFromWebStream:()=>J,stringifyChunked:()=>C,stringifyInfo:()=>q});function j(t){return typeof t=="object"&&t!==null&&(typeof t[Symbol.iterator]=="function"||typeof t[Symbol.asyncIterator]=="function")}function F(t,e,n,s){switch(n&&typeof n.toJSON=="function"&&(n=n.toJSON()),s!==null&&(n=s.call(t,String(e),n)),typeof n){case"function":case"symbol":n=void 0;break;case"object":if(n!==null){let i=n.constructor;(i===String||i===Number||i===Boolean)&&(n=n.valueOf())}break}return n}function U(t){return typeof t=="function"?t:Array.isArray(t)?[...new Set(t.map(n=>{let s=n&&n.constructor;return s===String||s===Number?String(n):null}).filter(n=>typeof n=="string"))]:null}function R(t){return typeof t=="number"?!Number.isFinite(t)||t<1?!1:" ".repeat(Math.min(t,10)):typeof t=="string"&&t.slice(0,10)||!1}function B(t,e){(t===null||Array.isArray(t)||typeof t!="object")&&(t={replacer:t,space:e});let n=U(t.replacer),s=Object.keys;if(Array.isArray(n)){let i=n;s=()=>i,n=null}return{...t,replacer:n,getKeys:s,space:R(t.space)}}var O=1,Y=2,G=new TextDecoder;function H(t,e){return t.name==="SyntaxError"&&e.jsonParseOffset&&(t.message=t.message.replace(/at position (\d+)/,(n,s)=>"at position "+(Number(s)+e.jsonParseOffset))),t}function Q(t,e){let n=t.length;t.length+=e.length;for(let s=0;s<e.length;s++)t[n+s]=e[s]}async function N(t){let e=typeof t=="function"?t():t;if(j(e)){let n=new E;try{for await(let s of e){if(typeof s!="string"&&!ArrayBuffer.isView(s))throw new TypeError("Invalid chunk: Expected string, TypedArray or Buffer");n.push(s)}return n.finish()}catch(s){throw H(s,n)}}throw new TypeError("Invalid chunk emitter: Expected an Iterable, AsyncIterable, generator, async generator, or a function returning an Iterable or AsyncIterable")}var E=class{constructor(){this.value=void 0,this.valueStack=null,this.stack=new Array(100),this.lastFlushDepth=0,this.flushDepth=0,this.stateString=!1,this.stateStringEscape=!1,this.pendingByteSeq=null,this.pendingChunk=null,this.chunkOffset=0,this.jsonParseOffset=0}parseAndAppend(e,n){this.stack[this.lastFlushDepth-1]===O?(n&&(this.jsonParseOffset--,e="{"+e+"}"),Object.assign(this.valueStack.value,JSON.parse(e))):(n&&(this.jsonParseOffset--,e="["+e+"]"),Q(this.valueStack.value,JSON.parse(e)))}prepareAddition(e){let{value:n}=this.valueStack;if(Array.isArray(n)?n.length!==0:Object.keys(n).length!==0){if(e[0]===",")return this.jsonParseOffset++,e.slice(1);if(e[0]!=="}"&&e[0]!=="]")return this.jsonParseOffset-=3,"[[]"+e}return e}flush(e,n,s){let i=e.slice(n,s);if(this.jsonParseOffset=this.chunkOffset+n,this.pendingChunk!==null&&(i=this.pendingChunk+i,this.jsonParseOffset-=this.pendingChunk.length,this.pendingChunk=null),this.flushDepth===this.lastFlushDepth)this.flushDepth>0?this.parseAndAppend(this.prepareAddition(i),!0):(this.value=JSON.parse(i),this.valueStack={value:this.value,prev:null});else if(this.flushDepth>this.lastFlushDepth){for(let r=this.flushDepth-1;r>=this.lastFlushDepth;r--)i+=this.stack[r]===O?"}":"]";this.lastFlushDepth===0?(this.value=JSON.parse(i),this.valueStack={value:this.value,prev:null}):this.parseAndAppend(this.prepareAddition(i),!0);for(let r=this.lastFlushDepth||1;r<this.flushDepth;r++){let l=this.valueStack.value;if(this.stack[r-1]===O){let x;for(x in l);l=l[x]}else l=l[l.length-1];this.valueStack={value:l,prev:this.valueStack}}}else{i=this.prepareAddition(i);for(let r=this.lastFlushDepth-1;r>=this.flushDepth;r--)this.jsonParseOffset--,i=(this.stack[r]===O?"{":"[")+i;this.parseAndAppend(i,!1);for(let r=this.lastFlushDepth-1;r>=this.flushDepth;r--)this.valueStack=this.valueStack.prev}this.lastFlushDepth=this.flushDepth}push(e){if(typeof e!="string"){if(this.pendingByteSeq!==null){let r=e;e=new Uint8Array(this.pendingByteSeq.length+r.length),e.set(this.pendingByteSeq),e.set(r,this.pendingByteSeq.length),this.pendingByteSeq=null}if(e[e.length-1]>127)for(let r=0;r<e.length;r++){let l=e[e.length-1-r];if(l>>6===3){r++,(r!==4&&l>>3===30||r!==3&&l>>4===14||r!==2&&l>>5===6)&&(this.pendingByteSeq=e.slice(e.length-r),e=e.slice(0,-r));break}}e=G.decode(e)}let n=e.length,s=0,i=0;t:for(let r=0;r<n;r++){if(this.stateString){for(;r<n;r++)if(this.stateStringEscape)this.stateStringEscape=!1;else switch(e.charCodeAt(r)){case 34:this.stateString=!1;continue t;case 92:this.stateStringEscape=!0}break}switch(e.charCodeAt(r)){case 34:this.stateString=!0,this.stateStringEscape=!1;break;case 44:i=r;break;case 123:i=r+1,this.stack[this.flushDepth++]=O;break;case 91:i=r+1,this.stack[this.flushDepth++]=Y;break;case 93:case 125:i=r+1,this.flushDepth--,this.flushDepth<this.lastFlushDepth&&(this.flush(e,s,i),s=i);break;case 9:case 10:case 13:case 32:s===r&&s++,i===r&&i++;break}}i>s&&this.flush(e,s,i),i<n&&(this.pendingChunk!==null?this.pendingChunk+=e:this.pendingChunk=e.slice(i,n)),this.chunkOffset+=n}finish(){return this.pendingChunk!==null&&(this.flush("",0,0),this.pendingChunk=null),this.value}};function L(t){return/[^\x20\x21\x23-\x5B\x5D-\uD799]/.test(t)?JSON.stringify(t):'"'+t+'"'}function*C(t,...e){let{replacer:n,getKeys:s,space:i,...r}=B(...e),l=Number(r.highWaterMark)||16384,x=new Map,g=[],w={"":t},u=null,k=()=>D("",t),y=w,a=!0,S=[""],p=0,h="";for(;k(),!((h.length>=l||u===null)&&(yield h,h="",u===null)););function A(){if(p===0&&(S=s(y),h+="{"),p===S.length){h+=i&&!a?`
+${i.repeat(g.length-1)}}`:"}",b();return}let f=S[p++];D(f,y[f])}function m(){if(p===0&&(h+="["),p===y.length){h+=i&&!a?`
+${i.repeat(g.length-1)}]`:"]",b();return}D(p,y[p++])}function o(f){if(a?a=!1:h+=",",i&&u!==null&&(h+=`
+${i.repeat(g.length)}`),k===A){let c=x.get(f);c===void 0&&x.set(f,c=L(f)+(i?": ":":")),h+=c}}function D(f,c){if(c=F(y,f,c,n),c===null||typeof c!="object")(k!==A||c!==void 0)&&(o(f),I(c));else{if(g.includes(c))throw new TypeError("Converting circular structure to JSON");o(f),g.push(c),d(),k=Array.isArray(c)?m:A,y=c,a=!0,p=0}}function I(f){switch(typeof f){case"string":h+=L(f);break;case"number":h+=Number.isFinite(f)?String(f):"null";break;case"boolean":h+=f?"true":"false";break;case"undefined":case"object":h+="null";break;default:throw new TypeError(`Do not know how to serialize a ${f.constructor?.name||typeof f}`)}}function d(){u={keys:S,index:p,prev:u}}function b(){g.pop();let f=g.length>0?g[g.length-1]:w;k=Array.isArray(f)?m:A,y=f,a=!1,S=u.keys,p=u.index,u=u.prev}}var X=typeof Object.hasOwn=="function"?Object.hasOwn:(t,e)=>Object.hasOwnProperty.call(t,e),Z={8:"\\b",9:"\\t",10:"\\n",12:"\\f",13:"\\r",34:'\\"',92:"\\\\"},v=Uint8Array.from({length:2048},(t,e)=>X(Z,e)?2:e<32?6:e<128?1:2);function tt(t){return t>=55296&&t<=56319}function et(t){return t>=56320&&t<=57343}function T(t){if(!/[^\x20\x21\x23-\x5B\x5D-\x7F]/.test(t))return t.length+2;let e=0,n=!1;for(let s=0;s<t.length;s++){let i=t.charCodeAt(s);if(i<2048)e+=v[i];else if(tt(i)){e+=6,n=!0;continue}else et(i)?e=n?e-2:e+6:e+=3;n=!1}return e+2}function nt(t){let e=0;return t<0&&(e=1,t=-t),t>=1e9&&(e+=9,t=(t-t%1e9)/1e9),t>=1e4?t>=1e6?e+(t>=1e8?9:t>=1e7?8:7):e+(t>=1e5?6:5):e+(t>=100?t>=1e3?4:3:t>=10?2:1)}function it(t){switch(typeof t){case"string":return T(t);case"number":return Number.isFinite(t)?Number.isInteger(t)?nt(t):String(t).length:4;case"boolean":return t?4:5;case"undefined":case"object":return 4;default:return 0}}function q(t,...e){let{replacer:n,getKeys:s,...i}=B(...e),r=!!i.continueOnCircular,l=i.space?.length||0,x=new Map,g=new Map,w=new Set,u=[],k={"":t},y=!1,a=0,S=0,p=0;return h(k,"",t),a===0&&(a+=9),{bytes:isNaN(a)?1/0:a+S,spaceBytes:l>0&&isNaN(a)?1/0:S,circular:[...w]};function h(A,m,o){if(!y)if(o=F(A,m,o,n),o===null||typeof o!="object")(o!==void 0||Array.isArray(A))&&(a+=it(o));else{if(u.includes(o)){w.add(o),a+=4,r||(y=!0);return}if(g.has(o)){a+=g.get(o);return}p++;let D=p,I=a,d=0;if(u.push(o),Array.isArray(o)){d=o.length;for(let b=0;b<d;b++)h(o,b,o[b])}else{let b=a;for(let f of s(o))if(h(o,f,o[f]),b!==a){let c=x.get(f);c===void 0&&x.set(f,c=T(f)+1),a+=c,d++,b=a}}a+=d===0?2:1+d,l>0&&d>0&&(S+=(Array.isArray(o)?0:d)+(1+u.length*l)*(d+1)-l),u.pop(),D!==p&&g.set(o,a-I)}}}function J(t){return N(j(t)?t:async function*(){let e=t.getReader();try{for(;;){let{value:n,done:s}=await e.read();if(s)break;yield n}}finally{e.releaseLock()}})}function z(t,e,n){return typeof ReadableStream.from=="function"?ReadableStream.from(C(t,e,n)):new ReadableStream({start(){this.generator=C(t,e,n)},pull(s){let{value:i,done:r}=this.generator.next();r?s.close():s.enqueue(i)},cancel(){this.generator=null}})}return $(st);})();
+
+  return exports;
+})));
+//# sourceMappingURL=json-ext.min.js.map
Index: imaps-frontend/node_modules/@discoveryjs/json-ext/dist/json-ext.min.js.map
===================================================================
--- imaps-frontend/node_modules/@discoveryjs/json-ext/dist/json-ext.min.js.map	(revision 79a03170cdde4e801d12257ee86723774970427b)
+++ imaps-frontend/node_modules/@discoveryjs/json-ext/dist/json-ext.min.js.map	(revision 79a03170cdde4e801d12257ee86723774970427b)
@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../src/index.js", "../src/utils.js", "../src/parse-chunked.js", "../src/stringify-chunked.js", "../src/stringify-info.js", "../src/web-streams.js"],
+  "sourcesContent": ["export { parseChunked } from './parse-chunked.js';\nexport { stringifyChunked } from './stringify-chunked.js';\nexport { stringifyInfo } from './stringify-info.js';\nexport { createStringifyWebStream, parseFromWebStream } from './web-streams.js';\n", "export function isIterable(value) {\n    return (\n        typeof value === 'object' &&\n        value !== null &&\n        (\n            typeof value[Symbol.iterator] === 'function' ||\n            typeof value[Symbol.asyncIterator] === 'function'\n        )\n    );\n}\n\nexport function replaceValue(holder, key, value, replacer) {\n    if (value && typeof value.toJSON === 'function') {\n        value = value.toJSON();\n    }\n\n    if (replacer !== null) {\n        value = replacer.call(holder, String(key), value);\n    }\n\n    switch (typeof value) {\n        case 'function':\n        case 'symbol':\n            value = undefined;\n            break;\n\n        case 'object':\n            if (value !== null) {\n                const cls = value.constructor;\n                if (cls === String || cls === Number || cls === Boolean) {\n                    value = value.valueOf();\n                }\n            }\n            break;\n    }\n\n    return value;\n}\n\nexport function normalizeReplacer(replacer) {\n    if (typeof replacer === 'function') {\n        return replacer;\n    }\n\n    if (Array.isArray(replacer)) {\n        const allowlist = new Set(replacer\n            .map(item => {\n                const cls = item && item.constructor;\n                return cls === String || cls === Number ? String(item) : null;\n            })\n            .filter(item => typeof item === 'string')\n        );\n\n        return [...allowlist];\n    }\n\n    return null;\n}\n\nexport function normalizeSpace(space) {\n    if (typeof space === 'number') {\n        if (!Number.isFinite(space) || space < 1) {\n            return false;\n        }\n\n        return ' '.repeat(Math.min(space, 10));\n    }\n\n    if (typeof space === 'string') {\n        return space.slice(0, 10) || false;\n    }\n\n    return false;\n}\n\nexport function normalizeStringifyOptions(optionsOrReplacer, space) {\n    if (optionsOrReplacer === null || Array.isArray(optionsOrReplacer) || typeof optionsOrReplacer !== 'object') {\n        optionsOrReplacer = {\n            replacer: optionsOrReplacer,\n            space\n        };\n    }\n\n    let replacer = normalizeReplacer(optionsOrReplacer.replacer);\n    let getKeys = Object.keys;\n\n    if (Array.isArray(replacer)) {\n        const allowlist = replacer;\n\n        getKeys = () => allowlist;\n        replacer = null;\n    }\n\n    return {\n        ...optionsOrReplacer,\n        replacer,\n        getKeys,\n        space: normalizeSpace(optionsOrReplacer.space)\n    };\n}\n", "import { isIterable } from './utils.js';\n\nconst STACK_OBJECT = 1;\nconst STACK_ARRAY = 2;\nconst decoder = new TextDecoder();\n\nfunction adjustPosition(error, parser) {\n    if (error.name === 'SyntaxError' && parser.jsonParseOffset) {\n        error.message = error.message.replace(/at position (\\d+)/, (_, pos) =>\n            'at position ' + (Number(pos) + parser.jsonParseOffset)\n        );\n    }\n\n    return error;\n}\n\nfunction append(array, elements) {\n    // Note: Avoid to use array.push(...elements) since it may lead to\n    // \"RangeError: Maximum call stack size exceeded\" for a long arrays\n    const initialLength = array.length;\n    array.length += elements.length;\n\n    for (let i = 0; i < elements.length; i++) {\n        array[initialLength + i] = elements[i];\n    }\n}\n\nexport async function parseChunked(chunkEmitter) {\n    const iterable = typeof chunkEmitter === 'function'\n        ? chunkEmitter()\n        : chunkEmitter;\n\n    if (isIterable(iterable)) {\n        let parser = new ChunkParser();\n\n        try {\n            for await (const chunk of iterable) {\n                if (typeof chunk !== 'string' && !ArrayBuffer.isView(chunk)) {\n                    throw new TypeError('Invalid chunk: Expected string, TypedArray or Buffer');\n                }\n\n                parser.push(chunk);\n            }\n\n            return parser.finish();\n        } catch (e) {\n            throw adjustPosition(e, parser);\n        }\n    }\n\n    throw new TypeError(\n        'Invalid chunk emitter: Expected an Iterable, AsyncIterable, generator, ' +\n        'async generator, or a function returning an Iterable or AsyncIterable'\n    );\n};\n\nclass ChunkParser {\n    constructor() {\n        this.value = undefined;\n        this.valueStack = null;\n\n        this.stack = new Array(100);\n        this.lastFlushDepth = 0;\n        this.flushDepth = 0;\n        this.stateString = false;\n        this.stateStringEscape = false;\n        this.pendingByteSeq = null;\n        this.pendingChunk = null;\n        this.chunkOffset = 0;\n        this.jsonParseOffset = 0;\n    }\n\n    parseAndAppend(fragment, wrap) {\n        // Append new entries or elements\n        if (this.stack[this.lastFlushDepth - 1] === STACK_OBJECT) {\n            if (wrap) {\n                this.jsonParseOffset--;\n                fragment = '{' + fragment + '}';\n            }\n\n            Object.assign(this.valueStack.value, JSON.parse(fragment));\n        } else {\n            if (wrap) {\n                this.jsonParseOffset--;\n                fragment = '[' + fragment + ']';\n            }\n\n            append(this.valueStack.value, JSON.parse(fragment));\n        }\n    }\n\n    prepareAddition(fragment) {\n        const { value } = this.valueStack;\n        const expectComma = Array.isArray(value)\n            ? value.length !== 0\n            : Object.keys(value).length !== 0;\n\n        if (expectComma) {\n            // Skip a comma at the beginning of fragment, otherwise it would\n            // fail to parse\n            if (fragment[0] === ',') {\n                this.jsonParseOffset++;\n                return fragment.slice(1);\n            }\n\n            // When value (an object or array) is not empty and a fragment\n            // doesn't start with a comma, a single valid fragment starting\n            // is a closing bracket. If it's not, a prefix is adding to fail\n            // parsing. Otherwise, the sequence of chunks can be successfully\n            // parsed, although it should not, e.g. [\"[{}\", \"{}]\"]\n            if (fragment[0] !== '}' && fragment[0] !== ']') {\n                this.jsonParseOffset -= 3;\n                return '[[]' + fragment;\n            }\n        }\n\n        return fragment;\n    }\n\n    flush(chunk, start, end) {\n        let fragment = chunk.slice(start, end);\n\n        // Save position correction an error in JSON.parse() if any\n        this.jsonParseOffset = this.chunkOffset + start;\n\n        // Prepend pending chunk if any\n        if (this.pendingChunk !== null) {\n            fragment = this.pendingChunk + fragment;\n            this.jsonParseOffset -= this.pendingChunk.length;\n            this.pendingChunk = null;\n        }\n\n        if (this.flushDepth === this.lastFlushDepth) {\n            // Depth didn't changed, so it's a root value or entry/element set\n            if (this.flushDepth > 0) {\n                this.parseAndAppend(this.prepareAddition(fragment), true);\n            } else {\n                // That's an entire value on a top level\n                this.value = JSON.parse(fragment);\n                this.valueStack = {\n                    value: this.value,\n                    prev: null\n                };\n            }\n        } else if (this.flushDepth > this.lastFlushDepth) {\n            // Add missed closing brackets/parentheses\n            for (let i = this.flushDepth - 1; i >= this.lastFlushDepth; i--) {\n                fragment += this.stack[i] === STACK_OBJECT ? '}' : ']';\n            }\n\n            if (this.lastFlushDepth === 0) {\n                // That's a root value\n                this.value = JSON.parse(fragment);\n                this.valueStack = {\n                    value: this.value,\n                    prev: null\n                };\n            } else {\n                this.parseAndAppend(this.prepareAddition(fragment), true);\n            }\n\n            // Move down to the depths to the last object/array, which is current now\n            for (let i = this.lastFlushDepth || 1; i < this.flushDepth; i++) {\n                let value = this.valueStack.value;\n\n                if (this.stack[i - 1] === STACK_OBJECT) {\n                    // find last entry\n                    let key;\n                    // eslint-disable-next-line curly\n                    for (key in value);\n                    value = value[key];\n                } else {\n                    // last element\n                    value = value[value.length - 1];\n                }\n\n                this.valueStack = {\n                    value,\n                    prev: this.valueStack\n                };\n            }\n        } else /* this.flushDepth < this.lastFlushDepth */ {\n            fragment = this.prepareAddition(fragment);\n\n            // Add missed opening brackets/parentheses\n            for (let i = this.lastFlushDepth - 1; i >= this.flushDepth; i--) {\n                this.jsonParseOffset--;\n                fragment = (this.stack[i] === STACK_OBJECT ? '{' : '[') + fragment;\n            }\n\n            this.parseAndAppend(fragment, false);\n\n            for (let i = this.lastFlushDepth - 1; i >= this.flushDepth; i--) {\n                this.valueStack = this.valueStack.prev;\n            }\n        }\n\n        this.lastFlushDepth = this.flushDepth;\n    }\n\n    push(chunk) {\n        if (typeof chunk !== 'string') {\n            // Suppose chunk is Buffer or Uint8Array\n\n            // Prepend uncompleted byte sequence if any\n            if (this.pendingByteSeq !== null) {\n                const origRawChunk = chunk;\n                chunk = new Uint8Array(this.pendingByteSeq.length + origRawChunk.length);\n                chunk.set(this.pendingByteSeq);\n                chunk.set(origRawChunk, this.pendingByteSeq.length);\n                this.pendingByteSeq = null;\n            }\n\n            // In case Buffer/Uint8Array, an input is encoded in UTF8\n            // Seek for parts of uncompleted UTF8 symbol on the ending\n            // This makes sense only if we expect more chunks and last char is not multi-bytes\n            if (chunk[chunk.length - 1] > 127) {\n                for (let seqLength = 0; seqLength < chunk.length; seqLength++) {\n                    const byte = chunk[chunk.length - 1 - seqLength];\n\n                    // 10xxxxxx - 2nd, 3rd or 4th byte\n                    // 110xxxxx \u2013 first byte of 2-byte sequence\n                    // 1110xxxx - first byte of 3-byte sequence\n                    // 11110xxx - first byte of 4-byte sequence\n                    if (byte >> 6 === 3) {\n                        seqLength++;\n\n                        // If the sequence is really incomplete, then preserve it\n                        // for the future chunk and cut off it from the current chunk\n                        if ((seqLength !== 4 && byte >> 3 === 0b11110) ||\n                            (seqLength !== 3 && byte >> 4 === 0b1110) ||\n                            (seqLength !== 2 && byte >> 5 === 0b110)) {\n                            this.pendingByteSeq = chunk.slice(chunk.length - seqLength);\n                            chunk = chunk.slice(0, -seqLength);\n                        }\n\n                        break;\n                    }\n                }\n            }\n\n            // Convert chunk to a string, since single decode per chunk\n            // is much effective than decode multiple small substrings\n            chunk = decoder.decode(chunk);\n        }\n\n        const chunkLength = chunk.length;\n        let lastFlushPoint = 0;\n        let flushPoint = 0;\n\n        // Main scan loop\n        scan: for (let i = 0; i < chunkLength; i++) {\n            if (this.stateString) {\n                for (; i < chunkLength; i++) {\n                    if (this.stateStringEscape) {\n                        this.stateStringEscape = false;\n                    } else {\n                        switch (chunk.charCodeAt(i)) {\n                            case 0x22: /* \" */\n                                this.stateString = false;\n                                continue scan;\n\n                            case 0x5C: /* \\ */\n                                this.stateStringEscape = true;\n                        }\n                    }\n                }\n\n                break;\n            }\n\n            switch (chunk.charCodeAt(i)) {\n                case 0x22: /* \" */\n                    this.stateString = true;\n                    this.stateStringEscape = false;\n                    break;\n\n                case 0x2C: /* , */\n                    flushPoint = i;\n                    break;\n\n                case 0x7B: /* { */\n                    // Open an object\n                    flushPoint = i + 1;\n                    this.stack[this.flushDepth++] = STACK_OBJECT;\n                    break;\n\n                case 0x5B: /* [ */\n                    // Open an array\n                    flushPoint = i + 1;\n                    this.stack[this.flushDepth++] = STACK_ARRAY;\n                    break;\n\n                case 0x5D: /* ] */\n                case 0x7D: /* } */\n                    // Close an object or array\n                    flushPoint = i + 1;\n                    this.flushDepth--;\n\n                    if (this.flushDepth < this.lastFlushDepth) {\n                        this.flush(chunk, lastFlushPoint, flushPoint);\n                        lastFlushPoint = flushPoint;\n                    }\n\n                    break;\n\n                case 0x09: /* \\t */\n                case 0x0A: /* \\n */\n                case 0x0D: /* \\r */\n                case 0x20: /* space */\n                    // Move points forward when they points on current position and it's a whitespace\n                    if (lastFlushPoint === i) {\n                        lastFlushPoint++;\n                    }\n\n                    if (flushPoint === i) {\n                        flushPoint++;\n                    }\n\n                    break;\n            }\n        }\n\n        if (flushPoint > lastFlushPoint) {\n            this.flush(chunk, lastFlushPoint, flushPoint);\n        }\n\n        // Produce pendingChunk if something left\n        if (flushPoint < chunkLength) {\n            if (this.pendingChunk !== null) {\n                // When there is already a pending chunk then no flush happened,\n                // appending entire chunk to pending one\n                this.pendingChunk += chunk;\n            } else {\n                // Create a pending chunk, it will start with non-whitespace since\n                // flushPoint was moved forward away from whitespaces on scan\n                this.pendingChunk = chunk.slice(flushPoint, chunkLength);\n            }\n        }\n\n        this.chunkOffset += chunkLength;\n    }\n\n    finish() {\n        if (this.pendingChunk !== null) {\n            this.flush('', 0, 0);\n            this.pendingChunk = null;\n        }\n\n        return this.value;\n    }\n};\n", "import { normalizeStringifyOptions, replaceValue } from './utils.js';\n\nfunction encodeString(value) {\n    if (/[^\\x20\\x21\\x23-\\x5B\\x5D-\\uD799]/.test(value)) { // [^\\x20-\\uD799]|[\\x22\\x5c]\n        return JSON.stringify(value);\n    }\n\n    return '\"' + value + '\"';\n}\n\nexport function* stringifyChunked(value, ...args) {\n    const { replacer, getKeys, space, ...options } = normalizeStringifyOptions(...args);\n    const highWaterMark = Number(options.highWaterMark) || 0x4000; // 16kb by default\n\n    const keyStrings = new Map();\n    const stack = [];\n    const rootValue = { '': value };\n    let prevState = null;\n    let state = () => printEntry('', value);\n    let stateValue = rootValue;\n    let stateEmpty = true;\n    let stateKeys = [''];\n    let stateIndex = 0;\n    let buffer = '';\n\n    while (true) {\n        state();\n\n        if (buffer.length >= highWaterMark || prevState === null) {\n            // flush buffer\n            yield buffer;\n            buffer = '';\n\n            if (prevState === null) {\n                break;\n            }\n        }\n    }\n\n    function printObject() {\n        if (stateIndex === 0) {\n            stateKeys = getKeys(stateValue);\n            buffer += '{';\n        }\n\n        // when no keys left\n        if (stateIndex === stateKeys.length) {\n            buffer += space && !stateEmpty\n                ? `\\n${space.repeat(stack.length - 1)}}`\n                : '}';\n\n            popState();\n            return;\n        }\n\n        const key = stateKeys[stateIndex++];\n        printEntry(key, stateValue[key]);\n    }\n\n    function printArray() {\n        if (stateIndex === 0) {\n            buffer += '[';\n        }\n\n        if (stateIndex === stateValue.length) {\n            buffer += space && !stateEmpty\n                ? `\\n${space.repeat(stack.length - 1)}]`\n                : ']';\n\n            popState();\n            return;\n        }\n\n        printEntry(stateIndex, stateValue[stateIndex++]);\n    }\n\n    function printEntryPrelude(key) {\n        if (stateEmpty) {\n            stateEmpty = false;\n        } else {\n            buffer += ',';\n        }\n\n        if (space && prevState !== null) {\n            buffer += `\\n${space.repeat(stack.length)}`;\n        }\n\n        if (state === printObject) {\n            let keyString = keyStrings.get(key);\n\n            if (keyString === undefined) {\n                keyStrings.set(key, keyString = encodeString(key) + (space ? ': ' : ':'));\n            }\n\n            buffer += keyString;\n        }\n    }\n\n    function printEntry(key, value) {\n        value = replaceValue(stateValue, key, value, replacer);\n\n        if (value === null || typeof value !== 'object') {\n            // primitive\n            if (state !== printObject || value !== undefined) {\n                printEntryPrelude(key);\n                pushPrimitive(value);\n            }\n        } else {\n            // If the visited set does not change after adding a value, then it is already in the set\n            if (stack.includes(value)) {\n                throw new TypeError('Converting circular structure to JSON');\n            }\n\n            printEntryPrelude(key);\n            stack.push(value);\n\n            pushState();\n            state = Array.isArray(value) ? printArray : printObject;\n            stateValue = value;\n            stateEmpty = true;\n            stateIndex = 0;\n        }\n    }\n\n    function pushPrimitive(value) {\n        switch (typeof value) {\n            case 'string':\n                buffer += encodeString(value);\n                break;\n\n            case 'number':\n                buffer += Number.isFinite(value) ? String(value) : 'null';\n                break;\n\n            case 'boolean':\n                buffer += value ? 'true' : 'false';\n                break;\n\n            case 'undefined':\n            case 'object': // typeof null === 'object'\n                buffer += 'null';\n                break;\n\n            default:\n                throw new TypeError(`Do not know how to serialize a ${value.constructor?.name || typeof value}`);\n        }\n    }\n\n    function pushState() {\n        prevState = {\n            keys: stateKeys,\n            index: stateIndex,\n            prev: prevState\n        };\n    }\n\n    function popState() {\n        stack.pop();\n        const value = stack.length > 0 ? stack[stack.length - 1] : rootValue;\n\n        // restore state\n        state = Array.isArray(value) ? printArray : printObject;\n        stateValue = value;\n        stateEmpty = false;\n        stateKeys = prevState.keys;\n        stateIndex = prevState.index;\n\n        // pop state\n        prevState = prevState.prev;\n    }\n};\n", "import { normalizeStringifyOptions, replaceValue } from './utils.js';\n\nconst hasOwn = typeof Object.hasOwn === 'function'\n    ? Object.hasOwn\n    : (object, key) => Object.hasOwnProperty.call(object, key);\n\n// https://tc39.es/ecma262/#table-json-single-character-escapes\nconst escapableCharCodeSubstitution = { // JSON Single Character Escape Sequences\n    0x08: '\\\\b',\n    0x09: '\\\\t',\n    0x0a: '\\\\n',\n    0x0c: '\\\\f',\n    0x0d: '\\\\r',\n    0x22: '\\\\\\\"',\n    0x5c: '\\\\\\\\'\n};\n\nconst charLength2048 = Uint8Array.from({ length: 2048 }, (_, code) => {\n    if (hasOwn(escapableCharCodeSubstitution, code)) {\n        return 2; // \\X\n    }\n\n    if (code < 0x20) {\n        return 6; // \\uXXXX\n    }\n\n    return code < 128 ? 1 : 2; // UTF8 bytes\n});\n\nfunction isLeadingSurrogate(code) {\n    return code >= 0xD800 && code <= 0xDBFF;\n}\n\nfunction isTrailingSurrogate(code) {\n    return code >= 0xDC00 && code <= 0xDFFF;\n}\n\nfunction stringLength(str) {\n    // Fast path to compute length when a string contains only characters encoded as single bytes\n    if (!/[^\\x20\\x21\\x23-\\x5B\\x5D-\\x7F]/.test(str)) {\n        return str.length + 2;\n    }\n\n    let len = 0;\n    let prevLeadingSurrogate = false;\n\n    for (let i = 0; i < str.length; i++) {\n        const code = str.charCodeAt(i);\n\n        if (code < 2048) {\n            len += charLength2048[code];\n        } else if (isLeadingSurrogate(code)) {\n            len += 6; // \\uXXXX since no pair with trailing surrogate yet\n            prevLeadingSurrogate = true;\n            continue;\n        } else if (isTrailingSurrogate(code)) {\n            len = prevLeadingSurrogate\n                ? len - 2  // surrogate pair (4 bytes), since we calculate prev leading surrogate as 6 bytes, substruct 2 bytes\n                : len + 6; // \\uXXXX\n        } else {\n            len += 3; // code >= 2048 is 3 bytes length for UTF8\n        }\n\n        prevLeadingSurrogate = false;\n    }\n\n    return len + 2; // +2 for quotes\n}\n\n// avoid producing a string from a number\nfunction intLength(num) {\n    let len = 0;\n\n    if (num < 0) {\n        len = 1;\n        num = -num;\n    }\n\n    if (num >= 1e9) {\n        len += 9;\n        num = (num - num % 1e9) / 1e9;\n    }\n\n    if (num >= 1e4) {\n        if (num >= 1e6) {\n            return len + (num >= 1e8\n                ? 9\n                : num >= 1e7 ? 8 : 7\n            );\n        }\n        return len + (num >= 1e5 ? 6 : 5);\n    }\n\n    return len + (num >= 1e2\n        ? num >= 1e3 ? 4 : 3\n        : num >= 10 ? 2 : 1\n    );\n};\n\nfunction primitiveLength(value) {\n    switch (typeof value) {\n        case 'string':\n            return stringLength(value);\n\n        case 'number':\n            return Number.isFinite(value)\n                ? Number.isInteger(value)\n                    ? intLength(value)\n                    : String(value).length\n                : 4 /* null */;\n\n        case 'boolean':\n            return value ? 4 /* true */ : 5 /* false */;\n\n        case 'undefined':\n        case 'object':\n            return 4; /* null */\n\n        default:\n            return 0;\n    }\n}\n\nexport function stringifyInfo(value, ...args) {\n    const { replacer, getKeys, ...options } = normalizeStringifyOptions(...args);\n    const continueOnCircular = Boolean(options.continueOnCircular);\n    const space = options.space?.length || 0;\n\n    const keysLength = new Map();\n    const visited = new Map();\n    const circular = new Set();\n    const stack = [];\n    const root = { '': value };\n    let stop = false;\n    let bytes = 0;\n    let spaceBytes = 0;\n    let objects = 0;\n\n    walk(root, '', value);\n\n    // when value is undefined or replaced for undefined\n    if (bytes === 0) {\n        bytes += 9; // FIXME: that's the length of undefined, should we normalize behaviour to convert it to null?\n    }\n\n    return {\n        bytes: isNaN(bytes) ? Infinity : bytes + spaceBytes,\n        spaceBytes: space > 0 && isNaN(bytes) ? Infinity : spaceBytes,\n        circular: [...circular]\n    };\n\n    function walk(holder, key, value) {\n        if (stop) {\n            return;\n        }\n\n        value = replaceValue(holder, key, value, replacer);\n\n        if (value === null || typeof value !== 'object') {\n            // primitive\n            if (value !== undefined || Array.isArray(holder)) {\n                bytes += primitiveLength(value);\n            }\n        } else {\n            // check for circular references\n            if (stack.includes(value)) {\n                circular.add(value);\n                bytes += 4; // treat as null\n\n                if (!continueOnCircular) {\n                    stop = true;\n                }\n\n                return;\n            }\n\n            // Using 'visited' allows avoiding hang-ups in cases of highly interconnected object graphs;\n            // for example, a list of git commits with references to parents can lead to N^2 complexity for traversal,\n            // and N when 'visited' is used\n            if (visited.has(value)) {\n                bytes += visited.get(value);\n\n                return;\n            }\n\n            objects++;\n\n            const prevObjects = objects;\n            const valueBytes = bytes;\n            let valueLength = 0;\n\n            stack.push(value);\n\n            if (Array.isArray(value)) {\n                // array\n                valueLength = value.length;\n\n                for (let i = 0; i < valueLength; i++) {\n                    walk(value, i, value[i]);\n                }\n            } else {\n                // object\n                let prevLength = bytes;\n\n                for (const key of getKeys(value)) {\n                    walk(value, key, value[key]);\n\n                    if (prevLength !== bytes) {\n                        let keyLen = keysLength.get(key);\n\n                        if (keyLen === undefined) {\n                            keysLength.set(key, keyLen = stringLength(key) + 1); // \"key\":\n                        }\n\n                        // value is printed\n                        bytes += keyLen;\n                        valueLength++;\n                        prevLength = bytes;\n                    }\n                }\n            }\n\n            bytes += valueLength === 0\n                ? 2 // {} or []\n                : 1 + valueLength; // {} or [] + commas\n\n            if (space > 0 && valueLength > 0) {\n                spaceBytes +=\n                    // a space between \":\" and a value for each object entry\n                    (Array.isArray(value) ? 0 : valueLength) +\n                    // the formula results from folding the following components:\n                    // - for each key-value or element: ident + newline\n                    //   (1 + stack.length * space) * valueLength\n                    // - ident (one space less) before \"}\" or \"]\" + newline\n                    //   (stack.length - 1) * space + 1\n                    (1 + stack.length * space) * (valueLength + 1) - space;\n            }\n\n            stack.pop();\n\n            // add to 'visited' only objects that contain nested objects\n            if (prevObjects !== objects) {\n                visited.set(value, bytes - valueBytes);\n            }\n        }\n    }\n};\n", "/* eslint-env browser */\nimport { parseChunked } from './parse-chunked.js';\nimport { stringifyChunked } from './stringify-chunked.js';\nimport { isIterable } from './utils.js';\n\nexport function parseFromWebStream(stream) {\n    // 2024/6/17: currently, an @@asyncIterator on a ReadableStream is not widely supported,\n    // therefore use a fallback using a reader\n    // https://caniuse.com/mdn-api_readablestream_--asynciterator\n    return parseChunked(isIterable(stream) ? stream : async function*() {\n        const reader = stream.getReader();\n\n        try {\n            while (true) {\n                const { value, done } = await reader.read();\n\n                if (done) {\n                    break;\n                }\n\n                yield value;\n            }\n        } finally {\n            reader.releaseLock();\n        }\n    });\n}\n\nexport function createStringifyWebStream(value, replacer, space) {\n    // 2024/6/17: the ReadableStream.from() static method is supported\n    // in Node.js 20.6+ and Firefox only\n    if (typeof ReadableStream.from === 'function') {\n        return ReadableStream.from(stringifyChunked(value, replacer, space));\n    }\n\n    // emulate ReadableStream.from()\n    return new ReadableStream({\n        start() {\n            this.generator = stringifyChunked(value, replacer, space);\n        },\n        pull(controller) {\n            const { value, done } = this.generator.next();\n\n            if (done) {\n                controller.close();\n            } else {\n                controller.enqueue(value);\n            }\n        },\n        cancel() {\n            this.generator = null;\n        }\n    });\n};\n"],
+  "mappings": "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",
+  "names": ["src_exports", "__export", "createStringifyWebStream", "parseChunked", "parseFromWebStream", "stringifyChunked", "stringifyInfo", "isIterable", "value", "replaceValue", "holder", "key", "replacer", "cls", "normalizeReplacer", "item", "normalizeSpace", "space", "normalizeStringifyOptions", "optionsOrReplacer", "getKeys", "allowlist", "STACK_OBJECT", "STACK_ARRAY", "decoder", "adjustPosition", "error", "parser", "_", "pos", "append", "array", "elements", "initialLength", "i", "parseChunked", "chunkEmitter", "iterable", "isIterable", "ChunkParser", "chunk", "e", "fragment", "wrap", "value", "start", "end", "key", "origRawChunk", "seqLength", "byte", "chunkLength", "lastFlushPoint", "flushPoint", "scan", "encodeString", "value", "stringifyChunked", "args", "replacer", "getKeys", "space", "options", "normalizeStringifyOptions", "highWaterMark", "keyStrings", "stack", "rootValue", "prevState", "state", "printEntry", "stateValue", "stateEmpty", "stateKeys", "stateIndex", "buffer", "printObject", "popState", "key", "printArray", "printEntryPrelude", "keyString", "replaceValue", "pushPrimitive", "pushState", "hasOwn", "object", "key", "escapableCharCodeSubstitution", "charLength2048", "_", "code", "isLeadingSurrogate", "isTrailingSurrogate", "stringLength", "str", "len", "prevLeadingSurrogate", "i", "intLength", "num", "primitiveLength", "value", "stringifyInfo", "args", "replacer", "getKeys", "options", "normalizeStringifyOptions", "continueOnCircular", "space", "keysLength", "visited", "circular", "stack", "root", "stop", "bytes", "spaceBytes", "objects", "walk", "holder", "replaceValue", "prevObjects", "valueBytes", "valueLength", "prevLength", "keyLen", "parseFromWebStream", "stream", "parseChunked", "isIterable", "reader", "value", "done", "createStringifyWebStream", "replacer", "space", "stringifyChunked", "controller"]
+}
Index: imaps-frontend/node_modules/@discoveryjs/json-ext/dist/package.json
===================================================================
--- imaps-frontend/node_modules/@discoveryjs/json-ext/dist/package.json	(revision 79a03170cdde4e801d12257ee86723774970427b)
+++ imaps-frontend/node_modules/@discoveryjs/json-ext/dist/package.json	(revision 79a03170cdde4e801d12257ee86723774970427b)
@@ -0,0 +1,3 @@
+{
+    "type": "commonjs"
+}
Index: imaps-frontend/node_modules/@discoveryjs/json-ext/index.d.ts
===================================================================
--- imaps-frontend/node_modules/@discoveryjs/json-ext/index.d.ts	(revision 79a03170cdde4e801d12257ee86723774970427b)
+++ imaps-frontend/node_modules/@discoveryjs/json-ext/index.d.ts	(revision 79a03170cdde4e801d12257ee86723774970427b)
@@ -0,0 +1,37 @@
+declare module '@discoveryjs/json-ext' {
+    type Chunk = string | Uint8Array | Buffer;
+    type Replacer =
+        | ((this: any, key: string, value: any) => any)
+        | (string | number)[]
+        | null;
+    type Space = string | number | null;
+    type StringifyOptions = {
+        replacer?: Replacer;
+        space?: Space;
+        highWaterMark?: number;
+    };
+    type StringifyInfoOptions = {
+        replacer?: Replacer;
+        space?: Space;
+        continueOnCircular?: boolean;
+    }
+    type StringifyInfoResult = {
+        bytes: number;
+        spaceBytes: number;
+        circular: object[];
+    };
+
+    export function parseChunked(input: Iterable<Chunk> | AsyncIterable<Chunk>): Promise<any>;
+    export function parseChunked(input: () => (Iterable<Chunk> | AsyncIterable<Chunk>)): Promise<any>;
+
+    export function stringifyChunked(value: any, replacer?: Replacer, space?: Space): Generator<string>;
+    export function stringifyChunked(value: any, options: StringifyOptions): Generator<string>;
+
+    export function stringifyInfo(value: any, replacer?: Replacer, space?: Space): StringifyInfoResult;
+    export function stringifyInfo(value: any, options?: StringifyInfoOptions): StringifyInfoResult;
+
+    // Web streams
+    export function parseFromWebStream(stream: ReadableStream<Chunk>): Promise<any>;
+    export function createStringifyWebStream(value: any, replacer?: Replacer, space?: Space): ReadableStream<string>;
+    export function createStringifyWebStream(value: any, options: StringifyOptions): ReadableStream<string>;
+}
Index: imaps-frontend/node_modules/@discoveryjs/json-ext/package.json
===================================================================
--- imaps-frontend/node_modules/@discoveryjs/json-ext/package.json	(revision 79a03170cdde4e801d12257ee86723774970427b)
+++ imaps-frontend/node_modules/@discoveryjs/json-ext/package.json	(revision 79a03170cdde4e801d12257ee86723774970427b)
@@ -0,0 +1,68 @@
+{
+    "name": "@discoveryjs/json-ext",
+    "version": "0.6.3",
+    "description": "A set of utilities that extend the use of JSON",
+    "keywords": [
+        "json",
+        "utils",
+        "stream",
+        "async",
+        "promise",
+        "stringify",
+        "info"
+    ],
+    "author": "Roman Dvornov <rdvornov@gmail.com> (https://github.com/lahmatiy)",
+    "license": "MIT",
+    "repository": {
+        "type": "git",
+        "url": "git+https://github.com/discoveryjs/json-ext.git"
+    },
+    "engines": {
+        "node": ">=14.17.0"
+    },
+    "type": "module",
+    "main": "./cjs/index.cjs",
+    "module": "./src/index.js",
+    "types": "./index.d.ts",
+    "exports": {
+        ".": {
+            "types": "./index.d.ts",
+            "require": "./cjs/index.cjs",
+            "import": "./src/index.js"
+        },
+        "./dist/*": "./dist/*",
+        "./package.json": "./package.json"
+    },
+    "scripts": {
+        "test": "npm run test:src",
+        "lint": "eslint src",
+        "lint-and-test": "npm run lint && npm test",
+        "bundle": "node scripts/bundle.js",
+        "transpile": "node scripts/transpile.cjs",
+        "test:all": "npm run test:src && npm run test:cjs && npm run test:dist && npm run test:e2e",
+        "test:src": "mocha --reporter progress src/*.test.js",
+        "test:cjs": "mocha --reporter progress cjs/*.test.cjs",
+        "test:e2e": "mocha --reporter progress test-e2e",
+        "test:dist": "mocha --reporter progress dist/test",
+        "test:deno": "node scripts/deno-adapt-test.js && mocha --reporter progress deno-tests/*.test.js",
+        "bundle-and-test": "npm run bundle && npm run test:dist",
+        "coverage": "c8 --reporter=lcovonly npm test",
+        "prepublishOnly": "npm run lint && npm run bundle && npm run transpile && npm run test:all"
+    },
+    "devDependencies": {
+        "c8": "^7.10.0",
+        "chalk": "^4.1.0",
+        "esbuild": "^0.24.0",
+        "eslint": "^8.57.0",
+        "mocha": "^9.2.2",
+        "rollup": "^2.79.2"
+    },
+    "files": [
+        "cjs",
+        "!cjs/*{.test,-cases}.cjs",
+        "dist",
+        "src",
+        "!src/*{.test,-cases}.js",
+        "index.d.ts"
+    ]
+}
Index: imaps-frontend/node_modules/@discoveryjs/json-ext/src/index.js
===================================================================
--- imaps-frontend/node_modules/@discoveryjs/json-ext/src/index.js	(revision 79a03170cdde4e801d12257ee86723774970427b)
+++ imaps-frontend/node_modules/@discoveryjs/json-ext/src/index.js	(revision 79a03170cdde4e801d12257ee86723774970427b)
@@ -0,0 +1,4 @@
+export { parseChunked } from './parse-chunked.js';
+export { stringifyChunked } from './stringify-chunked.js';
+export { stringifyInfo } from './stringify-info.js';
+export { createStringifyWebStream, parseFromWebStream } from './web-streams.js';
Index: imaps-frontend/node_modules/@discoveryjs/json-ext/src/parse-chunked.js
===================================================================
--- imaps-frontend/node_modules/@discoveryjs/json-ext/src/parse-chunked.js	(revision 79a03170cdde4e801d12257ee86723774970427b)
+++ imaps-frontend/node_modules/@discoveryjs/json-ext/src/parse-chunked.js	(revision 79a03170cdde4e801d12257ee86723774970427b)
@@ -0,0 +1,352 @@
+import { isIterable } from './utils.js';
+
+const STACK_OBJECT = 1;
+const STACK_ARRAY = 2;
+const decoder = new TextDecoder();
+
+function adjustPosition(error, parser) {
+    if (error.name === 'SyntaxError' && parser.jsonParseOffset) {
+        error.message = error.message.replace(/at position (\d+)/, (_, pos) =>
+            'at position ' + (Number(pos) + parser.jsonParseOffset)
+        );
+    }
+
+    return error;
+}
+
+function append(array, elements) {
+    // Note: Avoid to use array.push(...elements) since it may lead to
+    // "RangeError: Maximum call stack size exceeded" for a long arrays
+    const initialLength = array.length;
+    array.length += elements.length;
+
+    for (let i = 0; i < elements.length; i++) {
+        array[initialLength + i] = elements[i];
+    }
+}
+
+export async function parseChunked(chunkEmitter) {
+    const iterable = typeof chunkEmitter === 'function'
+        ? chunkEmitter()
+        : chunkEmitter;
+
+    if (isIterable(iterable)) {
+        let parser = new ChunkParser();
+
+        try {
+            for await (const chunk of iterable) {
+                if (typeof chunk !== 'string' && !ArrayBuffer.isView(chunk)) {
+                    throw new TypeError('Invalid chunk: Expected string, TypedArray or Buffer');
+                }
+
+                parser.push(chunk);
+            }
+
+            return parser.finish();
+        } catch (e) {
+            throw adjustPosition(e, parser);
+        }
+    }
+
+    throw new TypeError(
+        'Invalid chunk emitter: Expected an Iterable, AsyncIterable, generator, ' +
+        'async generator, or a function returning an Iterable or AsyncIterable'
+    );
+};
+
+class ChunkParser {
+    constructor() {
+        this.value = undefined;
+        this.valueStack = null;
+
+        this.stack = new Array(100);
+        this.lastFlushDepth = 0;
+        this.flushDepth = 0;
+        this.stateString = false;
+        this.stateStringEscape = false;
+        this.pendingByteSeq = null;
+        this.pendingChunk = null;
+        this.chunkOffset = 0;
+        this.jsonParseOffset = 0;
+    }
+
+    parseAndAppend(fragment, wrap) {
+        // Append new entries or elements
+        if (this.stack[this.lastFlushDepth - 1] === STACK_OBJECT) {
+            if (wrap) {
+                this.jsonParseOffset--;
+                fragment = '{' + fragment + '}';
+            }
+
+            Object.assign(this.valueStack.value, JSON.parse(fragment));
+        } else {
+            if (wrap) {
+                this.jsonParseOffset--;
+                fragment = '[' + fragment + ']';
+            }
+
+            append(this.valueStack.value, JSON.parse(fragment));
+        }
+    }
+
+    prepareAddition(fragment) {
+        const { value } = this.valueStack;
+        const expectComma = Array.isArray(value)
+            ? value.length !== 0
+            : Object.keys(value).length !== 0;
+
+        if (expectComma) {
+            // Skip a comma at the beginning of fragment, otherwise it would
+            // fail to parse
+            if (fragment[0] === ',') {
+                this.jsonParseOffset++;
+                return fragment.slice(1);
+            }
+
+            // When value (an object or array) is not empty and a fragment
+            // doesn't start with a comma, a single valid fragment starting
+            // is a closing bracket. If it's not, a prefix is adding to fail
+            // parsing. Otherwise, the sequence of chunks can be successfully
+            // parsed, although it should not, e.g. ["[{}", "{}]"]
+            if (fragment[0] !== '}' && fragment[0] !== ']') {
+                this.jsonParseOffset -= 3;
+                return '[[]' + fragment;
+            }
+        }
+
+        return fragment;
+    }
+
+    flush(chunk, start, end) {
+        let fragment = chunk.slice(start, end);
+
+        // Save position correction an error in JSON.parse() if any
+        this.jsonParseOffset = this.chunkOffset + start;
+
+        // Prepend pending chunk if any
+        if (this.pendingChunk !== null) {
+            fragment = this.pendingChunk + fragment;
+            this.jsonParseOffset -= this.pendingChunk.length;
+            this.pendingChunk = null;
+        }
+
+        if (this.flushDepth === this.lastFlushDepth) {
+            // Depth didn't changed, so it's a root value or entry/element set
+            if (this.flushDepth > 0) {
+                this.parseAndAppend(this.prepareAddition(fragment), true);
+            } else {
+                // That's an entire value on a top level
+                this.value = JSON.parse(fragment);
+                this.valueStack = {
+                    value: this.value,
+                    prev: null
+                };
+            }
+        } else if (this.flushDepth > this.lastFlushDepth) {
+            // Add missed closing brackets/parentheses
+            for (let i = this.flushDepth - 1; i >= this.lastFlushDepth; i--) {
+                fragment += this.stack[i] === STACK_OBJECT ? '}' : ']';
+            }
+
+            if (this.lastFlushDepth === 0) {
+                // That's a root value
+                this.value = JSON.parse(fragment);
+                this.valueStack = {
+                    value: this.value,
+                    prev: null
+                };
+            } else {
+                this.parseAndAppend(this.prepareAddition(fragment), true);
+            }
+
+            // Move down to the depths to the last object/array, which is current now
+            for (let i = this.lastFlushDepth || 1; i < this.flushDepth; i++) {
+                let value = this.valueStack.value;
+
+                if (this.stack[i - 1] === STACK_OBJECT) {
+                    // find last entry
+                    let key;
+                    // eslint-disable-next-line curly
+                    for (key in value);
+                    value = value[key];
+                } else {
+                    // last element
+                    value = value[value.length - 1];
+                }
+
+                this.valueStack = {
+                    value,
+                    prev: this.valueStack
+                };
+            }
+        } else /* this.flushDepth < this.lastFlushDepth */ {
+            fragment = this.prepareAddition(fragment);
+
+            // Add missed opening brackets/parentheses
+            for (let i = this.lastFlushDepth - 1; i >= this.flushDepth; i--) {
+                this.jsonParseOffset--;
+                fragment = (this.stack[i] === STACK_OBJECT ? '{' : '[') + fragment;
+            }
+
+            this.parseAndAppend(fragment, false);
+
+            for (let i = this.lastFlushDepth - 1; i >= this.flushDepth; i--) {
+                this.valueStack = this.valueStack.prev;
+            }
+        }
+
+        this.lastFlushDepth = this.flushDepth;
+    }
+
+    push(chunk) {
+        if (typeof chunk !== 'string') {
+            // Suppose chunk is Buffer or Uint8Array
+
+            // Prepend uncompleted byte sequence if any
+            if (this.pendingByteSeq !== null) {
+                const origRawChunk = chunk;
+                chunk = new Uint8Array(this.pendingByteSeq.length + origRawChunk.length);
+                chunk.set(this.pendingByteSeq);
+                chunk.set(origRawChunk, this.pendingByteSeq.length);
+                this.pendingByteSeq = null;
+            }
+
+            // In case Buffer/Uint8Array, an input is encoded in UTF8
+            // Seek for parts of uncompleted UTF8 symbol on the ending
+            // This makes sense only if we expect more chunks and last char is not multi-bytes
+            if (chunk[chunk.length - 1] > 127) {
+                for (let seqLength = 0; seqLength < chunk.length; seqLength++) {
+                    const byte = chunk[chunk.length - 1 - seqLength];
+
+                    // 10xxxxxx - 2nd, 3rd or 4th byte
+                    // 110xxxxx – first byte of 2-byte sequence
+                    // 1110xxxx - first byte of 3-byte sequence
+                    // 11110xxx - first byte of 4-byte sequence
+                    if (byte >> 6 === 3) {
+                        seqLength++;
+
+                        // If the sequence is really incomplete, then preserve it
+                        // for the future chunk and cut off it from the current chunk
+                        if ((seqLength !== 4 && byte >> 3 === 0b11110) ||
+                            (seqLength !== 3 && byte >> 4 === 0b1110) ||
+                            (seqLength !== 2 && byte >> 5 === 0b110)) {
+                            this.pendingByteSeq = chunk.slice(chunk.length - seqLength);
+                            chunk = chunk.slice(0, -seqLength);
+                        }
+
+                        break;
+                    }
+                }
+            }
+
+            // Convert chunk to a string, since single decode per chunk
+            // is much effective than decode multiple small substrings
+            chunk = decoder.decode(chunk);
+        }
+
+        const chunkLength = chunk.length;
+        let lastFlushPoint = 0;
+        let flushPoint = 0;
+
+        // Main scan loop
+        scan: for (let i = 0; i < chunkLength; i++) {
+            if (this.stateString) {
+                for (; i < chunkLength; i++) {
+                    if (this.stateStringEscape) {
+                        this.stateStringEscape = false;
+                    } else {
+                        switch (chunk.charCodeAt(i)) {
+                            case 0x22: /* " */
+                                this.stateString = false;
+                                continue scan;
+
+                            case 0x5C: /* \ */
+                                this.stateStringEscape = true;
+                        }
+                    }
+                }
+
+                break;
+            }
+
+            switch (chunk.charCodeAt(i)) {
+                case 0x22: /* " */
+                    this.stateString = true;
+                    this.stateStringEscape = false;
+                    break;
+
+                case 0x2C: /* , */
+                    flushPoint = i;
+                    break;
+
+                case 0x7B: /* { */
+                    // Open an object
+                    flushPoint = i + 1;
+                    this.stack[this.flushDepth++] = STACK_OBJECT;
+                    break;
+
+                case 0x5B: /* [ */
+                    // Open an array
+                    flushPoint = i + 1;
+                    this.stack[this.flushDepth++] = STACK_ARRAY;
+                    break;
+
+                case 0x5D: /* ] */
+                case 0x7D: /* } */
+                    // Close an object or array
+                    flushPoint = i + 1;
+                    this.flushDepth--;
+
+                    if (this.flushDepth < this.lastFlushDepth) {
+                        this.flush(chunk, lastFlushPoint, flushPoint);
+                        lastFlushPoint = flushPoint;
+                    }
+
+                    break;
+
+                case 0x09: /* \t */
+                case 0x0A: /* \n */
+                case 0x0D: /* \r */
+                case 0x20: /* space */
+                    // Move points forward when they points on current position and it's a whitespace
+                    if (lastFlushPoint === i) {
+                        lastFlushPoint++;
+                    }
+
+                    if (flushPoint === i) {
+                        flushPoint++;
+                    }
+
+                    break;
+            }
+        }
+
+        if (flushPoint > lastFlushPoint) {
+            this.flush(chunk, lastFlushPoint, flushPoint);
+        }
+
+        // Produce pendingChunk if something left
+        if (flushPoint < chunkLength) {
+            if (this.pendingChunk !== null) {
+                // When there is already a pending chunk then no flush happened,
+                // appending entire chunk to pending one
+                this.pendingChunk += chunk;
+            } else {
+                // Create a pending chunk, it will start with non-whitespace since
+                // flushPoint was moved forward away from whitespaces on scan
+                this.pendingChunk = chunk.slice(flushPoint, chunkLength);
+            }
+        }
+
+        this.chunkOffset += chunkLength;
+    }
+
+    finish() {
+        if (this.pendingChunk !== null) {
+            this.flush('', 0, 0);
+            this.pendingChunk = null;
+        }
+
+        return this.value;
+    }
+};
Index: imaps-frontend/node_modules/@discoveryjs/json-ext/src/stringify-chunked.js
===================================================================
--- imaps-frontend/node_modules/@discoveryjs/json-ext/src/stringify-chunked.js	(revision 79a03170cdde4e801d12257ee86723774970427b)
+++ imaps-frontend/node_modules/@discoveryjs/json-ext/src/stringify-chunked.js	(revision 79a03170cdde4e801d12257ee86723774970427b)
@@ -0,0 +1,171 @@
+import { normalizeStringifyOptions, replaceValue } from './utils.js';
+
+function encodeString(value) {
+    if (/[^\x20\x21\x23-\x5B\x5D-\uD799]/.test(value)) { // [^\x20-\uD799]|[\x22\x5c]
+        return JSON.stringify(value);
+    }
+
+    return '"' + value + '"';
+}
+
+export function* stringifyChunked(value, ...args) {
+    const { replacer, getKeys, space, ...options } = normalizeStringifyOptions(...args);
+    const highWaterMark = Number(options.highWaterMark) || 0x4000; // 16kb by default
+
+    const keyStrings = new Map();
+    const stack = [];
+    const rootValue = { '': value };
+    let prevState = null;
+    let state = () => printEntry('', value);
+    let stateValue = rootValue;
+    let stateEmpty = true;
+    let stateKeys = [''];
+    let stateIndex = 0;
+    let buffer = '';
+
+    while (true) {
+        state();
+
+        if (buffer.length >= highWaterMark || prevState === null) {
+            // flush buffer
+            yield buffer;
+            buffer = '';
+
+            if (prevState === null) {
+                break;
+            }
+        }
+    }
+
+    function printObject() {
+        if (stateIndex === 0) {
+            stateKeys = getKeys(stateValue);
+            buffer += '{';
+        }
+
+        // when no keys left
+        if (stateIndex === stateKeys.length) {
+            buffer += space && !stateEmpty
+                ? `\n${space.repeat(stack.length - 1)}}`
+                : '}';
+
+            popState();
+            return;
+        }
+
+        const key = stateKeys[stateIndex++];
+        printEntry(key, stateValue[key]);
+    }
+
+    function printArray() {
+        if (stateIndex === 0) {
+            buffer += '[';
+        }
+
+        if (stateIndex === stateValue.length) {
+            buffer += space && !stateEmpty
+                ? `\n${space.repeat(stack.length - 1)}]`
+                : ']';
+
+            popState();
+            return;
+        }
+
+        printEntry(stateIndex, stateValue[stateIndex++]);
+    }
+
+    function printEntryPrelude(key) {
+        if (stateEmpty) {
+            stateEmpty = false;
+        } else {
+            buffer += ',';
+        }
+
+        if (space && prevState !== null) {
+            buffer += `\n${space.repeat(stack.length)}`;
+        }
+
+        if (state === printObject) {
+            let keyString = keyStrings.get(key);
+
+            if (keyString === undefined) {
+                keyStrings.set(key, keyString = encodeString(key) + (space ? ': ' : ':'));
+            }
+
+            buffer += keyString;
+        }
+    }
+
+    function printEntry(key, value) {
+        value = replaceValue(stateValue, key, value, replacer);
+
+        if (value === null || typeof value !== 'object') {
+            // primitive
+            if (state !== printObject || value !== undefined) {
+                printEntryPrelude(key);
+                pushPrimitive(value);
+            }
+        } else {
+            // If the visited set does not change after adding a value, then it is already in the set
+            if (stack.includes(value)) {
+                throw new TypeError('Converting circular structure to JSON');
+            }
+
+            printEntryPrelude(key);
+            stack.push(value);
+
+            pushState();
+            state = Array.isArray(value) ? printArray : printObject;
+            stateValue = value;
+            stateEmpty = true;
+            stateIndex = 0;
+        }
+    }
+
+    function pushPrimitive(value) {
+        switch (typeof value) {
+            case 'string':
+                buffer += encodeString(value);
+                break;
+
+            case 'number':
+                buffer += Number.isFinite(value) ? String(value) : 'null';
+                break;
+
+            case 'boolean':
+                buffer += value ? 'true' : 'false';
+                break;
+
+            case 'undefined':
+            case 'object': // typeof null === 'object'
+                buffer += 'null';
+                break;
+
+            default:
+                throw new TypeError(`Do not know how to serialize a ${value.constructor?.name || typeof value}`);
+        }
+    }
+
+    function pushState() {
+        prevState = {
+            keys: stateKeys,
+            index: stateIndex,
+            prev: prevState
+        };
+    }
+
+    function popState() {
+        stack.pop();
+        const value = stack.length > 0 ? stack[stack.length - 1] : rootValue;
+
+        // restore state
+        state = Array.isArray(value) ? printArray : printObject;
+        stateValue = value;
+        stateEmpty = false;
+        stateKeys = prevState.keys;
+        stateIndex = prevState.index;
+
+        // pop state
+        prevState = prevState.prev;
+    }
+};
Index: imaps-frontend/node_modules/@discoveryjs/json-ext/src/stringify-info.js
===================================================================
--- imaps-frontend/node_modules/@discoveryjs/json-ext/src/stringify-info.js	(revision 79a03170cdde4e801d12257ee86723774970427b)
+++ imaps-frontend/node_modules/@discoveryjs/json-ext/src/stringify-info.js	(revision 79a03170cdde4e801d12257ee86723774970427b)
@@ -0,0 +1,247 @@
+import { normalizeStringifyOptions, replaceValue } from './utils.js';
+
+const hasOwn = typeof Object.hasOwn === 'function'
+    ? Object.hasOwn
+    : (object, key) => Object.hasOwnProperty.call(object, key);
+
+// https://tc39.es/ecma262/#table-json-single-character-escapes
+const escapableCharCodeSubstitution = { // JSON Single Character Escape Sequences
+    0x08: '\\b',
+    0x09: '\\t',
+    0x0a: '\\n',
+    0x0c: '\\f',
+    0x0d: '\\r',
+    0x22: '\\\"',
+    0x5c: '\\\\'
+};
+
+const charLength2048 = Uint8Array.from({ length: 2048 }, (_, code) => {
+    if (hasOwn(escapableCharCodeSubstitution, code)) {
+        return 2; // \X
+    }
+
+    if (code < 0x20) {
+        return 6; // \uXXXX
+    }
+
+    return code < 128 ? 1 : 2; // UTF8 bytes
+});
+
+function isLeadingSurrogate(code) {
+    return code >= 0xD800 && code <= 0xDBFF;
+}
+
+function isTrailingSurrogate(code) {
+    return code >= 0xDC00 && code <= 0xDFFF;
+}
+
+function stringLength(str) {
+    // Fast path to compute length when a string contains only characters encoded as single bytes
+    if (!/[^\x20\x21\x23-\x5B\x5D-\x7F]/.test(str)) {
+        return str.length + 2;
+    }
+
+    let len = 0;
+    let prevLeadingSurrogate = false;
+
+    for (let i = 0; i < str.length; i++) {
+        const code = str.charCodeAt(i);
+
+        if (code < 2048) {
+            len += charLength2048[code];
+        } else if (isLeadingSurrogate(code)) {
+            len += 6; // \uXXXX since no pair with trailing surrogate yet
+            prevLeadingSurrogate = true;
+            continue;
+        } else if (isTrailingSurrogate(code)) {
+            len = prevLeadingSurrogate
+                ? len - 2  // surrogate pair (4 bytes), since we calculate prev leading surrogate as 6 bytes, substruct 2 bytes
+                : len + 6; // \uXXXX
+        } else {
+            len += 3; // code >= 2048 is 3 bytes length for UTF8
+        }
+
+        prevLeadingSurrogate = false;
+    }
+
+    return len + 2; // +2 for quotes
+}
+
+// avoid producing a string from a number
+function intLength(num) {
+    let len = 0;
+
+    if (num < 0) {
+        len = 1;
+        num = -num;
+    }
+
+    if (num >= 1e9) {
+        len += 9;
+        num = (num - num % 1e9) / 1e9;
+    }
+
+    if (num >= 1e4) {
+        if (num >= 1e6) {
+            return len + (num >= 1e8
+                ? 9
+                : num >= 1e7 ? 8 : 7
+            );
+        }
+        return len + (num >= 1e5 ? 6 : 5);
+    }
+
+    return len + (num >= 1e2
+        ? num >= 1e3 ? 4 : 3
+        : num >= 10 ? 2 : 1
+    );
+};
+
+function primitiveLength(value) {
+    switch (typeof value) {
+        case 'string':
+            return stringLength(value);
+
+        case 'number':
+            return Number.isFinite(value)
+                ? Number.isInteger(value)
+                    ? intLength(value)
+                    : String(value).length
+                : 4 /* null */;
+
+        case 'boolean':
+            return value ? 4 /* true */ : 5 /* false */;
+
+        case 'undefined':
+        case 'object':
+            return 4; /* null */
+
+        default:
+            return 0;
+    }
+}
+
+export function stringifyInfo(value, ...args) {
+    const { replacer, getKeys, ...options } = normalizeStringifyOptions(...args);
+    const continueOnCircular = Boolean(options.continueOnCircular);
+    const space = options.space?.length || 0;
+
+    const keysLength = new Map();
+    const visited = new Map();
+    const circular = new Set();
+    const stack = [];
+    const root = { '': value };
+    let stop = false;
+    let bytes = 0;
+    let spaceBytes = 0;
+    let objects = 0;
+
+    walk(root, '', value);
+
+    // when value is undefined or replaced for undefined
+    if (bytes === 0) {
+        bytes += 9; // FIXME: that's the length of undefined, should we normalize behaviour to convert it to null?
+    }
+
+    return {
+        bytes: isNaN(bytes) ? Infinity : bytes + spaceBytes,
+        spaceBytes: space > 0 && isNaN(bytes) ? Infinity : spaceBytes,
+        circular: [...circular]
+    };
+
+    function walk(holder, key, value) {
+        if (stop) {
+            return;
+        }
+
+        value = replaceValue(holder, key, value, replacer);
+
+        if (value === null || typeof value !== 'object') {
+            // primitive
+            if (value !== undefined || Array.isArray(holder)) {
+                bytes += primitiveLength(value);
+            }
+        } else {
+            // check for circular references
+            if (stack.includes(value)) {
+                circular.add(value);
+                bytes += 4; // treat as null
+
+                if (!continueOnCircular) {
+                    stop = true;
+                }
+
+                return;
+            }
+
+            // Using 'visited' allows avoiding hang-ups in cases of highly interconnected object graphs;
+            // for example, a list of git commits with references to parents can lead to N^2 complexity for traversal,
+            // and N when 'visited' is used
+            if (visited.has(value)) {
+                bytes += visited.get(value);
+
+                return;
+            }
+
+            objects++;
+
+            const prevObjects = objects;
+            const valueBytes = bytes;
+            let valueLength = 0;
+
+            stack.push(value);
+
+            if (Array.isArray(value)) {
+                // array
+                valueLength = value.length;
+
+                for (let i = 0; i < valueLength; i++) {
+                    walk(value, i, value[i]);
+                }
+            } else {
+                // object
+                let prevLength = bytes;
+
+                for (const key of getKeys(value)) {
+                    walk(value, key, value[key]);
+
+                    if (prevLength !== bytes) {
+                        let keyLen = keysLength.get(key);
+
+                        if (keyLen === undefined) {
+                            keysLength.set(key, keyLen = stringLength(key) + 1); // "key":
+                        }
+
+                        // value is printed
+                        bytes += keyLen;
+                        valueLength++;
+                        prevLength = bytes;
+                    }
+                }
+            }
+
+            bytes += valueLength === 0
+                ? 2 // {} or []
+                : 1 + valueLength; // {} or [] + commas
+
+            if (space > 0 && valueLength > 0) {
+                spaceBytes +=
+                    // a space between ":" and a value for each object entry
+                    (Array.isArray(value) ? 0 : valueLength) +
+                    // the formula results from folding the following components:
+                    // - for each key-value or element: ident + newline
+                    //   (1 + stack.length * space) * valueLength
+                    // - ident (one space less) before "}" or "]" + newline
+                    //   (stack.length - 1) * space + 1
+                    (1 + stack.length * space) * (valueLength + 1) - space;
+            }
+
+            stack.pop();
+
+            // add to 'visited' only objects that contain nested objects
+            if (prevObjects !== objects) {
+                visited.set(value, bytes - valueBytes);
+            }
+        }
+    }
+};
Index: imaps-frontend/node_modules/@discoveryjs/json-ext/src/utils.js
===================================================================
--- imaps-frontend/node_modules/@discoveryjs/json-ext/src/utils.js	(revision 79a03170cdde4e801d12257ee86723774970427b)
+++ imaps-frontend/node_modules/@discoveryjs/json-ext/src/utils.js	(revision 79a03170cdde4e801d12257ee86723774970427b)
@@ -0,0 +1,100 @@
+export function isIterable(value) {
+    return (
+        typeof value === 'object' &&
+        value !== null &&
+        (
+            typeof value[Symbol.iterator] === 'function' ||
+            typeof value[Symbol.asyncIterator] === 'function'
+        )
+    );
+}
+
+export function replaceValue(holder, key, value, replacer) {
+    if (value && typeof value.toJSON === 'function') {
+        value = value.toJSON();
+    }
+
+    if (replacer !== null) {
+        value = replacer.call(holder, String(key), value);
+    }
+
+    switch (typeof value) {
+        case 'function':
+        case 'symbol':
+            value = undefined;
+            break;
+
+        case 'object':
+            if (value !== null) {
+                const cls = value.constructor;
+                if (cls === String || cls === Number || cls === Boolean) {
+                    value = value.valueOf();
+                }
+            }
+            break;
+    }
+
+    return value;
+}
+
+export function normalizeReplacer(replacer) {
+    if (typeof replacer === 'function') {
+        return replacer;
+    }
+
+    if (Array.isArray(replacer)) {
+        const allowlist = new Set(replacer
+            .map(item => {
+                const cls = item && item.constructor;
+                return cls === String || cls === Number ? String(item) : null;
+            })
+            .filter(item => typeof item === 'string')
+        );
+
+        return [...allowlist];
+    }
+
+    return null;
+}
+
+export function normalizeSpace(space) {
+    if (typeof space === 'number') {
+        if (!Number.isFinite(space) || space < 1) {
+            return false;
+        }
+
+        return ' '.repeat(Math.min(space, 10));
+    }
+
+    if (typeof space === 'string') {
+        return space.slice(0, 10) || false;
+    }
+
+    return false;
+}
+
+export function normalizeStringifyOptions(optionsOrReplacer, space) {
+    if (optionsOrReplacer === null || Array.isArray(optionsOrReplacer) || typeof optionsOrReplacer !== 'object') {
+        optionsOrReplacer = {
+            replacer: optionsOrReplacer,
+            space
+        };
+    }
+
+    let replacer = normalizeReplacer(optionsOrReplacer.replacer);
+    let getKeys = Object.keys;
+
+    if (Array.isArray(replacer)) {
+        const allowlist = replacer;
+
+        getKeys = () => allowlist;
+        replacer = null;
+    }
+
+    return {
+        ...optionsOrReplacer,
+        replacer,
+        getKeys,
+        space: normalizeSpace(optionsOrReplacer.space)
+    };
+}
Index: imaps-frontend/node_modules/@discoveryjs/json-ext/src/web-streams.js
===================================================================
--- imaps-frontend/node_modules/@discoveryjs/json-ext/src/web-streams.js	(revision 79a03170cdde4e801d12257ee86723774970427b)
+++ imaps-frontend/node_modules/@discoveryjs/json-ext/src/web-streams.js	(revision 79a03170cdde4e801d12257ee86723774970427b)
@@ -0,0 +1,54 @@
+/* eslint-env browser */
+import { parseChunked } from './parse-chunked.js';
+import { stringifyChunked } from './stringify-chunked.js';
+import { isIterable } from './utils.js';
+
+export function parseFromWebStream(stream) {
+    // 2024/6/17: currently, an @@asyncIterator on a ReadableStream is not widely supported,
+    // therefore use a fallback using a reader
+    // https://caniuse.com/mdn-api_readablestream_--asynciterator
+    return parseChunked(isIterable(stream) ? stream : async function*() {
+        const reader = stream.getReader();
+
+        try {
+            while (true) {
+                const { value, done } = await reader.read();
+
+                if (done) {
+                    break;
+                }
+
+                yield value;
+            }
+        } finally {
+            reader.releaseLock();
+        }
+    });
+}
+
+export function createStringifyWebStream(value, replacer, space) {
+    // 2024/6/17: the ReadableStream.from() static method is supported
+    // in Node.js 20.6+ and Firefox only
+    if (typeof ReadableStream.from === 'function') {
+        return ReadableStream.from(stringifyChunked(value, replacer, space));
+    }
+
+    // emulate ReadableStream.from()
+    return new ReadableStream({
+        start() {
+            this.generator = stringifyChunked(value, replacer, space);
+        },
+        pull(controller) {
+            const { value, done } = this.generator.next();
+
+            if (done) {
+                controller.close();
+            } else {
+                controller.enqueue(value);
+            }
+        },
+        cancel() {
+            this.generator = null;
+        }
+    });
+};
