@speckle/objectloader2 2.25.4 → 2.25.8

package/src/queues/batchingQueue.test.ts

@@ -0,0 +1,149 @@
+import { describe, test, expect, vi } from 'vitest'
+import BatchingQueue from './batchingQueue.js'
+
+describe('BatchingQueue', () => {
+  test('should add items and process them in batches', async () => {
+    const processSpy = vi.fn()
+    const queue = new BatchingQueue({
+      batchSize: 2,
+      maxWaitTime: 100,
+      processFunction: async (batch: string[]): Promise<void> => {
+        await new Promise((resolve) => setTimeout(resolve, 0))
+        processSpy(batch)
+      }
+    })
+
+    try {
+      queue.add('key1', 'item1')
+      queue.add('key2', 'item2')
+
+      await new Promise((resolve) => setTimeout(resolve, 200))
+
+      expect(processSpy).toHaveBeenCalledTimes(1)
+      expect(processSpy).toHaveBeenCalledWith(['item1', 'item2'])
+    } finally {
+      await queue.disposeAsync()
+    }
+  })
+
+  test('should process items after timeout if batch size is not reached', async () => {
+    const processSpy = vi.fn()
+    const queue = new BatchingQueue({
+      batchSize: 5,
+      maxWaitTime: 100,
+      processFunction: async (batch: string[]): Promise<void> => {
+        await new Promise((resolve) => setTimeout(resolve, 0))
+        processSpy(batch)
+      }
+    })
+
+    try {
+      queue.add('key1', 'item1')
+      queue.add('key2', 'item2')
+
+      await new Promise((resolve) => setTimeout(resolve, 200))
+
+      expect(processSpy).toHaveBeenCalledTimes(1)
+      expect(processSpy).toHaveBeenCalledWith(['item1', 'item2'])
+    } finally {
+      await queue.disposeAsync()
+    }
+  })
+
+  test('should handle multiple batches correctly', async () => {
+    const processSpy = vi.fn()
+    const queue = new BatchingQueue({
+      batchSize: 2,
+      maxWaitTime: 100,
+      processFunction: async (batch: string[]): Promise<void> => {
+        await new Promise((resolve) => setTimeout(resolve, 0))
+        processSpy(batch)
+      }
+    })
+
+    try {
+      queue.add('key1', 'item1')
+      queue.add('key2', 'item2')
+      queue.add('key3', 'item3')
+      queue.add('key4', 'item4')
+
+      await new Promise((resolve) => setTimeout(resolve, 200))
+
+      expect(processSpy).toHaveBeenCalledTimes(2)
+      expect(processSpy).toHaveBeenCalledWith(['item1', 'item2'])
+      expect(processSpy).toHaveBeenCalledWith(['item3', 'item4'])
+    } finally {
+      await queue.disposeAsync()
+    }
+  })
+
+  test('should retrieve items by key', async () => {
+    const queue = new BatchingQueue<string>({
+      batchSize: 3,
+      maxWaitTime: 100,
+      processFunction: async (): Promise<void> => {
+        await new Promise((resolve) => setTimeout(resolve, 0))
+      }
+    })
+    try {
+      queue.add('key1', 'item1')
+      queue.add('key2', 'item2')
+
+      expect(queue.get('key1')).toBe('item1')
+      expect(queue.get('key2')).toBe('item2')
+      expect(queue.get('key3')).toBeUndefined()
+    } finally {
+      await queue.disposeAsync()
+    }
+  })
+
+  test('should return correct count of items', async () => {
+    const queue = new BatchingQueue<string>({
+      batchSize: 3,
+      maxWaitTime: 100,
+      processFunction: async (): Promise<void> => {
+        await new Promise((resolve) => setTimeout(resolve, 0))
+      }
+    })
+    try {
+      expect(queue.count()).toBe(0)
+
+      queue.add('key1', 'item1')
+      queue.add('key2', 'item2')
+
+      expect(queue.count()).toBe(2)
+    } finally {
+      await queue.disposeAsync()
+    }
+  })
+
+  test('should not process items if already processing', async () => {
+    const processSpy = vi.fn()
+    const queue = new BatchingQueue({
+      batchSize: 2,
+      maxWaitTime: 100,
+      processFunction: async (batch: string[]): Promise<void> => {
+        processSpy(batch)
+        await new Promise((resolve) => setTimeout(resolve, 300))
+      }
+    })
+
+    try {
+      queue.add('key1', 'item1')
+      queue.add('key2', 'item2')
+      queue.add('key3', 'item3')
+
+      await new Promise((resolve) => setTimeout(resolve, 200))
+
+      expect(processSpy).toHaveBeenCalledTimes(1)
+      expect(processSpy).toHaveBeenCalledWith(['item1', 'item2'])
+
+      await new Promise((resolve) => setTimeout(resolve, 500))
+
+      expect(processSpy).toHaveBeenCalledTimes(2)
+      expect(processSpy).toHaveBeenCalledWith(['item3'])
+    } finally {
+      await queue.disposeAsync()
+    }
+  })
+})

