ima2-gen 3.20.0 → 3.21.0

package/node_modules/eventsource-parser/src/parse.ts

@@ -1,395 +0,0 @@
-/**
- * EventSource/Server-Sent Events parser
- * @see https://html.spec.whatwg.org/multipage/server-sent-events.html
- */
-import {ParseError} from './errors.ts'
-import type {EventSourceParser, ParserCallbacks} from './types.ts'
-
-// ASCII codes used in the hot parsing paths.
-const LF = 10
-const CR = 13
-const SPACE = 32
-
-// oxlint-disable-next-line no-unused-vars
-function noop(_arg: unknown) {
-  // intentional noop
-}
-
-/**
- * Creates a new EventSource parser.
- *
- * @param callbacks - Callbacks to invoke on different parsing events:
- *   - `onEvent` when a new event is parsed
- *   - `onError` when an error occurs
- *   - `onRetry` when a new reconnection interval has been sent from the server
- *   - `onComment` when a comment is encountered in the stream
- *
- * @returns A new EventSource parser, with `parse` and `reset` methods.
- * @public
- */
-export function createParser(callbacks: ParserCallbacks): EventSourceParser {
-  if (typeof callbacks === 'function') {
-    throw new TypeError(
-      '`callbacks` must be an object, got a function instead. Did you mean `{onEvent: fn}`?',
-    )
-  }
-
-  const {onEvent = noop, onError = noop, onRetry = noop, onComment} = callbacks
-
-  // Trailing bytes from prior `feed()` calls that did not yet form a complete line.
-  // Stored as an array of fragments and only joined when a line terminator arrives.
-  // Concatenating per-feed (`prefix + chunk`) is O(N²) when a single SSE line spans
-  // many chunks (e.g. a large `data:` payload streamed in tiny slices, or an MCP-style
-  // server that emits one giant content block). Buffering as fragments + joining once
-  // makes the same workload linear.
-  const pendingFragments: string[] = []
-
-  let isFirstChunk = true
-  let id: string | undefined
-  let data = ''
-  let dataLines = 0
-  let eventType: string | undefined
-
-  /**
-   * Feeds a chunk of the SSE stream to the parser. Any trailing bytes that do
-   * not yet form a complete line are held back and prepended to the next chunk,
-   * so callers can pass arbitrary slices of the stream without worrying about
-   * line boundaries.
-   *
-   * Per the SSE spec, a UTF-8 BOM (0xEF 0xBB 0xBF) at the start of the very
-   * first chunk is stripped before parsing.
-   *
-   * @see https://html.spec.whatwg.org/multipage/server-sent-events.html#parsing-an-event-stream
-   */
-  function feed(chunk: string) {
-    if (isFirstChunk) {
-      isFirstChunk = false
-      // Match and strip UTF-8 BOM from the start of the stream, if present.
-      // (Per the spec, this is only valid at the very start of the stream)
-      if (
-        chunk.charCodeAt(0) === 0xef &&
-        chunk.charCodeAt(1) === 0xbb &&
-        chunk.charCodeAt(2) === 0xbf
-      ) {
-        chunk = chunk.slice(3)
-      }
-    }
-
-    // Hot path: no buffered prefix from a prior partial line. Hand the chunk
-    // straight to `processLines`, exactly like the original implementation.
-    // Zero new work in the common case (every chunk ends with `\n\n`).
-    if (pendingFragments.length === 0) {
-      const trailing = processLines(chunk)
-      if (trailing !== '') pendingFragments.push(trailing)
-      return
-    }
-
-    // We have a buffered prefix. If this chunk also has no terminator, append
-    // to the buffer without concatenating — that's the O(N²) trap we're
-    // avoiding (large single `data:` payload split across many tiny chunks).
-    if (chunk.indexOf('\n') === -1 && chunk.indexOf('\r') === -1) {
-      pendingFragments.push(chunk)
-      return
-    }
-
-    // Terminator arrived. Join the accumulated fragments + this chunk once,
-    // process, and buffer any new trailing partial line.
-    pendingFragments.push(chunk)
-    const input = pendingFragments.join('')
-    pendingFragments.length = 0
-    const trailing = processLines(input)
-    if (trailing !== '') pendingFragments.push(trailing)
-  }
-
-  /**
-   * Splits `chunk` into SSE lines and dispatches each to the appropriate handler.
-   * Returns any trailing bytes that did not terminate with a line break, so the
-   * caller can prepend them to the next chunk.
-   *
-   * The SSE spec permits three line terminators: `\n`, `\r`, and `\r\n`. Real-world
-   * streams almost always use plain `\n`, so we take a fast path when no `\r` is
-   * present in the chunk. The slow path is spec-correct but does more work per line.
-   */
-  function processLines(chunk: string): string {
-    let searchIndex = 0
-
-    // Fast path: LF-only chunk (the common case for typical SSE servers).
-    // We can scan forward with a single `indexOf('\n')` per line and inline
-    // the hot-path branches for `data:` and `event:` without the CR bookkeeping
-    // the slow path needs.
-    if (chunk.indexOf('\r') === -1) {
-      let lfIndex = chunk.indexOf('\n', searchIndex)
-      while (lfIndex !== -1) {
-        // Blank line: end-of-event marker. Dispatch the accumulated event (if any)
-        // and reset the buffered fields. This is hoisted out of `parseLine` because
-        // it's the single most common line shape after `data:` lines.
-        if (searchIndex === lfIndex) {
-          if (dataLines > 0) {
-            onEvent({id, event: eventType, data})
-          }
-          id = undefined
-          data = ''
-          dataLines = 0
-          eventType = undefined
-          searchIndex = lfIndex + 1
-          lfIndex = chunk.indexOf('\n', searchIndex)
-          continue
-        }
-        const firstCharCode = chunk.charCodeAt(searchIndex)
-        if (isDataPrefix(chunk, searchIndex, firstCharCode)) {
-          // `data:` line — append the value to the event's data buffer.
-          // 'data:'.length === 5, 'data: '.length === 6
-          const valueStart =
-            chunk.charCodeAt(searchIndex + 5) === SPACE ? searchIndex + 6 : searchIndex + 5
-          const value = chunk.slice(valueStart, lfIndex)
-          // Fast path within a fast path: if this is the first data line AND the
-          // next char is another LF (i.e. `data:foo\n\n`), dispatch immediately
-          // without ever writing to the `data` buffer. This is the shape of a
-          // typical single-line SSE event (ChatGPT-style streams, etc.) and is
-          // hot enough to be worth the duplication.
-          if (dataLines === 0 && chunk.charCodeAt(lfIndex + 1) === LF) {
-            onEvent({id, event: eventType, data: value})
-            id = undefined
-            data = ''
-            eventType = undefined
-            searchIndex = lfIndex + 2
-            lfIndex = chunk.indexOf('\n', searchIndex)
-            continue
-          }
-          // Multi-line data: concatenate with newline separator per spec.
-          data = dataLines === 0 ? value : `${data}\n${value}`
-          dataLines++
-        } else if (isEventPrefix(chunk, searchIndex, firstCharCode)) {
-          // `event:` line — set the event type for the next dispatch. Per spec,
-          // an empty value resets `event type` to its default (undefined here).
-          // 'event:'.length === 6, 'event: '.length === 7
-          eventType =
-            chunk.slice(
-              chunk.charCodeAt(searchIndex + 6) === SPACE ? searchIndex + 7 : searchIndex + 6,
-              lfIndex,
-            ) || undefined
-        } else {
-          // Everything else: `id:`, `retry:`, comment lines (`:` prefix), unknown
-          // fields, or malformed lines. These are rarer and go through the full
-          // per-line parser, which handles the SSE field grammar in detail.
-          parseLine(chunk, searchIndex, lfIndex)
-        }
-        searchIndex = lfIndex + 1
-        lfIndex = chunk.indexOf('\n', searchIndex)
-      }
-      return chunk.slice(searchIndex)
-    }
-
-    // Slow path: the chunk contains at least one `\r`, so lines may be terminated
-    // by `\r`, `\n`, or `\r\n`. We locate the next terminator by looking at both
-    // the nearest `\r` and `\n` and picking whichever comes first.
-    while (searchIndex < chunk.length) {
-      const crIndex = chunk.indexOf('\r', searchIndex)
-      const lfIndex = chunk.indexOf('\n', searchIndex)
-
-      let lineEnd = -1
-      if (crIndex !== -1 && lfIndex !== -1) {
-        lineEnd = crIndex < lfIndex ? crIndex : lfIndex
-      } else if (crIndex !== -1) {
-        // A trailing `\r` at the very end of the chunk is ambiguous: it could be
-        // a bare-CR terminator, or the first half of a `\r\n` whose `\n` arrives
-        // in the next chunk. Defer until we see more input.
-        if (crIndex === chunk.length - 1) {
-          lineEnd = -1
-        } else {
-          lineEnd = crIndex
-        }
-      } else if (lfIndex !== -1) {
-        lineEnd = lfIndex
-      }
-
-      if (lineEnd === -1) {
-        break
-      }
-
-      parseLine(chunk, searchIndex, lineEnd)
-      searchIndex = lineEnd + 1
-      // If we just consumed a `\r` and the next char is `\n`, skip it so the
-      // pair is treated as a single terminator rather than an empty line.
-      if (chunk.charCodeAt(searchIndex - 1) === CR && chunk.charCodeAt(searchIndex) === LF) {
-        searchIndex++
-      }
-    }
-
-    return chunk.slice(searchIndex)
-  }
-
-  function parseLine(chunk: string, start: number, end: number) {
-    if (start === end) {
-      dispatchEvent()
-      return
-    }
-
-    const firstCharCode = chunk.charCodeAt(start)
-
-    if (isDataPrefix(chunk, start, firstCharCode)) {
-      // 'data:'.length === 5, 'data: '.length === 6
-      const valueStart = chunk.charCodeAt(start + 5) === SPACE ? start + 6 : start + 5
-      const value = chunk.slice(valueStart, end)
-      data = dataLines === 0 ? value : `${data}\n${value}`
-      dataLines++
-      return
-    }
-
-    if (isEventPrefix(chunk, start, firstCharCode)) {
-      // 'event:'.length === 6, 'event: '.length === 7
-      eventType =
-        chunk.slice(chunk.charCodeAt(start + 6) === SPACE ? start + 7 : start + 6, end) || undefined
-      return
-    }
-
-    // Fast path for "id:" — 'i' = 105, 'd' = 100, ':' = 58
-    if (
-      firstCharCode === 105 &&
-      chunk.charCodeAt(start + 1) === 100 &&
-      chunk.charCodeAt(start + 2) === 58
-    ) {
-      // 'id:'.length === 3, 'id: '.length === 4
-      const value = chunk.slice(chunk.charCodeAt(start + 3) === SPACE ? start + 4 : start + 3, end)
-      id = value.includes('\0') ? undefined : value
-      return
-    }
-
-    // Comment line — ':' = 58
-    if (firstCharCode === 58) {
-      if (onComment) {
-        const line = chunk.slice(start, end)
-        // skip ':' (+1), or ': ' (+2) when a space follows
-        onComment(line.slice(chunk.charCodeAt(start + 1) === SPACE ? 2 : 1))
-      }
-      return
-    }
-
-    const line = chunk.slice(start, end)
-    const fieldSeparatorIndex = line.indexOf(':')
-    if (fieldSeparatorIndex === -1) {
-      processField(line, '', line)
-      return
-    }
-
-    const field = line.slice(0, fieldSeparatorIndex)
-    // skip ':' (+1), or ': ' (+2) when a space follows
-    const offset = line.charCodeAt(fieldSeparatorIndex + 1) === SPACE ? 2 : 1
-    const value = line.slice(fieldSeparatorIndex + offset)
-    processField(field, value, line)
-  }
-
-  function processField(field: string, value: string, line: string) {
-    // Field names must be compared literally, with no case folding performed.
-    switch (field) {
-      case 'event':
-        // Set the `event type` buffer to field value
-        eventType = value || undefined
-        break
-      case 'data':
-        data = dataLines === 0 ? value : `${data}\n${value}`
-        dataLines++
-        break
-      case 'id':
-        // If the field value does not contain U+0000 NULL, then set the `ID` buffer to
-        // the field value. Otherwise, ignore the field.
-        id = value.includes('\0') ? undefined : value
-        break
-      case 'retry':
-        // If the field value consists of only ASCII digits, then interpret the field value as an
-        // integer in base ten, and set the event stream's reconnection time to that integer.
-        // Otherwise, ignore the field.
-        if (/^\d+$/.test(value)) {
-          onRetry(parseInt(value, 10))
-        } else {
-          onError(
-            new ParseError(`Invalid \`retry\` value: "${value}"`, {
-              type: 'invalid-retry',
-              value,
-              line,
-            }),
-          )
-        }
-        break
-      default:
-        // Otherwise, the field is ignored.
-        onError(
-          new ParseError(
-            `Unknown field "${field.length > 20 ? `${field.slice(0, 20)}…` : field}"`,
-            {type: 'unknown-field', field, value, line},
-          ),
-        )
-        break
-    }
-  }
-
-  function dispatchEvent() {
-    if (dataLines > 0) {
-      onEvent({
-        id,
-        event: eventType,
-        data,
-      })
-    }
-
-    id = undefined
-    data = ''
-    dataLines = 0
-    eventType = undefined
-  }
-
-  function reset(options: {consume?: boolean} = {}) {
-    if (options.consume && pendingFragments.length > 0) {
-      const incompleteLine = pendingFragments.join('')
-      parseLine(incompleteLine, 0, incompleteLine.length)
-    }
-
-    isFirstChunk = true
-    id = undefined
-    data = ''
-    dataLines = 0
-    eventType = undefined
-    pendingFragments.length = 0
-  }
-
-  return {feed, reset}
-}
-
-/**
- * Checks if `chunk` starts with the literal `data:` at index `i`.
- *
- * Equivalent to `chunk.startsWith('data:', i)`, but benchmarks show this
- * hand-unrolled char-code comparison is ~20% faster on common event types.
- * The caller passes `firstCharCode` (the code at `i`) so it can be reused
- * across prefix checks.
- *
- * ASCII: 'd' = 100, 'a' = 97, 't' = 116, 'a' = 97, ':' = 58
- */
-function isDataPrefix(chunk: string, i: number, firstCharCode: number): boolean {
-  return (
-    firstCharCode === 100 &&
-    chunk.charCodeAt(i + 1) === 97 &&
-    chunk.charCodeAt(i + 2) === 116 &&
-    chunk.charCodeAt(i + 3) === 97 &&
-    chunk.charCodeAt(i + 4) === 58
-  )
-}
-
-/**
- * Checks if `chunk` starts with the literal `event:` at index `i`.
- *
- * See {@link isDataPrefix} for why this is hand-unrolled rather than using
- * `String.prototype.startsWith`.
- *
- * ASCII: 'e' = 101, 'v' = 118, 'e' = 101, 'n' = 110, 't' = 116, ':' = 58
- */
-function isEventPrefix(chunk: string, i: number, firstCharCode: number): boolean {
-  return (
-    firstCharCode === 101 &&
-    chunk.charCodeAt(i + 1) === 118 &&
-    chunk.charCodeAt(i + 2) === 101 &&
-    chunk.charCodeAt(i + 3) === 110 &&
-    chunk.charCodeAt(i + 4) === 116 &&
-    chunk.charCodeAt(i + 5) === 58
-  )
-}

