decocms 2.276.1 → 2.276.2

package/dist/server/node_modules/pg-pool/index.js

@@ -0,0 +1,517 @@
+'use strict'
+const EventEmitter = require('events').EventEmitter
+
+const NOOP = function () {}
+
+const removeWhere = (list, predicate) => {
+  const i = list.findIndex(predicate)
+
+  return i === -1 ? undefined : list.splice(i, 1)[0]
+}
+
+class IdleItem {
+  constructor(client, idleListener, timeoutId) {
+    this.client = client
+    this.idleListener = idleListener
+    this.timeoutId = timeoutId
+  }
+}
+
+class PendingItem {
+  constructor(callback) {
+    this.callback = callback
+  }
+}
+
+function throwOnDoubleRelease() {
+  throw new Error('Release called on client which has already been released to the pool.')
+}
+
+function promisify(Promise, callback) {
+  if (callback) {
+    return { callback: callback, result: undefined }
+  }
+  let rej
+  let res
+  const cb = function (err, client) {
+    err ? rej(err) : res(client)
+  }
+  const result = new Promise(function (resolve, reject) {
+    res = resolve
+    rej = reject
+  }).catch((err) => {
+    // replace the stack trace that leads to `TCP.onStreamRead` with one that leads back to the
+    // application that created the query
+    Error.captureStackTrace(err)
+    throw err
+  })
+  return { callback: cb, result: result }
+}
+
+function makeIdleListener(pool, client) {
+  return function idleListener(err) {
+    err.client = client
+
+    client.removeListener('error', idleListener)
+    client.on('error', () => {
+      pool.log('additional client error after disconnection due to error', err)
+    })
+    pool._remove(client)
+    // TODO - document that once the pool emits an error
+    // the client has already been closed & purged and is unusable
+    pool.emit('error', err, client)
+  }
+}
+
+class Pool extends EventEmitter {
+  constructor(options, Client) {
+    super()
+    this.options = Object.assign({}, options)
+
+    if (options != null && 'password' in options) {
+      // "hiding" the password so it doesn't show up in stack traces
+      // or if the client is console.logged
+      Object.defineProperty(this.options, 'password', {
+        configurable: true,
+        enumerable: false,
+        writable: true,
+        value: options.password,
+      })
+    }
+    if (options != null && options.ssl && options.ssl.key) {
+      // "hiding" the ssl->key so it doesn't show up in stack traces
+      // or if the client is console.logged
+      Object.defineProperty(this.options.ssl, 'key', {
+        enumerable: false,
+      })
+    }
+
+    this.options.max = this.options.max || this.options.poolSize || 10
+    this.options.min = this.options.min || 0
+    this.options.maxUses = this.options.maxUses || Infinity
+    this.options.allowExitOnIdle = this.options.allowExitOnIdle || false
+    this.options.maxLifetimeSeconds = this.options.maxLifetimeSeconds || 0
+    this.log = this.options.log || function () {}
+    this.Client = this.options.Client || Client || require('pg').Client
+    this.Promise = this.options.Promise || global.Promise
+
+    if (typeof this.options.idleTimeoutMillis === 'undefined') {
+      this.options.idleTimeoutMillis = 10000
+    }
+
+    this._clients = []
+    this._idle = []
+    this._expired = new WeakSet()
+    this._pendingQueue = []
+    this._endCallback = undefined
+    this.ending = false
+    this.ended = false
+  }
+
+  _promiseTry(f) {
+    const Promise = this.Promise
+    if (typeof Promise.try === 'function') {
+      return Promise.try(f)
+    }
+    return new Promise((resolve) => resolve(f()))
+  }
+
+  _isFull() {
+    return this._clients.length >= this.options.max
+  }
+
+  _isAboveMin() {
+    return this._clients.length > this.options.min
+  }
+
+  _pulseQueue() {
+    this.log('pulse queue')
+    if (this.ended) {
+      this.log('pulse queue ended')
+      return
+    }
+    if (this.ending) {
+      this.log('pulse queue on ending')
+      if (this._idle.length) {
+        this._idle.slice().map((item) => {
+          this._remove(item.client)
+        })
+      }
+      if (!this._clients.length) {
+        this.ended = true
+        this._endCallback()
+      }
+      return
+    }
+
+    // if we don't have any waiting, do nothing
+    if (!this._pendingQueue.length) {
+      this.log('no queued requests')
+      return
+    }
+    // if we don't have any idle clients and we have no more room do nothing
+    if (!this._idle.length && this._isFull()) {
+      return
+    }
+    const pendingItem = this._pendingQueue.shift()
+    if (this._idle.length) {
+      const idleItem = this._idle.pop()
+      clearTimeout(idleItem.timeoutId)
+      const client = idleItem.client
+      client.ref && client.ref()
+      const idleListener = idleItem.idleListener
+
+      return this._acquireClient(client, pendingItem, idleListener, false)
+    }
+    if (!this._isFull()) {
+      return this.newClient(pendingItem)
+    }
+    throw new Error('unexpected condition')
+  }
+
+  _remove(client, callback) {
+    const removed = removeWhere(this._idle, (item) => item.client === client)
+
+    if (removed !== undefined) {
+      clearTimeout(removed.timeoutId)
+    }
+
+    this._clients = this._clients.filter((c) => c !== client)
+    const context = this
+    client.end(() => {
+      context.emit('remove', client)
+
+      if (typeof callback === 'function') {
+        callback()
+      }
+    })
+  }
+
+  connect(cb) {
+    if (this.ending) {
+      const err = new Error('Cannot use a pool after calling end on the pool')
+      return cb ? cb(err) : this.Promise.reject(err)
+    }
+
+    const response = promisify(this.Promise, cb)
+    const result = response.result
+
+    // if we don't have to connect a new client, don't do so
+    if (this._isFull() || this._idle.length) {
+      // if we have idle clients schedule a pulse immediately
+      if (this._idle.length) {
+        process.nextTick(() => this._pulseQueue())
+      }
+
+      if (!this.options.connectionTimeoutMillis) {
+        this._pendingQueue.push(new PendingItem(response.callback))
+        return result
+      }
+
+      const queueCallback = (err, res, done) => {
+        clearTimeout(tid)
+        response.callback(err, res, done)
+      }
+
+      const pendingItem = new PendingItem(queueCallback)
+
+      // set connection timeout on checking out an existing client
+      const tid = setTimeout(() => {
+        // remove the callback from pending waiters because
+        // we're going to call it with a timeout error
+        removeWhere(this._pendingQueue, (i) => i.callback === queueCallback)
+        pendingItem.timedOut = true
+        response.callback(new Error('timeout exceeded when trying to connect'))
+      }, this.options.connectionTimeoutMillis)
+
+      if (tid.unref) {
+        tid.unref()
+      }
+
+      this._pendingQueue.push(pendingItem)
+      return result
+    }
+
+    this.newClient(new PendingItem(response.callback))
+
+    return result
+  }
+
+  newClient(pendingItem) {
+    const client = new this.Client(this.options)
+    this._clients.push(client)
+    const idleListener = makeIdleListener(this, client)
+
+    this.log('checking client timeout')
+
+    // connection timeout logic
+    let tid
+    let timeoutHit = false
+    if (this.options.connectionTimeoutMillis) {
+      tid = setTimeout(() => {
+        if (client.connection) {
+          this.log('ending client due to timeout')
+          timeoutHit = true
+          client.connection.stream.destroy()
+        } else if (!client.isConnected()) {
+          this.log('ending client due to timeout')
+          timeoutHit = true
+          // force kill the node driver, and let libpq do its teardown
+          client.end()
+        }
+      }, this.options.connectionTimeoutMillis)
+    }
+
+    this.log('connecting new client')
+    client.connect((err) => {
+      if (tid) {
+        clearTimeout(tid)
+      }
+      client.on('error', idleListener)
+      if (err) {
+        this.log('client failed to connect', err)
+        // remove the dead client from our list of clients
+        this._clients = this._clients.filter((c) => c !== client)
+        if (timeoutHit) {
+          err = new Error('Connection terminated due to connection timeout', { cause: err })
+        }
+
+        // this client won’t be released, so move on immediately
+        this._pulseQueue()
+
+        if (!pendingItem.timedOut) {
+          pendingItem.callback(err, undefined, NOOP)
+        }
+      } else {
+        this.log('new client connected')
+
+        if (this.options.onConnect) {
+          this._promiseTry(() => this.options.onConnect(client)).then(
+            () => {
+              this._afterConnect(client, pendingItem, idleListener)
+            },
+            (hookErr) => {
+              this._clients = this._clients.filter((c) => c !== client)
+              client.end(() => {
+                this._pulseQueue()
+                if (!pendingItem.timedOut) {
+                  pendingItem.callback(hookErr, undefined, NOOP)
+                }
+              })
+            }
+          )
+          return
+        }
+
+        return this._afterConnect(client, pendingItem, idleListener)
+      }
+    })
+  }
+
+  _afterConnect(client, pendingItem, idleListener) {
+    if (this.options.maxLifetimeSeconds !== 0) {
+      const maxLifetimeTimeout = setTimeout(() => {
+        this.log('ending client due to expired lifetime')
+        this._expired.add(client)
+        const idleIndex = this._idle.findIndex((idleItem) => idleItem.client === client)
+        if (idleIndex !== -1) {
+          this._acquireClient(
+            client,
+            new PendingItem((err, client, clientRelease) => clientRelease()),
+            idleListener,
+            false
+          )
+        }
+      }, this.options.maxLifetimeSeconds * 1000)
+
+      maxLifetimeTimeout.unref()
+      client.once('end', () => clearTimeout(maxLifetimeTimeout))
+    }
+
+    return this._acquireClient(client, pendingItem, idleListener, true)
+  }
+
+  // acquire a client for a pending work item
+  _acquireClient(client, pendingItem, idleListener, isNew) {
+    if (isNew) {
+      this.emit('connect', client)
+    }
+
+    this.emit('acquire', client)
+
+    client.release = this._releaseOnce(client, idleListener)
+
+    client.removeListener('error', idleListener)
+
+    if (!pendingItem.timedOut) {
+      if (isNew && this.options.verify) {
+        this.options.verify(client, (err) => {
+          if (err) {
+            client.release(err)
+            return pendingItem.callback(err, undefined, NOOP)
+          }
+
+          pendingItem.callback(undefined, client, client.release)
+        })
+      } else {
+        pendingItem.callback(undefined, client, client.release)
+      }
+    } else {
+      if (isNew && this.options.verify) {
+        this.options.verify(client, client.release)
+      } else {
+        client.release()
+      }
+    }
+  }
+
+  // returns a function that wraps _release and throws if called more than once
+  _releaseOnce(client, idleListener) {
+    let released = false
+
+    return (err) => {
+      if (released) {
+        throwOnDoubleRelease()
+      }
+
+      released = true
+      this._release(client, idleListener, err)
+    }
+  }
+
+  // release a client back to the poll, include an error
+  // to remove it from the pool
+  _release(client, idleListener, err) {
+    client.on('error', idleListener)
+
+    client._poolUseCount = (client._poolUseCount || 0) + 1
+
+    this.emit('release', err, client)
+
+    // TODO(bmc): expose a proper, public interface _queryable and _ending
+    if (err || this.ending || !client._queryable || client._ending || client._poolUseCount >= this.options.maxUses) {
+      if (client._poolUseCount >= this.options.maxUses) {
+        this.log('remove expended client')
+      }
+
+      return this._remove(client, this._pulseQueue.bind(this))
+    }
+
+    const isExpired = this._expired.has(client)
+    if (isExpired) {
+      this.log('remove expired client')
+      this._expired.delete(client)
+      return this._remove(client, this._pulseQueue.bind(this))
+    }
+
+    // idle timeout
+    let tid
+    if (this.options.idleTimeoutMillis && this._isAboveMin()) {
+      tid = setTimeout(() => {
+        if (this._isAboveMin()) {
+          this.log('remove idle client')
+          this._remove(client, this._pulseQueue.bind(this))
+        }
+      }, this.options.idleTimeoutMillis)
+
+      if (this.options.allowExitOnIdle) {
+        // allow Node to exit if this is all that's left
+        tid.unref()
+      }
+    }
+
+    if (this.options.allowExitOnIdle) {
+      client.unref()
+    }
+
+    this._idle.push(new IdleItem(client, idleListener, tid))
+    this._pulseQueue()
+  }
+
+  query(text, values, cb) {
+    // guard clause against passing a function as the first parameter
+    if (typeof text === 'function') {
+      const response = promisify(this.Promise, text)
+      setImmediate(function () {
+        return response.callback(new Error('Passing a function as the first parameter to pool.query is not supported'))
+      })
+      return response.result
+    }
+
+    // allow plain text query without values
+    if (typeof values === 'function') {
+      cb = values
+      values = undefined
+    }
+    const response = promisify(this.Promise, cb)
+    cb = response.callback
+
+    this.connect((err, client) => {
+      if (err) {
+        return cb(err)
+      }
+
+      let clientReleased = false
+      const onError = (err) => {
+        if (clientReleased) {
+          return
+        }
+        clientReleased = true
+        client.release(err)
+        cb(err)
+      }
+
+      client.once('error', onError)
+      this.log('dispatching query')
+      try {
+        client.query(text, values, (err, res) => {
+          this.log('query dispatched')
+          client.removeListener('error', onError)
+          if (clientReleased) {
+            return
+          }
+          clientReleased = true
+          client.release(err)
+          if (err) {
+            return cb(err)
+          }
+          return cb(undefined, res)
+        })
+      } catch (err) {
+        client.release(err)
+        return cb(err)
+      }
+    })
+    return response.result
+  }
+
+  end(cb) {
+    this.log('ending')
+    if (this.ending) {
+      const err = new Error('Called end on pool more than once')
+      return cb ? cb(err) : this.Promise.reject(err)
+    }
+    this.ending = true
+    const promised = promisify(this.Promise, cb)
+    this._endCallback = promised.callback
+    this._pulseQueue()
+    return promised.result
+  }
+
+  get waitingCount() {
+    return this._pendingQueue.length
+  }
+
+  get idleCount() {
+    return this._idle.length
+  }
+
+  get expiredCount() {
+    return this._clients.reduce((acc, client) => acc + (this._expired.has(client) ? 1 : 0), 0)
+  }
+
+  get totalCount() {
+    return this._clients.length
+  }
+}
+module.exports = Pool

