@helia/utils 2.5.2-070b7528 → 2.5.2-16d805e1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@helia/utils",
-  "version": "2.5.2-070b7528",
+  "version": "2.5.2-16d805e1",
   "description": "Shared code that implements the Helia API",
   "license": "Apache-2.0 OR MIT",
   "homepage": "https://github.com/ipfs/helia/tree/main/packages/utils#readme",
@@ -48,49 +48,30 @@
     "test:electron-main": "aegir test -t electron-main"
   },
   "dependencies": {
-    "@helia/interface": "6.2.1-070b7528",
-    "@ipld/dag-cbor": "^9.2.6",
-    "@ipld/dag-json": "^10.2.7",
-    "@ipld/dag-pb": "^4.1.5",
-    "@libp2p/interface": "^3.2.0",
-    "@libp2p/keychain": "^6.0.12",
-    "@libp2p/utils": "^7.0.15",
-    "@multiformats/dns": "^1.0.13",
-    "@multiformats/multiaddr": "^13.0.1",
-    "any-signal": "^4.2.0",
-    "blockstore-core": "^6.1.3",
-    "cborg": "^5.1.0",
-    "interface-blockstore": "^6.0.2",
-    "interface-datastore": "^9.0.3",
-    "interface-store": "^7.0.2",
-    "it-drain": "^3.0.12",
-    "it-filter": "^3.1.5",
-    "it-foreach": "^2.1.6",
-    "it-merge": "^3.0.13",
-    "it-to-buffer": "^4.0.12",
-    "libp2p": "^3.2.0",
-    "mortice": "^3.3.1",
-    "multiformats": "^13.4.2",
+    "@helia/interface": "6.2.1-16d805e1",
+    "@libp2p/interface": "^3.2.3",
+    "@libp2p/utils": "^7.2.2",
+    "@multiformats/multiaddr": "^13.0.3",
+    "it-filter": "^3.1.6",
+    "it-to-buffer": "^5.0.0",
+    "multiformats": "^14.0.0",
     "p-defer": "^4.0.1",
     "progress-events": "^1.1.0",
-    "race-signal": "^2.0.0",
-    "uint8arrays": "^5.1.0"
+    "race-signal": "^2.0.0"
   },
   "devDependencies": {
-    "@libp2p/crypto": "^5.1.15",
-    "@libp2p/logger": "^6.2.4",
-    "@libp2p/peer-id": "^6.0.6",
+    "@ipld/dag-cbor": "^10.0.1",
+    "@libp2p/crypto": "^5.1.19",
+    "@libp2p/logger": "^6.2.8",
+    "@libp2p/peer-id": "^6.0.10",
     "@types/sinon": "^21.0.1",
-    "aegir": "^48.0.4",
-    "datastore-core": "^11.0.3",
+    "aegir": "^48.0.11",
+    "blockstore-core": "^7.0.1",
     "delay": "^7.0.0",
+    "interface-blockstore": "^7.0.1",
     "it-all": "^3.0.11",
-    "it-map": "^3.1.5",
-    "sinon": "^22.0.0",
-    "sinon-ts": "^2.0.0"
-  },
-  "browser": {
-    "./dist/src/utils/libp2p-defaults.js": "./dist/src/utils/libp2p-defaults.browser.js"
+    "it-map": "^3.1.6",
+    "sinon": "^22.0.0"
   },
   "sideEffects": false
 }

package/src/abstract-session.ts

@@ -5,7 +5,7 @@ import { base64 } from 'multiformats/bases/base64'
 import pDefer from 'p-defer'
 import { raceSignal } from 'race-signal'
 import type { BlockBroker, BlockRetrievalOptions, CreateSessionOptions } from '@helia/interface'
-import type { AbortOptions, ComponentLogger, Logger, PeerId } from '@libp2p/interface'
+import type { AbortOptions, ComponentLogger, Logger } from '@libp2p/interface'
 import type { Filter } from '@libp2p/utils'
 import type { Multiaddr } from '@multiformats/multiaddr'
 import type { CID } from 'multiformats/cid'
@@ -41,7 +41,7 @@ export abstract class AbstractSession<Provider, RetrieveBlockProgressEvents exte
   private readonly maxProviders: number
   public readonly providers: Provider[]
   private readonly evictionFilter: Filter