package/node_modules/eventsource-parser/src/stream.ts

@@ -1,88 +0,0 @@
-import {createParser} from './parse.ts'
-import type {EventSourceMessage, EventSourceParser} from './types.ts'
-
-/**
- * Options for the EventSourceParserStream.
- *
- * @public
- */
-export interface StreamOptions {
-  /**
-   * Behavior when a parsing error occurs.
-   *
-   * - A custom function can be provided to handle the error.
-   * - `'terminate'` will error the stream and stop parsing.
-   * - Any other value will ignore the error and continue parsing.
-   *
-   * @defaultValue `undefined`
-   */
-  onError?: ('terminate' | ((error: Error) => void)) | undefined
-
-  /**
-   * Callback for when a reconnection interval is sent from the server.
-   *
-   * @param retry - The number of milliseconds to wait before reconnecting.
-   */
-  onRetry?: ((retry: number) => void) | undefined
-
-  /**
-   * Callback for when a comment is encountered in the stream.
-   *
-   * @param comment - The comment encountered in the stream.
-   */
-  onComment?: ((comment: string) => void) | undefined
-}
-
-/**
- * A TransformStream that ingests a stream of strings and produces a stream of `EventSourceMessage`.
- *
- * @example Basic usage
- * ```
- * const eventStream =
- *   response.body
- *     .pipeThrough(new TextDecoderStream())
- *     .pipeThrough(new EventSourceParserStream())
- * ```
- *
- * @example Terminate stream on parsing errors
- * ```
- * const eventStream =
- *  response.body
- *   .pipeThrough(new TextDecoderStream())
- *   .pipeThrough(new EventSourceParserStream({terminateOnError: true}))
- * ```
- *
- * @public
- */
-export class EventSourceParserStream extends TransformStream<string, EventSourceMessage> {
-  constructor({onError, onRetry, onComment}: StreamOptions = {}) {
-    let parser!: EventSourceParser
-
-    super({
-      start(controller) {
-        parser = createParser({
-          onEvent: (event) => {
-            controller.enqueue(event)
-          },
-          onError(error) {
-            if (onError === 'terminate') {
-              controller.error(error)
-            } else if (typeof onError === 'function') {
-              onError(error)
-            }
-
-            // Ignore by default
-          },
-          onRetry,
-          onComment,
-        })
-      },
-      transform(chunk) {
-        parser.feed(chunk)
-      },
-    })
-  }
-}
-
-export {type ErrorType, ParseError} from './errors.ts'
-export type {EventSourceMessage} from './types.ts'