package/src/queues/batchingQueue.ts

@@ -0,0 +1,138 @@
+import { CustomLogger } from '../types/functions.js'
+import KeyedQueue from './keyedQueue.js'
+
+/**
+ * Default wait time in milliseconds for processing ongoing tasks during disposal.
+ * This value was chosen to balance responsiveness and CPU usage in typical scenarios.
+ */
+const PROCESSING_WAIT_TIME_MS = 100
+
+export default class BatchingQueue<T> {
+  #queue: KeyedQueue<string, T> = new KeyedQueue<string, T>()
+  #batchSize: number
+  #processFunction: (batch: T[]) => Promise<void>
+  #timeoutId: ReturnType<typeof setTimeout> | null = null
+  #isProcessing = false
+  #logger: CustomLogger
+
+  #disposed = false
+  #batchTimeout: number
+
+  // Helper methods for cross-environment timeout handling
+  #getSetTimeoutFn(): typeof setTimeout {
+    // First check for window object (browser), then fallback to global (node), then just use setTimeout
+    return typeof window !== 'undefined'
+      ? window.setTimeout.bind(window)
+      : typeof global !== 'undefined'
+      ? global.setTimeout
+      : setTimeout
+  }
+
+  #getClearTimeoutFn(): typeof clearTimeout {
+    // First check for window object (browser), then fallback to global (node), then just use clearTimeout
+    return typeof window !== 'undefined'
+      ? window.clearTimeout.bind(window)
+      : typeof global !== 'undefined'
+      ? global.clearTimeout
+      : clearTimeout
+  }
+
+  constructor(params: {
+    batchSize: number
+    maxWaitTime: number
+    processFunction: (batch: T[]) => Promise<void>
+    logger?: CustomLogger
+  }) {
+    this.#batchSize = params.batchSize
+    this.#processFunction = params.processFunction
+    this.#batchTimeout = params.maxWaitTime
+    this.#logger = params.logger || ((): void => {})
+  }
+
+  async disposeAsync(): Promise<void> {
+    this.#disposed = true
+    if (this.#timeoutId) {
+      this.#getClearTimeoutFn()(this.#timeoutId)
+      this.#timeoutId = null
+    }
+
+    // Wait for any ongoing processing to finish
+    while (this.#isProcessing) {
+      await new Promise((resolve) =>
+        this.#getSetTimeoutFn()(resolve, PROCESSING_WAIT_TIME_MS)
+      )
+    }
+
+    // After any ongoing flush is completed, there might be items in the queue.
+    // We should flush them.
+    if (this.#queue.size > 0) {
+      await this.#flush()
+    }
+  }
+
+  add(key: string, item: T): void {
+    if (this.#disposed) return
+    this.#queue.enqueue(key, item)
+    this.#addCheck()
+  }
+
+  addAll(keys: string[], items: T[]): void {
+    if (this.#disposed) return
+    this.#queue.enqueueAll(keys, items)
+    this.#addCheck()
+  }
+
+  #addCheck(): void {
+    if (this.#disposed) return
+    if (this.#queue.size >= this.#batchSize) {
+      // Fire and forget, no need to await
+      // eslint-disable-next-line @typescript-eslint/no-floating-promises
+      this.#flush()
+    } else {
+      if (this.#timeoutId) {
+        this.#getClearTimeoutFn()(this.#timeoutId)
+      }
+      // eslint-disable-next-line @typescript-eslint/no-misused-promises
+      this.#timeoutId = this.#getSetTimeoutFn()(() => this.#flush(), this.#batchTimeout)
+    }
+  }
+
+  async #flush(): Promise<void> {
+    if (this.#timeoutId) {
+      this.#getClearTimeoutFn()(this.#timeoutId)
+      this.#timeoutId = null
+    }
+
+    if (this.#isProcessing || this.#queue.size === 0) {
+      return
+    }
+    this.#isProcessing = true
+
+    const batchToProcess = this.#getBatch(this.#batchSize)
+
+    try {
+      await this.#processFunction(batchToProcess)
+    } catch (error) {
+      this.#logger('Batch processing failed:', error)
+    } finally {
+      this.#isProcessing = false
+    }
+    this.#addCheck()
+  }
+
+  get(id: string): T | undefined {
+    return this.#queue.get(id)
+  }
+
+  count(): number {
+    return this.#queue.size
+  }
+
+  isDisposed(): boolean {
+    return this.#disposed
+  }
+
+  #getBatch(batchSize: number): T[] {
+    return this.#queue.spliceValues(0, Math.min(batchSize, this.#queue.size))
+  }
+}