-  private readonly initialProviders: Array<PeerId | Multiaddr | Multiaddr[]>
+  private readonly initialProviders: Array<CID | Multiaddr | Multiaddr[]>
   private readonly cidPeerFilterSize: number
 
   constructor (components: AbstractSessionComponents, init: AbstractCreateSessionOptions) {
@@ -277,7 +277,7 @@ export abstract class AbstractSession<Provider, RetrieveBlockProgressEvents exte
     return false
   }
 
-  async addPeer (peer: PeerId | Multiaddr | Multiaddr[], options?: AbortOptions): Promise<void> {
+  async addPeer (peer: CID | Multiaddr | Multiaddr[], options?: AbortOptions): Promise<void> {
     const provider = await this.convertToProvider(peer, 'manually-added', options)
 
     if (provider == null || this.hasProvider(provider)) {
@@ -379,7 +379,7 @@ export abstract class AbstractSession<Provider, RetrieveBlockProgressEvents exte
    * into the format required or return `undefined` if the provider is not
    * compatible with this session implementation
    */
-  abstract convertToProvider (provider: PeerId | Multiaddr | Multiaddr[], routing: string, options?: AbortOptions): Promise<Provider | undefined>
+  abstract convertToProvider (provider: CID | Multiaddr | Multiaddr[], routing: string, options?: AbortOptions): Promise<Provider | undefined>
 
   /**
    * This method should search for new providers and yield them.

package/src/errors.ts

@@ -32,3 +32,8 @@ export class BlockNotFoundWhileOfflineError extends Error {
   static name = 'BlockNotFoundWhileOfflineError'
   name = 'BlockNotFoundWhileOfflineError'
 }
+
+export class DecryptionFailedError extends Error {
+  static name = 'DecryptionFailedError'
+  name = 'DecryptionFailedError'
+}

package/src/graph-walker.ts

@@ -2,29 +2,17 @@ import { Queue } from '@libp2p/utils'
 import filter from 'it-filter'
 import toBuffer from 'it-to-buffer'
 import { createUnsafe } from 'multiformats/block'
-import type { CodecLoader } from '@helia/interface'
+import type {
+  GraphWalker,
+  GraphWalkerComponents,
+  GraphWalkerInit,
+  GraphNode,
+  WalkOptions
+} from '@helia/interface'
 import type { AbortOptions } from '@libp2p/interface'
-import type { Blockstore } from 'interface-blockstore'
-import type { BlockView, CID, Version } from 'multiformats'
+import type { CID } from 'multiformats'
 
-export interface GraphWalkerComponents {
-  blockstore: Blockstore
-  getCodec: CodecLoader
-}
-
-export interface GraphWalkerInit {
-
-}
-
-export interface GraphNode <T = unknown, C extends number = number, A extends number = number, V extends Version = 0 | 1> {
-  block: BlockView<T, C, A, V>
-  depth: number
-  path: CID[]
-}
-
-export interface GraphWalker {
-  walk <T = any> (cid: CID, options?: WalkOptions<T>): AsyncGenerator<GraphNode<T>>
-}
+export type { GraphWalker, GraphWalkerComponents, GraphWalkerInit, GraphNode, WalkOptions }
 
 /**
  * A depth-first walker descends into child blocks before processing successor
@@ -55,10 +43,6 @@ interface JobOptions extends AbortOptions {
   path: CID[]
 }
 
-export interface WalkOptions<T> extends AbortOptions {
-  includeChild?(child: CID, parent: BlockView<T, number, number, 0 | 1>): boolean
-}
-
 abstract class AbstractGraphWalker {
   private readonly components: GraphWalkerComponents
 
@@ -70,6 +54,7 @@ abstract class AbstractGraphWalker {
     const queue = this.getQueue()
     const gen = filter(queue.toGenerator(options), (node) => node != null) as AsyncGenerator<GraphNode<T>>
     let finished = false
+    const maxDepth = options?.depth ?? Infinity
 
     const job = async (opts: JobOptions): Promise<GraphNode<T> | undefined> => {
       const cid = opts.cid
@@ -80,25 +65,27 @@ abstract class AbstractGraphWalker {
         codec: await this.components.getCodec(cid.code)
       })
 
-      for (const [, linkedCid] of block.links()) {
-        if (options?.includeChild?.(linkedCid, block) === false) {
-          continue
-        }
-
-        queue.add(job, {
-          ...opts,
-          cid: linkedCid,
-          depth: opts.depth + 1,
-          path: [...opts.path, linkedCid]
-        })
-          // eslint-disable-next-line no-loop-func
-          .catch(err => {
-            // only throw if the generator is still yielding results, otherwise
-            // it can cause unhandled promise rejections
-            if (!finished) {
-              gen.throw(err)
-            }
+      if (opts.depth < maxDepth) {
+        for (const [, linkedCid] of block.links()) {
+          if (options?.includeChild?.(linkedCid, block) === false) {
+            continue
+          }
+
+          queue.add(job, {
+            ...opts,
+            cid: linkedCid,
+            depth: opts.depth + 1,
+            path: [...opts.path, linkedCid]
           })
+            // eslint-disable-next-line no-loop-func
+            .catch(err => {
+              // only throw if the generator is still yielding results, otherwise
+              // it can cause unhandled promise rejections
+              if (!finished) {
+                gen.throw(err)
+              }
+            })
+        }
       }
 
       return {

package/src/index.ts

@@ -1,333 +1,5 @@
-/**
- * @packageDocumentation
- *
- * This module contains utility code that is shared between various Helia
- * modules such as `helia`, `@helia/http`, etc.
- */
-
-import { contentRoutingSymbol, peerRoutingSymbol, start, stop, TypedEventEmitter } from '@libp2p/interface'
-import { dns } from '@multiformats/dns'
-import drain from 'it-drain'
-import { CustomProgressEvent } from 'progress-events'
-import { PinsImpl } from './pins.ts'
-import { Routing as RoutingClass } from './routing.ts'
-import { BlockStorage } from './storage.ts'
-import { assertDatastoreVersionIsCurrent } from './utils/datastore-version.ts'
-import { getCodec } from './utils/get-codec.ts'
-import { getHasher } from './utils/get-hasher.ts'
-import { NetworkedStorage } from './utils/networked-storage.ts'
-import type { BlockStorageInit } from './storage.ts'
-import type { Await, CodecLoader, GCOptions, HasherLoader, Helia as HeliaInterface, HeliaEvents, Routing } from '@helia/interface'
-import type { BlockBroker } from '@helia/interface/blocks'
-import type { Pins } from '@helia/interface/pins'
-import type { ComponentLogger, ContentRouting, Libp2p, Logger, Metrics, PeerRouting } from '@libp2p/interface'
-import type { KeychainInit } from '@libp2p/keychain'
-import type { DNS } from '@multiformats/dns'
-import type { Blockstore } from 'interface-blockstore'
-import type { Datastore } from 'interface-datastore'
-import type { Libp2pOptions } from 'libp2p'
-import type { BlockCodec } from 'multiformats'
-import type { CID } from 'multiformats/cid'
-import type { MultihashHasher } from 'multiformats/hashes/interface'
-
-export { AbstractSession } from './abstract-session.ts'
-export type { AbstractCreateSessionOptions, BlockstoreSessionEvents, AbstractSessionComponents } from './abstract-session.ts'
-
-export type { BlockStorage, BlockStorageInit }
-
-export { breadthFirstWalker, depthFirstWalker, naturalOrderWalker } from './graph-walker.ts'
-export type { GraphWalkerComponents, GraphWalkerInit, GraphNode, GraphWalker } from './graph-walker.ts'
-
-/**
- * Options used to create a Helia node.
- */
-export interface HeliaInit<T extends Libp2p = Libp2p> {
-  /**
-   * A libp2p node is required to perform network operations. Either a
-   * pre-configured node or options to configure a node can be passed
-   * here.
-   *
-   * If node options are passed, they will be merged with the default
-   * config for the current platform. In this case all passed config
-   * keys will replace those from the default config.
-   *
-   * The libp2p `start` option is not supported, instead please pass `start` in
-   * the root of the HeliaInit object.
-   */
-  libp2p: T | Omit<Libp2pOptions<any>, 'start'>
-
-  /**
-   * Pass `false` to not start the Helia node
-   */
-  start?: boolean
-
-  /**
-   * By default Helia stores the node's PeerId in an encrypted form in a
-   * libp2p keystore. These options control how that keystore is configured.
-   */
-  keychain?: KeychainInit
-
-  /**
-   * The blockstore is where blocks are stored
-   */
-  blockstore: Blockstore
-
-  /**
-   * The datastore is where data is stored
-   */
-  datastore: Datastore
-
-  /**
-   * By default sha256, sha512 and identity hashes are supported for
-   * bitswap operations. To bitswap blocks with CIDs using other hashes
-   * pass appropriate MultihashHashers here.
-   */
-  hashers?: MultihashHasher[]
-
-  /**
-   * An optional function that can load a MultihashHasher on demand. May return
-   * a promise.
-   */
-  loadHasher?(code: number): Await<MultihashHasher>
-
-  /**
-   * In order to pin CIDs that correspond to a DAG, it's necessary to know
-   * how to traverse that DAG.  DAGWalkers take a block and yield any CIDs
-   * encoded within that block.
-   */
-  codecs?: Array<BlockCodec<any, any>>
-
-  /**
-   * An optional function that can load a BlockCodec on demand. May return a
-   * promise.
-   */
-  loadCodec?(code: number): Await<BlockCodec<any, any>>
-
-  /**
-   * A list of strategies used to fetch blocks when they are not present in
-   * the local blockstore
-   */
-  blockBrokers: Array<(components: any) => BlockBroker>
-
-  /**
-   * Garbage collection requires preventing blockstore writes during searches
-   * for unpinned blocks as DAGs are typically pinned after they've been
-   * imported - without locking this could lead to the deletion of blocks while
-   * they are being added to the blockstore.
-   *
-   * By default this lock is held on the current process and other processes
-   * will contact this process for access.
-   *
-   * If Helia is being run in multiple processes, one process must hold the GC
-   * lock so use this option to control which process that is.
-   *
-   * @default true
-   */
-  holdGcLock?: boolean
-
-  /**
-   * An optional logging component to pass to libp2p. If not specified the
-   * default implementation from libp2p will be used.
-   */
-  logger?: ComponentLogger
-
-  /**
-   * Routers perform operations such as looking up content providers,
-   * information about network peers or getting/putting records.
-   */
-  routers?: Array<Partial<Routing> | ((components: any) => Partial<Routing>)>
-
-  /**
-   * During provider lookups, peers can be returned from routing implementations
-   * with no multiaddrs.
-   *
-   * This can happen when they've been retrieved from network peers that only
-   * store multiaddrs for a limited amount of time.
-   *
-   * When this happens the peer's info has to be looked up with a further query.
-   *
-   * To not have this query block the yielding of other providers returned with
-   * multiaddrs, a separate queue is used to perform this lookup.
-   *
-   * This config value controls the concurrency of that queue.
-   *
-   * @default 5
-   */
-  providerLookupConcurrency?: number
-
-  /**
-   * Components used by subclasses
-   */
-  components?: Record<string, any>
-
-  /**
-   * An optional DNS implementation used to perform queries for DNS records.
-   */
-  dns?: DNS
-
-  /**
-   * A metrics object that can be used to collected arbitrary stats about node
-   * usage.
-   */
-  metrics?: Metrics
-
-  /**
-   * Limit the maximum supported size of identity hash digests to this value
-   *
-   * @default 128
-   */
-  maxIdentityHashDigestLength?: number
-}
-
-interface Components {
-  libp2p: Libp2p
-  blockstore: Blockstore
-  datastore: Datastore
-  logger: ComponentLogger
-  blockBrokers: BlockBroker[]
-  routing: Routing
-  dns: DNS
-  metrics?: Metrics
-  getCodec: CodecLoader
-  getHasher: HasherLoader
-}
-
-export class Helia<T extends Libp2p> implements HeliaInterface<T> {
-  public libp2p: T
-  public blockstore: BlockStorage
-  public datastore: Datastore
-  public events: TypedEventEmitter<HeliaEvents<T>>
-  public pins: Pins
-  public logger: ComponentLogger
-  public routing: Routing
-  public getCodec: CodecLoader
-  public getHasher: HasherLoader
-  public dns: DNS
-  public metrics?: Metrics
-  private readonly log: Logger
-
-  constructor (init: Omit<HeliaInit, 'start' | 'libp2p'> & { libp2p: T }) {
-    this.logger = init.logger ?? init.libp2p.logger
-    this.log = this.logger.forComponent('helia')
-    this.getHasher = getHasher(init.hashers, init.loadHasher)
-    this.getCodec = getCodec(init.codecs, init.loadCodec)
-    this.dns = init.dns ?? dns()
-    this.metrics = init.metrics
-    this.libp2p = init.libp2p
-    this.events = new TypedEventEmitter<HeliaEvents<T>>()
-
-    // @ts-expect-error routing is not set
-    const components: Components = {
-      blockstore: init.blockstore,
-      datastore: init.datastore,
-      logger: this.logger,
-      libp2p: this.libp2p,
-      blockBrokers: [],
-      getHasher: this.getHasher,
-      getCodec: this.getCodec,
-      dns: this.dns,
-      metrics: this.metrics,
-      ...(init.components ?? {})
-    }
-
-    this.routing = components.routing = new RoutingClass(components, {
-      routers: (init.routers ?? []).flatMap((router: Partial<Routing> | ((components: any) => Partial<Routing>)) => {
-        if (typeof router === 'function') {
-          router = router(components)
-        }
-
-        // if the router itself is a router
-        const routers = [
-          router
-        ]
-
-        // if the router provides a libp2p-style ContentRouter
-        const contentRouting = asContentRouting(router)
-        if (contentRouting != null) {
-          routers.push(contentRouting)
-        }
-
-        // if the router provides a libp2p-style PeerRouter
-        const peerRouting = asPeerRouting(router)
-        if (peerRouting != null) {
-          routers.push(peerRouting)
-        }
-
-        return routers
-      }),
-      providerLookupConcurrency: init.providerLookupConcurrency
-    })
-
-    components.blockBrokers = init.blockBrokers.map((fn) => {
-      return fn(components)
-    })
-
-    const networkedStorage = new NetworkedStorage(components, init)
-    this.pins = new PinsImpl(init.datastore, networkedStorage, this.getCodec)
-    this.blockstore = new BlockStorage(networkedStorage, this.pins, this.routing, {
-      holdGcLock: init.holdGcLock ?? true
-    })
-    this.datastore = init.datastore
-  }
-
-  async start (): Promise<void> {
-    await assertDatastoreVersionIsCurrent(this.datastore)
-    await start(
-      this.blockstore,
-      this.datastore,
-      this.routing,
-      this.libp2p
-    )
-    this.events.dispatchEvent(new CustomEvent('start', { detail: this }))
-  }
-
-  async stop (): Promise<void> {
-    await stop(
-      this.blockstore,
-      this.datastore,
-      this.routing,
-      this.libp2p
-    )
-    this.events.dispatchEvent(new CustomEvent('stop', { detail: this }))
-  }
-
-  async gc (options: GCOptions = {}): Promise<void> {
-    const releaseLock = await this.blockstore.lock.writeLock()
-
-    try {
-      const helia = this
-      const blockstore = this.blockstore.unwrap()
-
-      this.log('gc start')
-
-      await drain(blockstore.deleteMany((async function * (): AsyncGenerator<CID> {
-        for await (const { cid } of blockstore.getAll()) {
-          try {
-            if (await helia.pins.isPinned(cid, options)) {
-              continue
-            }
-
-            yield cid
-
-            options.onProgress?.(new CustomProgressEvent<CID>('helia:gc:deleted', cid))
-          } catch (err: any) {
-            helia.log.error('error during gc - %e', err)
-            options.onProgress?.(new CustomProgressEvent<Error>('helia:gc:error', err))
-          }
-        }
-      }())))
-    } finally {
-      releaseLock()
-    }
-
-    this.log('gc finished')
-  }
-}
-
-function asContentRouting (obj?: any): ContentRouting | undefined {
-  return obj?.[contentRoutingSymbol]
-}
-
-function asPeerRouting (obj?: any): PeerRouting | undefined {
-  return obj?.[peerRoutingSymbol]
-}
+export * from './abstract-session.ts'
+export * from './errors.ts'
+export * from './graph-walker.ts'
+export * from './is-cid.ts'
+export * from './is-promise.ts'

package/src/is-cid.ts

@@ -0,0 +1,9 @@
+import { CID } from 'multiformats/cid'
+
+export function isCID (obj?: any): obj is CID {
+  if (obj == null) {
+    return false
+  }
+
+  return CID.asCID(obj) != null
+}

package/dist/src/pins.d.ts

@@ -1,21 +0,0 @@
-import { CID } from 'multiformats/cid';
-import type { CodecLoader } from '@helia/interface';
-import type { AddOptions, IsPinnedOptions, LsOptions, Pin, Pins, RmOptions } from '@helia/interface/pins';
-import type { AbortOptions } from '@libp2p/interface';
-import type { Blockstore } from 'interface-blockstore';
-import type { Datastore } from 'interface-datastore';
-import type { Version } from 'multiformats/cid';
-export declare class PinsImpl implements Pins {
-    #private;
-    private readonly datastore;
-    private readonly blockstore;
-    private readonly getCodec;
-    constructor(datastore: Datastore, blockstore: Blockstore, getCodec: CodecLoader);
-    add(cid: CID<unknown, number, number, Version>, options?: AddOptions): AsyncGenerator<CID, void, undefined>;
-    rm(cid: CID<unknown, number, number, Version>, options?: RmOptions): AsyncGenerator<CID, void, undefined>;
-    ls(options?: LsOptions): AsyncGenerator<Pin, void, undefined>;
-    isPinned(cid: CID, options?: IsPinnedOptions): Promise<boolean>;
-    get(cid: CID, options?: AbortOptions): Promise<Pin>;
-    setMetadata(cid: CID, metadata: Record<string, string | number | boolean> | undefined, options?: AbortOptions): Promise<void>;
-}
-//# sourceMappingURL=pins.d.ts.map

package/dist/src/pins.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"pins.d.ts","sourceRoot":"","sources":["../../src/pins.ts"],"names":[],"mappings":"AAOA,OAAO,EAAE,GAAG,EAAE,MAAM,kBAAkB,CAAA;AAItC,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAA;AAEnD,OAAO,KAAK,EAAE,UAAU,EAAgB,eAAe,EAAE,SAAS,EAAE,GAAG,EAAE,IAAI,EAAE,SAAS,EAAE,MAAM,uBAAuB,CAAA;AACvH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAA;AACrD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,sBAAsB,CAAA;AACtD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,qBAAqB,CAAA;AACpD,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,kBAAkB,CAAA;AAgD/C,qBAAa,QAAS,YAAW,IAAI;;IACnC,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAW;IACrC,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAY;IACvC,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAa;gBAEzB,SAAS,EAAE,SAAS,EAAE,UAAU,EAAE,UAAU,EAAE,QAAQ,EAAE,WAAW;IAMxE,GAAG,CAAE,GAAG,EAAE,GAAG,CAAC,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,OAAO,GAAE,UAAe,GAAG,cAAc,CAAC,GAAG,EAAE,IAAI,EAAE,SAAS,CAAC;IAyGhH,EAAE,CAAE,GAAG,EAAE,GAAG,CAAC,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,OAAO,GAAE,SAAc,GAAG,cAAc,CAAC,GAAG,EAAE,IAAI,EAAE,SAAS,CAAC;IA6B9G,EAAE,CAAE,OAAO,GAAE,SAAc,GAAG,cAAc,CAAC,GAAG,EAAE,IAAI,EAAE,SAAS,CAAC;IAcpE,QAAQ,CAAE,GAAG,EAAE,GAAG,EAAE,OAAO,GAAE,eAAoB,GAAG,OAAO,CAAC,OAAO,CAAC;IAMpE,GAAG,CAAE,GAAG,EAAE,GAAG,EAAE,OAAO,CAAC,EAAE,YAAY,GAAG,OAAO,CAAC,GAAG,CAAC;IAOpD,WAAW,CAAE,GAAG,EAAE,GAAG,EAAE,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,OAAO,CAAC,GAAG,SAAS,EAAE,OAAO,CAAC,EAAE,YAAY,GAAG,OAAO,CAAC,IAAI,CAAC;CASrI"}