package/node_modules/eventsource-parser/src/types.ts

@@ -1,97 +0,0 @@
-import type {ParseError} from './errors.ts'
-
-/**
- * EventSource parser instance.
- *
- * Needs to be reset between reconnections/when switching data source, using the `reset()` method.
- *
- * @public
- */
-export interface EventSourceParser {
-  /**
-   * Feeds the parser another chunk. The method _does not_ return a parsed message.
-   * Instead, callbacks passed when creating the parser will be triggered once we see enough data
-   * for a valid/invalid parsing step (see {@link ParserCallbacks}).
-   *
-   * @param chunk - The chunk to parse. Can be a partial, eg in the case of streaming messages.
-   * @public
-   */
-  feed(chunk: string): void
-
-  /**
-   * Resets the parser state. This is required when you have a new stream of messages -
-   * for instance in the case of a client being disconnected and reconnecting.
-   *
-   * Previously received, incomplete data will NOT be parsed unless you pass `consume: true`,
-   * which tells the parser to attempt to consume any incomplete data as if it ended with a newline
-   * character. This is useful for cases when a server sends a non-EventSource message that you
-   * want to be able to react to in an `onError` callback.
-   *
-   * @public
-   */
-  reset(options?: {consume?: boolean}): void
-}
-
-/**
- * A parsed EventSource message event
- *
- * @public
- */
-export interface EventSourceMessage {
-  /**
-   * The event type sent from the server. Note that this differs from the browser `EventSource`
-   * implementation in that browsers will default this to `message`, whereas this parser will
-   * leave this as `undefined` if not explicitly declared.
-   */
-  event?: string | undefined
-
-  /**
-   * ID of the message, if any was provided by the server. Can be used by clients to keep the
-   * last received message ID in sync when reconnecting.
-   */
-  id?: string | undefined
-
-  /**
-   * The data received for this message
-   */
-  data: string
-}
-
-/**
- * Callbacks that can be passed to the parser to handle different types of parsed messages
- * and errors.
- *
- * @public
- */
-export interface ParserCallbacks {
-  /**
-   * Callback for when a new event/message is parsed from the stream.
-   * This is the main callback that clients will use to handle incoming messages.
-   *
-   * @param event - The parsed event/message
-   */
-  onEvent?: ((event: EventSourceMessage) => void) | undefined
-
-  /**
-   * Callback for when the server sends a new reconnection interval through the `retry` field.
-   *
-   * @param retry - The number of milliseconds to wait before reconnecting.
-   */
-  onRetry?: ((retry: number) => void) | undefined
-
-  /**
-   * Callback for when a comment is encountered in the stream.
-   *
-   * @param comment - The comment encountered in the stream.
-   */
-  onComment?: ((comment: string) => void) | undefined
-
-  /**
-   * Callback for when an error occurs during parsing. This is a catch-all for any errors
-   * that occur during parsing, and can be used to handle them in a custom way. Most clients
-   * tend to silently ignore any errors and instead retry, but it can be helpful to log/debug.
-   *
-   * @param error - The error that occurred during parsing
-   */
-  onError?: ((error: ParseError) => void) | undefined
-}