package/dist/server/node_modules/pg-pool/package.json

@@ -0,0 +1,51 @@
+{
+  "name": "pg-pool",
+  "version": "3.13.0",
+  "description": "Connection pool for node-postgres",
+  "main": "index.js",
+  "exports": {
+    ".": {
+      "import": "./esm/index.mjs",
+      "require": "./index.js",
+      "default": "./index.js"
+    }
+  },
+  "directories": {
+    "test": "test"
+  },
+  "scripts": {
+    "test": " node_modules/.bin/mocha"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/brianc/node-postgres.git",
+    "directory": "packages/pg-pool"
+  },
+  "keywords": [
+    "pg",
+    "postgres",
+    "pool",
+    "database"
+  ],
+  "author": "Brian M. Carlson",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/brianc/node-postgres/issues"
+  },
+  "homepage": "https://github.com/brianc/node-postgres/tree/master/packages/pg-pool#readme",
+  "devDependencies": {
+    "bluebird": "3.7.2",
+    "co": "4.6.0",
+    "expect.js": "0.3.1",
+    "lodash": "^4.17.11",
+    "mocha": "^11.7.5"
+  },
+  "peerDependencies": {
+    "pg": ">=8.0"
+  },
+  "files": [
+    "index.js",
+    "esm"
+  ],
+  "gitHead": "c9070cc8d526fca65780cedc25c1966b57cf7532"
+}