package/src/{helpers → queues}/bufferQueue.ts

@@ -9,4 +9,7 @@ export default class BufferQueue<T> implements Queue<T> {
   values(): T[] {
     return this.#buffer
   }
+  disposeAsync(): Promise<void> {
+    return Promise.resolve()
+  }
 }

package/src/{helpers → queues}/keyedQueue.ts

@@ -16,6 +16,18 @@ export default class KeyedQueue<K, V> {
     return true
   }
 
+  enqueueAll(keys: K[], values: V[]): number {
+    let count = 0
+    for (let i = 0; i < keys.length; i++) {
+      if (!this._map.has(keys[i])) {
+        this._map.set(keys[i], values[i])
+        this._order.push(keys[i])
+        count++
+      }
+    }
+    return count
+  }
+
   get(key: K): V | undefined {
     return this._map.get(key)
   }

package/src/{helpers → queues}/queue.ts

@@ -1,3 +1,4 @@
 export default interface Queue<T> {
   add(value: T): void
+  disposeAsync(): Promise<void>
 }

package/src/test/e2e.spec.ts

@@ -1,8 +1,8 @@
 import { describe, test, expect } from 'vitest'
 import { IDBFactory, IDBKeyRange } from 'fake-indexeddb'
-import { Base } from '../types/types.js'
 import { TIME_MS } from '@speckle/shared'