package/node_modules/eventsource-parser/stream.js

@@ -1,2 +0,0 @@
-/* included for compatibility with react-native without package exports support */
-module.exports = require('./dist/stream.cjs')

package/node_modules/get-caller-file/LICENSE.md

@@ -1,6 +0,0 @@
-ISC License (ISC)
-Copyright 2018 Stefan Penner
-
-Permission to use, copy, modify, and/or distribute this software for any purpose with or without fee is hereby granted, provided that the above copyright notice and this permission notice appear in all copies.
-
-THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

package/node_modules/get-caller-file/README.md

@@ -1,41 +0,0 @@
-# get-caller-file
-
-[![Build Status](https://travis-ci.org/stefanpenner/get-caller-file.svg?branch=master)](https://travis-ci.org/stefanpenner/get-caller-file)
-[![Build status](https://ci.appveyor.com/api/projects/status/ol2q94g1932cy14a/branch/master?svg=true)](https://ci.appveyor.com/project/embercli/get-caller-file/branch/master)
-
-This is a utility, which allows a function to figure out from which file it was invoked. It does so by inspecting v8's stack trace at the time it is invoked.
-
-Inspired by http://stackoverflow.com/questions/13227489
-
-*note: this relies on Node/V8 specific APIs, as such other runtimes may not work*
-
-## Installation
-
-```bash
-yarn add get-caller-file
-```
-
-## Usage
-
-Given:
-
-```js
-// ./foo.js
-const getCallerFile = require('get-caller-file');
-
-module.exports = function() {
-  return getCallerFile(); // figures out who called it
-};
-```
-
-```js
-// index.js
-const foo = require('./foo');
-
-foo() // => /full/path/to/this/file/index.js
-```
-
-
-## Options:
-
-* `getCallerFile(position = 2)`: where position is stack frame whos fileName we want.

package/node_modules/get-caller-file/index.d.ts

@@ -1,2 +0,0 @@
-declare const _default: (position?: number) => any;
-export = _default;

package/node_modules/get-caller-file/index.js

@@ -1,22 +0,0 @@
-"use strict";
-// Call this function in a another function to find out the file from
-// which that function was called from. (Inspects the v8 stack trace)
-//
-// Inspired by http://stackoverflow.com/questions/13227489
-module.exports = function getCallerFile(position) {
-    if (position === void 0) { position = 2; }
-    if (position >= Error.stackTraceLimit) {
-        throw new TypeError('getCallerFile(position) requires position be less then Error.stackTraceLimit but position was: `' + position + '` and Error.stackTraceLimit was: `' + Error.stackTraceLimit + '`');
-    }
-    var oldPrepareStackTrace = Error.prepareStackTrace;
-    Error.prepareStackTrace = function (_, stack) { return stack; };
-    var stack = new Error().stack;
-    Error.prepareStackTrace = oldPrepareStackTrace;
-    if (stack !== null && typeof stack === 'object') {
-        // stack[0] holds this file
-        // stack[1] holds where this function was called
-        // stack[2] holds the file we're interested in
-        return stack[position] ? stack[position].getFileName() : undefined;
-    }
-};
-//# sourceMappingURL=index.js.map

package/node_modules/get-caller-file/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["index.ts"],"names":[],"mappings":";AAAA,qEAAqE;AACrE,qEAAqE;AACrE,EAAE;AACF,0DAA0D;AAE1D,iBAAS,SAAS,aAAa,CAAC,QAAY;IAAZ,yBAAA,EAAA,YAAY;IAC1C,IAAI,QAAQ,IAAI,KAAK,CAAC,eAAe,EAAE;QACrC,MAAM,IAAI,SAAS,CAAC,kGAAkG,GAAG,QAAQ,GAAG,oCAAoC,GAAG,KAAK,CAAC,eAAe,GAAG,GAAG,CAAC,CAAC;KACzM;IAED,IAAM,oBAAoB,GAAG,KAAK,CAAC,iBAAiB,CAAC;IACrD,KAAK,CAAC,iBAAiB,GAAG,UAAC,CAAC,EAAE,KAAK,IAAM,OAAA,KAAK,EAAL,CAAK,CAAC;IAC/C,IAAM,KAAK,GAAG,IAAI,KAAK,EAAE,CAAC,KAAK,CAAC;IAChC,KAAK,CAAC,iBAAiB,GAAG,oBAAoB,CAAC;IAG/C,IAAI,KAAK,KAAK,IAAI,IAAI,OAAO,KAAK,KAAK,QAAQ,EAAE;QAC/C,2BAA2B;QAC3B,gDAAgD;QAChD,8CAA8C;QAC9C,OAAO,KAAK,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAE,KAAK,CAAC,QAAQ,CAAS,CAAC,WAAW,EAAE,CAAC,CAAC,CAAC,SAAS,CAAC;KAC7E;AACH,CAAC,CAAC"}