package/dist/server/node_modules/pg-protocol/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2010 - 2021 Brian Carlson
+
+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.

package/dist/server/node_modules/pg-protocol/README.md

@@ -0,0 +1,3 @@
+# pg-protocol
+
+Low level postgres wire protocol parser and serializer written in Typescript. Used by node-postgres. Needs more documentation. :smile:

package/dist/server/node_modules/pg-protocol/dist/b.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/server/node_modules/pg-protocol/dist/b.js

@@ -0,0 +1,23 @@
+"use strict";
+// file for microbenchmarking
+Object.defineProperty(exports, "__esModule", { value: true });
+const buffer_reader_1 = require("./buffer-reader");
+const LOOPS = 1000;
+let count = 0;
+const start = performance.now();
+const reader = new buffer_reader_1.BufferReader();
+const buffer = Buffer.from([33, 33, 33, 33, 33, 33, 33, 0]);
+const run = () => {
+    if (count > LOOPS) {
+        console.log(performance.now() - start);
+        return;
+    }
+    count++;
+    for (let i = 0; i < LOOPS; i++) {
+        reader.setBuffer(0, buffer);
+        reader.cstring();
+    }
+    setImmediate(run);
+};
+run();
+//# sourceMappingURL=b.js.map

package/dist/server/node_modules/pg-protocol/dist/b.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"b.js","sourceRoot":"","sources":["../src/b.ts"],"names":[],"mappings":";AAAA,6BAA6B;;AAE7B,mDAA8C;AAE9C,MAAM,KAAK,GAAG,IAAI,CAAA;AAClB,IAAI,KAAK,GAAG,CAAC,CAAA;AACb,MAAM,KAAK,GAAG,WAAW,CAAC,GAAG,EAAE,CAAA;AAE/B,MAAM,MAAM,GAAG,IAAI,4BAAY,EAAE,CAAA;AACjC,MAAM,MAAM,GAAG,MAAM,CAAC,IAAI,CAAC,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,CAAC,CAAC,CAAC,CAAA;AAE3D,MAAM,GAAG,GAAG,GAAG,EAAE;IACf,IAAI,KAAK,GAAG,KAAK,EAAE;QACjB,OAAO,CAAC,GAAG,CAAC,WAAW,CAAC,GAAG,EAAE,GAAG,KAAK,CAAC,CAAA;QACtC,OAAM;KACP;IACD,KAAK,EAAE,CAAA;IACP,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,KAAK,EAAE,CAAC,EAAE,EAAE;QAC9B,MAAM,CAAC,SAAS,CAAC,CAAC,EAAE,MAAM,CAAC,CAAA;QAC3B,MAAM,CAAC,OAAO,EAAE,CAAA;KACjB;IACD,YAAY,CAAC,GAAG,CAAC,CAAA;AACnB,CAAC,CAAA;AAED,GAAG,EAAE,CAAA"}