-import { ObjectLoader2Factory } from '../operations/objectLoader2Factory.js'
+import { ObjectLoader2Factory } from '../core/objectLoader2Factory.js'
+import { Base } from '../types/types.js'
 
 describe('e2e', () => {
   test(
@@ -14,8 +14,10 @@ describe('e2e', () => {
         serverUrl: 'https://app.speckle.systems',
         streamId: 'da9e320dad',
         objectId: '31d10c0cea569a1e26809658ed27e281',
-        indexedDB: new IDBFactory(),
-        keyRange: IDBKeyRange
+        options: {
+          indexedDB: new IDBFactory(),
+          keyRange: IDBKeyRange
+        }
       })
 
       const getObjectPromise = loader.getObject({

package/src/types/functions.spec.ts

@@ -0,0 +1,155 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest'
+import {
+  isBase,
+  isReference,
+  isScalar,
+  take,
+  getFeatureFlag,
+  ObjectLoader2Flags
+} from './functions.js'
+
+describe('isBase', () => {
+  it('should return true for valid Base objects', () => {
+    expect(isBase({ id: '123', speckle_type: 'Base' })).toBe(true)
+  })
+
+  it('should return false for objects without an id', () => {
+    expect(isBase({ speckle_type: 'Base' })).toBe(false)
+  })
+
+  it('should return false for objects with a non-string id', () => {
+    expect(isBase({ id: 123, speckle_type: 'Base' })).toBe(false)
+  })
+
+  it('should return false for null or undefined', () => {
+    expect(isBase(null)).toBe(false)
+    expect(isBase(undefined)).toBe(false)
+  })
+
+  it('should return false for non-objects', () => {
+    expect(isBase('a string')).toBe(false)
+    expect(isBase(123)).toBe(false)
+  })
+})
+
+describe('isReference', () => {
+  it('should return true for valid Reference objects', () => {
+    expect(isReference({ referencedId: '456' })).toBe(true)
+  })
+
+  it('should return false for objects without a referencedId', () => {
+    expect(isReference({ id: '456' })).toBe(false)
+  })
+
+  it('should return false for objects with a non-string referencedId', () => {
+    expect(isReference({ referencedId: 456 })).toBe(false)
+  })
+
+  it('should return false for null or undefined', () => {
+    expect(isReference(null)).toBe(false)
+    expect(isReference(undefined)).toBe(false)
+  })
+
+  it('should return false for non-objects', () => {
+    expect(isReference('a string')).toBe(false)
+    expect(isReference(123)).toBe(false)
+  })
+})
+
+describe('isScalar', () => {
+  it('should return true for scalar values', () => {
+    expect(isScalar('hello')).toBe(true)
+    expect(isScalar(123)).toBe(true)
+    expect(isScalar(true)).toBe(true)
+    expect(isScalar(BigInt(9007199254740991))).toBe(true)
+    expect(isScalar(Symbol('id'))).toBe(true)
+    expect(isScalar(undefined)).toBe(true)
+    expect(isScalar(null)).toBe(true)
+  })
+
+  it('should return false for non-scalar values', () => {
+    expect(isScalar({})).toBe(false)
+    expect(isScalar([])).toBe(false)
+    expect(isScalar(() => {})).toBe(false)
+  })
+})
+
+describe('take', () => {
+  it('should take the specified number of items from an iterator', () => {
+    const arr = [1, 2, 3, 4, 5]
+    const iterator = arr[Symbol.iterator]()
+    expect(take(iterator, 3)).toEqual([1, 2, 3])
+  })
+
+  it('should take all items if count is larger than the number of items', () => {
+    const arr = [1, 2]
+    const iterator = arr[Symbol.iterator]()
+    expect(take(iterator, 5)).toEqual([1, 2])
+  })
+
+  it('should take no items if count is 0', () => {
+    const arr = [1, 2, 3]
+    const iterator = arr[Symbol.iterator]()
+    expect(take(iterator, 0)).toEqual([])
+  })
+
+  it('should work with an empty iterator', () => {
+    const arr: number[] = []
+    const iterator = arr[Symbol.iterator]()
+    expect(take(iterator, 3)).toEqual([])
+  })
+})
+
+describe('getFeatureFlag', () => {
+  describe('in a non-browser environment', () => {
+    it('should return the default value', () => {
+      expect(getFeatureFlag(ObjectLoader2Flags.USE_CACHE)).toBe('true')
+    })
+
+    it('should return undefined when useDefault is false', () => {
+      expect(getFeatureFlag(ObjectLoader2Flags.USE_CACHE, false)).toBe(undefined)
+    })
+  })
+
+  describe('in a browser environment', () => {
+    const mockWindow = {
+      document: {},
+      location: {
+        search: ''
+      }
+    }
+
+    beforeEach(() => {
+      vi.stubGlobal('window', mockWindow)
+    })
+
+    afterEach(() => {
+      vi.unstubAllGlobals()
+    })
+
+    it('should return the parameter value from the URL', () => {
+      mockWindow.location.search = '?debug=value'
+      expect(getFeatureFlag(ObjectLoader2Flags.DEBUG)).toBe('value')
+    })
+
+    it('should return the default value if the parameter is not in the URL', () => {
+      mockWindow.location.search = '?otherparam=value'
+      expect(getFeatureFlag(ObjectLoader2Flags.DEBUG)).toBe('false')
+    })
+
+    it('should return the default value if the URL has no query string', () => {
+      mockWindow.location.search = ''
+      expect(getFeatureFlag(ObjectLoader2Flags.DEBUG)).toBe('false')
+    })
+
+    it('should return undefined if useDefault is false and parameter is not in URL', () => {
+      mockWindow.location.search = '?otherparam=value'
+      expect(getFeatureFlag(ObjectLoader2Flags.DEBUG, false)).toBe(undefined)
+    })
+
+    it('should still return the parameter value from URL when useDefault is false', () => {
+      mockWindow.location.search = '?debug=custom'
+      expect(getFeatureFlag(ObjectLoader2Flags.DEBUG, false)).toBe('custom')
+    })
+  })
+})

package/src/types/functions.ts

@@ -0,0 +1,118 @@
+import { Base, Reference } from './types.js'
+
+export type CustomLogger = (message?: string, ...optionalParams: unknown[]) => void
+
+export type Fetcher = (
+  input: string | URL | Request,
+  init?: RequestInit
+) => Promise<Response>
+
+export function isBase(maybeBase?: unknown): maybeBase is Base {
+  return (
+    maybeBase !== null &&
+    typeof maybeBase === 'object' &&
+    'id' in maybeBase &&
+    typeof maybeBase.id === 'string'
+  )
+}
+
+export function isReference(maybeRef?: unknown): maybeRef is Reference {
+  return (
+    maybeRef !== null &&
+    typeof maybeRef === 'object' &&
+    'referencedId' in maybeRef &&
+    typeof maybeRef.referencedId === 'string'
+  )
+}
+
+export function isScalar(
+  value: unknown
+): value is string | number | boolean | bigint | symbol | undefined {
+  const type = typeof value
+  return (
+    value === null ||
+    type === 'string' ||
+    type === 'number' ||
+    type === 'boolean' ||
+    type === 'bigint' ||
+    type === 'symbol' ||
+    type === 'undefined'
+  )
+}
+
+export function take<T>(it: Iterator<T>, count: number): T[] {
+  const result: T[] = []
+  for (let i = 0; i < count; i++) {
+    const itr = it.next()
+    if (itr.done) break
+    result.push(itr.value)
+  }
+  return result
+}
+
+export enum ObjectLoader2Flags {
+  DEBUG = 'debug',
+  USE_CACHE = 'useCache'
+}
+
+const defaultValues: Record<ObjectLoader2Flags, string> = {
+  [ObjectLoader2Flags.DEBUG]: 'false',
+  [ObjectLoader2Flags.USE_CACHE]: 'true'
+}
+
+export function getFeatureFlag(
+  paramName: ObjectLoader2Flags,
+  useDefault: boolean = true
+): string | undefined {
+  // Check if the code is running in a browser environment 🌐
+  const isBrowser =
+    typeof window !== 'undefined' && typeof window.document !== 'undefined'
+
+  if (!isBrowser) {
+    // If in Node.js or another server environment, return the default
+    return useDefault ? defaultValues[paramName] : undefined
+  }
+
+  // In a browser, parse the query string
+  const params = new URLSearchParams(window.location.search)
+
+  // .get() returns the value, or null if it's not found.
+  // The nullish coalescing operator (??) provides the default value
+  // if the left-hand side is null or undefined.
+  return params.get(paramName) ?? (useDefault ? defaultValues[paramName] : undefined)
+}
+
+/**
+ * Finds the first index of a "needle" Uint8Array within a "haystack" Uint8Array.
+ * @param haystack The larger array to search within.
+ * @param needle The smaller array to search for.
+ * @param start The index to start searching from. Defaults to 0.
+ * @returns The starting index of the needle, or -1 if not found.
+ */
+export function indexOf(
+  haystack: Uint8Array,
+  needle: Uint8Array,
+  start: number = 0
+): number {
+  if (needle.length === 0) {
+    return 0
+  }
+
+  // The last possible starting position for a match
+  const limit = haystack.length - needle.length
+
+  for (let i = start; i <= limit; i++) {
+    let foundMatch = true
+    for (let j = 0; j < needle.length; j++) {
+      if (haystack[i + j] !== needle[j]) {
+        foundMatch = false
+        break // Mismatch, break inner loop
+      }
+    }
+    if (foundMatch) {
+      return i // Found a full match at index i
+    }
+  }
+
+  return -1 // No match found
+}

package/src/types/types.ts

@@ -1,13 +1,6 @@
-export type CustomLogger = (message?: string, ...optionalParams: unknown[]) => void
-
-export type Fetcher = (
-  input: string | URL | Request,
-  init?: RequestInit
-) => Promise<Response>
-
 export interface Item {
   baseId: string
-  base: Base
+  base?: Base
   size?: number
 }
 
@@ -26,46 +19,3 @@ export interface Reference {
 export interface DataChunk extends Base {
   data?: Base[]
 }
-
-export function isBase(maybeBase?: unknown): maybeBase is Base {
-  return (
-    maybeBase !== null &&
-    typeof maybeBase === 'object' &&
-    'id' in maybeBase &&
-    typeof maybeBase.id === 'string'
-  )
-}
-
-export function isReference(maybeRef?: unknown): maybeRef is Reference {
-  return (
-    maybeRef !== null &&
-    typeof maybeRef === 'object' &&
-    'referencedId' in maybeRef &&
-    typeof maybeRef.referencedId === 'string'
-  )
-}
-
-export function isScalar(
-  value: unknown
-): value is string | number | boolean | bigint | symbol | undefined {
-  const type = typeof value
-  return (
-    value === null ||
-    type === 'string' ||
-    type === 'number' ||
-    type === 'boolean' ||
-    type === 'bigint' ||
-    type === 'symbol' ||
-    type === 'undefined'
-  )
-}
-
-export function take<T>(it: Iterator<T>, count: number): T[] {
-  const result: T[] = []
-  for (let i = 0; i < count; i++) {
-    const itr = it.next()
-    if (itr.done) break
-    result.push(itr.value)
-  }
-  return result
-}

package/dist/commonjs/helpers/aggregateQueue.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"aggregateQueue.d.ts","sourceRoot":"","sources":["../../../src/helpers/aggregateQueue.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,YAAY,CAAA;AAE9B,MAAM,CAAC,OAAO,OAAO,cAAc,CAAC,CAAC,CAAE,YAAW,KAAK,CAAC,CAAC,CAAC;;gBAI5C,MAAM,EAAE,KAAK,CAAC,CAAC,CAAC,EAAE,MAAM,EAAE,KAAK,CAAC,CAAC,CAAC;IAK9C,GAAG,CAAC,KAAK,EAAE,CAAC,GAAG,IAAI;IAKnB,MAAM,IAAI,CAAC,EAAE;CAGd"}

package/dist/commonjs/helpers/aggregateQueue.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"aggregateQueue.js","sourceRoot":"","sources":["../../../src/helpers/aggregateQueue.ts"],"names":[],"mappings":";;AAEA,MAAqB,cAAc;IACjC,OAAO,CAAU;IACjB,OAAO,CAAU;IAEjB,YAAY,MAAgB,EAAE,MAAgB;QAC5C,IAAI,CAAC,OAAO,GAAG,MAAM,CAAA;QACrB,IAAI,CAAC,OAAO,GAAG,MAAM,CAAA;IACvB,CAAC;IAED,GAAG,CAAC,KAAQ;QACV,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,KAAK,CAAC,CAAA;QACvB,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,KAAK,CAAC,CAAA;IACzB,CAAC;IAED,MAAM;QACJ,MAAM,IAAI,KAAK,CAAC,iBAAiB,CAAC,CAAA;IACpC,CAAC;CACF;AAjBD,iCAiBC"}

package/dist/commonjs/helpers/asyncGeneratorQueue.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"asyncGeneratorQueue.d.ts","sourceRoot":"","sources":["../../../src/helpers/asyncGeneratorQueue.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,YAAY,CAAA;AAE9B,MAAM,CAAC,OAAO,OAAO,mBAAmB,CAAC,CAAC,CAAE,YAAW,KAAK,CAAC,CAAC,CAAC;;IAK7D,GAAG,CAAC,KAAK,EAAE,CAAC,GAAG,IAAI;IAWZ,OAAO,IAAI,cAAc,CAAC,CAAC,CAAC;IAanC,OAAO,IAAI,IAAI;CAGhB"}

package/dist/commonjs/helpers/asyncGeneratorQueue.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"asyncGeneratorQueue.js","sourceRoot":"","sources":["../../../src/helpers/asyncGeneratorQueue.ts"],"names":[],"mappings":";;AAEA,MAAqB,mBAAmB;IACtC,OAAO,GAAQ,EAAE,CAAA;IACjB,aAAa,GAA2B,EAAE,CAAA;IAC1C,SAAS,GAAG,KAAK,CAAA;IAEjB,GAAG,CAAC,KAAQ;QACV,IAAI,IAAI,CAAC,aAAa,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;YAClC,qDAAqD;YACrD,MAAM,OAAO,GAAG,IAAI,CAAC,aAAa,CAAC,KAAK,EAAG,CAAA;YAC3C,OAAO,CAAC,KAAK,CAAC,CAAA;QAChB,CAAC;aAAM,CAAC;YACN,+BAA+B;YAC/B,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,CAAA;QAC1B,CAAC;IACH,CAAC;IAED,KAAK,CAAC,CAAC,OAAO;QACZ,OACE,CAAC,IAAI,CAAC,SAAS;YACf,IAAI,CAAC,aAAa,CAAC,MAAM,GAAG,CAAC;YAC7B,IAAI,CAAC,OAAO,CAAC,MAAM,GAAG,CAAC,EACvB,CAAC;YACD,IAAI,IAAI,CAAC,OAAO,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;gBAC5B,MAAM,IAAI,CAAC,OAAO,CAAC,KAAK,EAAG,CAAA,CAAC,yBAAyB;YACvD,CAAC;iBAAM,CAAC;gBACN,MAAM,MAAM,IAAI,OAAO,CAAI,CAAC,OAAO,EAAE,EAAE,CAAC,IAAI,CAAC,aAAa,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC,CAAA;YAC3E,CAAC;QACH,CAAC;IACH,CAAC;IACD,OAAO;QACL,IAAI,CAAC,SAAS,GAAG,IAAI,CAAA;IACvB,CAAC;CACF;AAhCD,sCAgCC"}