package/dist/server/node_modules/pg-protocol/dist/buffer-reader.d.ts

@@ -0,0 +1,15 @@
+/// <reference types="node" />
+export declare class BufferReader {
+    private offset;
+    private buffer;
+    private encoding;
+    constructor(offset?: number);
+    setBuffer(offset: number, buffer: Buffer): void;
+    int16(): number;
+    byte(): number;
+    int32(): number;
+    uint32(): number;
+    string(length: number): string;
+    cstring(): string;
+    bytes(length: number): Buffer;
+}

package/dist/server/node_modules/pg-protocol/dist/buffer-reader.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BufferReader = void 0;
+class BufferReader {
+    constructor(offset = 0) {
+        this.offset = offset;
+        this.buffer = Buffer.allocUnsafe(0);
+        // TODO(bmc): support non-utf8 encoding?
+        this.encoding = 'utf-8';
+    }
+    setBuffer(offset, buffer) {
+        this.offset = offset;
+        this.buffer = buffer;
+    }
+    int16() {
+        const result = this.buffer.readInt16BE(this.offset);
+        this.offset += 2;
+        return result;
+    }
+    byte() {
+        const result = this.buffer[this.offset];
+        this.offset++;
+        return result;
+    }
+    int32() {
+        const result = this.buffer.readInt32BE(this.offset);
+        this.offset += 4;
+        return result;
+    }
+    uint32() {
+        const result = this.buffer.readUInt32BE(this.offset);
+        this.offset += 4;
+        return result;
+    }
+    string(length) {
+        const result = this.buffer.toString(this.encoding, this.offset, this.offset + length);
+        this.offset += length;
+        return result;
+    }
+    cstring() {
+        const start = this.offset;
+        let end = start;
+        // eslint-disable-next-line no-empty
+        while (this.buffer[end++] !== 0) { }
+        this.offset = end;
+        return this.buffer.toString(this.encoding, start, end - 1);
+    }
+    bytes(length) {
+        const result = this.buffer.slice(this.offset, this.offset + length);
+        this.offset += length;
+        return result;
+    }
+}
+exports.BufferReader = BufferReader;
+//# sourceMappingURL=buffer-reader.js.map

package/dist/server/node_modules/pg-protocol/dist/buffer-reader.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"buffer-reader.js","sourceRoot":"","sources":["../src/buffer-reader.ts"],"names":[],"mappings":";;;AAAA,MAAa,YAAY;IAMvB,YAAoB,SAAiB,CAAC;QAAlB,WAAM,GAAN,MAAM,CAAY;QAL9B,WAAM,GAAW,MAAM,CAAC,WAAW,CAAC,CAAC,CAAC,CAAA;QAE9C,wCAAwC;QAChC,aAAQ,GAAW,OAAO,CAAA;IAEO,CAAC;IAEnC,SAAS,CAAC,MAAc,EAAE,MAAc;QAC7C,IAAI,CAAC,MAAM,GAAG,MAAM,CAAA;QACpB,IAAI,CAAC,MAAM,GAAG,MAAM,CAAA;IACtB,CAAC;IAEM,KAAK;QACV,MAAM,MAAM,GAAG,IAAI,CAAC,MAAM,CAAC,WAAW,CAAC,IAAI,CAAC,MAAM,CAAC,CAAA;QACnD,IAAI,CAAC,MAAM,IAAI,CAAC,CAAA;QAChB,OAAO,MAAM,CAAA;IACf,CAAC;IAEM,IAAI;QACT,MAAM,MAAM,GAAG,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,CAAA;QACvC,IAAI,CAAC,MAAM,EAAE,CAAA;QACb,OAAO,MAAM,CAAA;IACf,CAAC;IAEM,KAAK;QACV,MAAM,MAAM,GAAG,IAAI,CAAC,MAAM,CAAC,WAAW,CAAC,IAAI,CAAC,MAAM,CAAC,CAAA;QACnD,IAAI,CAAC,MAAM,IAAI,CAAC,CAAA;QAChB,OAAO,MAAM,CAAA;IACf,CAAC;IAEM,MAAM;QACX,MAAM,MAAM,GAAG,IAAI,CAAC,MAAM,CAAC,YAAY,CAAC,IAAI,CAAC,MAAM,CAAC,CAAA;QACpD,IAAI,CAAC,MAAM,IAAI,CAAC,CAAA;QAChB,OAAO,MAAM,CAAA;IACf,CAAC;IAEM,MAAM,CAAC,MAAc;QAC1B,MAAM,MAAM,GAAG,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,IAAI,CAAC,QAAQ,EAAE,IAAI,CAAC,MAAM,EAAE,IAAI,CAAC,MAAM,GAAG,MAAM,CAAC,CAAA;QACrF,IAAI,CAAC,MAAM,IAAI,MAAM,CAAA;QACrB,OAAO,MAAM,CAAA;IACf,CAAC;IAEM,OAAO;QACZ,MAAM,KAAK,GAAG,IAAI,CAAC,MAAM,CAAA;QACzB,IAAI,GAAG,GAAG,KAAK,CAAA;QACf,oCAAoC;QACpC,OAAO,IAAI,CAAC,MAAM,CAAC,GAAG,EAAE,CAAC,KAAK,CAAC,EAAE,GAAE;QACnC,IAAI,CAAC,MAAM,GAAG,GAAG,CAAA;QACjB,OAAO,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,IAAI,CAAC,QAAQ,EAAE,KAAK,EAAE,GAAG,GAAG,CAAC,CAAC,CAAA;IAC5D,CAAC;IAEM,KAAK,CAAC,MAAc;QACzB,MAAM,MAAM,GAAG,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,IAAI,CAAC,MAAM,EAAE,IAAI,CAAC,MAAM,GAAG,MAAM,CAAC,CAAA;QACnE,IAAI,CAAC,MAAM,IAAI,MAAM,CAAA;QACrB,OAAO,MAAM,CAAA;IACf,CAAC;CACF;AAzDD,oCAyDC"}