@warp-drive-mirror/experiments 0.2.8 → 5.9.1

package/dist/unpkg/dev/document-storage.js

@@ -1,349 +1,3 @@
-const WARP_DRIVE_STORAGE_FILE_NAME = 'warp-drive_document-storage';
-const WARP_DRIVE_STORAGE_VERSION = 1;
+import { t as DocumentStorage } from "./document-storage-DkiEg9rY.js";
 
-/**
- * DocumentStorage is specifically designed around WarpDrive Cache and Request concepts.
- *
- * CacheFileDocument is a StructuredDocument (request response) whose `content` is
- * the ResourceDocument returned by inserting the request into a Store's Cache.
- */
-
-/**
- * A CacheDocument is a reconstructed request response that rehydrates ResourceDocument
- * with the associated resources based on their identifiers.
- */
-
-class InternalDocumentStorage {
-  constructor(options) {
-    this.options = options;
-    this._lastModified = 0;
-    this._invalidated = true;
-    this._fileHandle = this._open(options.scope);
-    this._channel = Object.assign(new BroadcastChannel(options.scope), {
-      onmessage: this._onMessage.bind(this)
-    });
-  }
-  _onMessage(_event) {
-    this._invalidated = true;
-  }
-  async _open(scope) {
-    const directoryHandle = await navigator.storage.getDirectory();
-    const fileHandle = await directoryHandle.getFileHandle(scope, {
-      create: true
-    });
-    return fileHandle;
-  }
-  async _read() {
-    if (this._filePromise) {
-      return this._filePromise;
-    }
-    if (this._invalidated) {
-      const updateFile = async () => {
-        const fileHandle = await this._fileHandle;
-        const file = await fileHandle.getFile();
-        const lastModified = file.lastModified;
-        if (lastModified === this._lastModified && this._cache) {
-          return this._cache;
-        }
-        const contents = await file.text();
-        const cache = contents ? JSON.parse(contents) : {
-          documents: [],
-          resources: []
-        };
-        const documents = new Map(cache.documents);
-        const resources = new Map(cache.resources);
-        const cacheMap = {
-          documents,
-          resources
-        };
-        this._cache = cacheMap;
-        this._invalidated = false;
-        this._lastModified = lastModified;
-        return cacheMap;
-      };
-      this._filePromise = updateFile();
-      await this._filePromise;
-      this._filePromise = null;
-    }
-    return this._cache;
-  }
-  async _patch(documentKey, document, updatedResources) {
-    const fileHandle = await this._fileHandle;
-    // secure a lock before getting latest state
-    const writable = await fileHandle.createWritable();
-    const cache = await this._read();
-    cache.documents.set(documentKey, document);
-    updatedResources.forEach((resource, key) => {
-      cache.resources.set(key, resource);
-    });
-    const documents = [...cache.documents.entries()];
-    const resources = [...cache.resources.entries()];
-    const cacheFile = {
-      documents,
-      resources
-    };
-    await writable.write(JSON.stringify(cacheFile));
-    await writable.close();
-    this._channel.postMessage({
-      type: 'patch',
-      key: documentKey,
-      resources: [...updatedResources.keys()]
-    });
-  }
-  async getDocument(key) {
-    const cache = await this._read();
-    // clone the document to avoid leaking the internal cache
-    const document = safeDocumentHydrate(cache.documents.get(key.lid));
-    if (!document) {
-      return null;
-    }
-
-    // expand the document with the resources
-    if (document.content) {
-      if (docHasData(document.content)) {
-        let data = null;
-        if (Array.isArray(document.content.data)) {
-          data = document.content.data.map(resourceIdentifier => {
-            const resource = cache.resources.get(resourceIdentifier.lid);
-            if (!resource) {
-              throw new Error(`Resource not found for ${resourceIdentifier.lid}`);
-            }
-
-            // clone the resource to avoid leaking the internal cache
-            return structuredClone(resource);
-          });
-        } else if (document.content.data) {
-          const resource = cache.resources.get(document.content.data.lid);
-          if (!resource) {
-            throw new Error(`Resource not found for ${document.content.data.lid}`);
-          }
-
-          // clone the resource to avoid leaking the internal cache
-          data = structuredClone(resource);
-        }
-        if (document.content.included) {
-          const included = document.content.included.map(resourceIdentifier => {
-            const resource = cache.resources.get(resourceIdentifier.lid);
-            if (!resource) {
-              throw new Error(`Resource not found for ${resourceIdentifier.lid}`);
-            }
-
-            // clone the resource to avoid leaking the internal cache
-            return structuredClone(resource);
-          });
-          document.content.included = included;
-        }
-        document.content.data = data;
-      }
-    }
-    return document;
-  }
-  async putDocument(document, resourceCollector) {
-    const resources = new Map();
-    if (!document.content) {
-      throw new Error(`Document content is missing, only finalized documents can be stored`);
-    }
-    if (!document.content.lid) {
-      throw new Error(`Document content is missing a lid, only documents with a cache-key can be stored`);
-    }
-    if (docHasData(document.content)) {
-      this._getResources(document.content, resourceCollector, resources);
-    }
-    await this._patch(document.content.lid, safeDocumentSerialize(document), resources);
-  }
-  _getResources(document, resourceCollector, resources = new Map()) {
-    if (Array.isArray(document.data)) {
-      document.data.forEach(resourceIdentifier => {
-        const resource = resourceCollector(resourceIdentifier);
-        resources.set(resourceIdentifier.lid, structuredClone(resource));
-      });
-    } else if (document.data) {
-      const resource = resourceCollector(document.data);
-      resources.set(document.data.lid, structuredClone(resource));
-    }
-    if (document.included) {
-      document.included.forEach(resourceIdentifier => {
-        const resource = resourceCollector(resourceIdentifier);
-        resources.set(resourceIdentifier.lid, structuredClone(resource));
-      });
-    }
-    return resources;
-  }
-  async putResources(document, resourceCollector) {
-    const fileHandle = await this._fileHandle;
-    // secure a lock before getting latest state
-    const writable = await fileHandle.createWritable();
-    const cache = await this._read();
-    const updatedResources = this._getResources(document, resourceCollector);
-    updatedResources.forEach((resource, key) => {
-      cache.resources.set(key, resource);
-    });
-    const documents = [...cache.documents.entries()];
-    const resources = [...cache.resources.entries()];
-    const cacheFile = {
-      documents,
-      resources
-    };
-    await writable.write(JSON.stringify(cacheFile));
-    await writable.close();
-    this._channel.postMessage({
-      type: 'patch',
-      key: null,
-      resources: [...updatedResources.keys()]
-    });
-  }
-  async clear(reset) {
-    const fileHandle = await this._fileHandle;
-    const writable = await fileHandle.createWritable();
-    await writable.write('');
-    await writable.close();
-    this._invalidated = true;
-    this._lastModified = 0;
-    this._cache = null;
-    this._filePromise = null;
-    this._channel.postMessage({
-      type: 'clear'
-    });
-    if (!reset) {
-      this._channel.close();
-      this._channel = null;
-      if (!this.options.isolated) {
-        Storages.delete(this.options.scope);
-      }
-    }
-  }
-}
-function safeDocumentSerialize(document) {
-  (test => {
-    if (!test) {
-      throw new Error(`Expected to receive a document`);
-    }
-  })(document && typeof document === 'object');
-  const doc = document;
-  const newDoc = {};
-  if ('request' in doc) {
-    newDoc.request = prepareRequest(doc.request);
-  }
-  if ('response' in doc) {
-    newDoc.response = prepareResponse(doc.response);
-  }
-  if ('content' in doc) {
-    newDoc.content = structuredClone(doc.content);
-  }
-  return newDoc;
-}
-function prepareRequest(request) {
-  const {
-    signal,
-    headers
-  } = request;
-  const requestCopy = Object.assign({}, request);
-  delete requestCopy.store;
-  if (signal instanceof AbortSignal) {
-    delete requestCopy.signal;
-  }
-  if (headers instanceof Headers) {
-    requestCopy.headers = Array.from(headers);
-  }
-  return requestCopy;
-}
-function prepareResponse(response) {
-  if (!response) return null;
-  const clone = {};
-  if (response.headers) {
-    clone.headers = Array.from(response.headers);
-  }
-  clone.ok = response.ok;
-  clone.redirected = response.redirected;
-  clone.status = response.status;
-  clone.statusText = response.statusText;
-  clone.type = response.type;
-  clone.url = response.url;
-  return clone;
-}
-function safeDocumentHydrate(document) {
-  (test => {
-    if (!test) {
-      throw new Error(`Expected to receive a document`);
-    }
-  })(document && typeof document === 'object');
-  const doc = document;
-  const newDoc = {};
-  if ('request' in doc) {
-    const headers = new Headers(doc.request.headers);
-    const req = Object.assign({}, doc.request, {
-      headers
-    });
-    newDoc.request = new Request(doc.request.url ?? '', req);
-  }
-  if ('response' in doc) {
-    const headers = new Headers(doc.response.headers);
-    const resp = Object.assign({}, doc.response, {
-      headers
-    });
-    newDoc.response = new Response(null, resp);
-  }
-  if ('content' in doc) {
-    newDoc.content = structuredClone(doc.content);
-  }
-  return newDoc;
-}
-function docHasData(doc) {
-  return 'data' in doc;
-}
-const Storages = new Map();
-
-/**
- * DocumentStorage is a wrapper around the StorageManager API that provides
- * a simple interface for reading and updating documents and requests.
- *
- * Some goals for this experiment:
- *
- * - optimize for storing requests/documents
- * - optimize for storing resources
- * - optimize for looking up resources associated to a document
- * - optimize for notifying cross-tab when data is updated
- *
- * optional features:
- *
- * - support for offline mode
- * - ?? support for relationship based cache traversal
- * - a way to index records by type + another field (e.g updatedAt/createAt/name)
- *   such that simple queries can be done without having to scan all records
- */
-class DocumentStorage {
-  constructor(options = {}) {
-    options.isolated = options.isolated ?? false;
-    options.scope = options.scope ?? 'default';
-    const fileName = `${WARP_DRIVE_STORAGE_FILE_NAME}@version_${WARP_DRIVE_STORAGE_VERSION}:${options.scope}`;
-    if (!options.isolated && Storages.has(fileName)) {
-      const storage = Storages.get(fileName);
-      if (storage) {
-        this._storage = storage.deref();
-        return;
-      }
-    }
-    const storage = new InternalDocumentStorage({
-      scope: fileName,
-      isolated: options.isolated
-    });
-    this._storage = storage;
-    if (!options.isolated) {
-      Storages.set(fileName, new WeakRef(storage));
-    }
-  }
-  getDocument(key) {
-    return this._storage.getDocument(key);
-  }
-  putDocument(document, resourceCollector) {
-    return this._storage.putDocument(document, resourceCollector);
-  }
-  putResources(document, resourceCollector) {
-    return this._storage.putResources(document, resourceCollector);
-  }
-  clear(reset) {
-    return this._storage.clear(reset);
-  }
-}
-
-export { DocumentStorage };
+export { DocumentStorage };

package/dist/unpkg/dev/image-fetch.js

@@ -1,74 +1,107 @@
-import { createDeferred } from '@warp-drive-mirror/core/request';
+import { createDeferred } from "@warp-drive-mirror/core/request";
 
-// @ts-expect-error untyped global
-const isServerEnv = typeof FastBoot !== 'undefined';
-class ImageFetch {
-  constructor(worker) {
-    this.threadId = isServerEnv ? '' : crypto.randomUUID();
-    this.pending = new Map();
-    this.cache = new Map();
-    this.worker = worker;
-    if (!isServerEnv) {
-      const fn = event => {
-        const {
-          type,
-          url
-        } = event.data;
-        const deferred = this.cleanupRequest(url);
-        if (!deferred) {
-          return;
-        }
-        if (type === 'success-response') {
-          deferred.resolve(url);
-          return;
-        }
-        if (type === 'error-response') {
-          deferred.reject(null);
-          return;
-        }
-      };
-      if (worker instanceof SharedWorker) {
-        worker.port.postMessage({
-          type: 'connect',
-          thread: this.threadId
-        });
-        worker.port.onmessage = fn;
-      } else if (worker) {
-        this.channel = new MessageChannel();
-        worker.postMessage({
-          type: 'connect',
-          thread: this.threadId
-        }, [this.channel.port2]);
-        this.channel.port1.onmessage = fn;
-      }
-    }
-  }
-  cleanupRequest(url) {
-    const deferred = this.pending.get(url);
-    this.pending.delete(url);
-    return deferred;
-  }
-  _send(event) {
-    // eslint-disable-next-line @typescript-eslint/no-unused-expressions
-    this.worker instanceof SharedWorker ? this.worker.port.postMessage(event) : this.channel.port1.postMessage(event);
-  }
-  load(url) {
-    if (isServerEnv) {
-      return Promise.resolve(url);
-    }
-    const objectUrl = this.cache.get(url);
-    if (objectUrl) {
-      return Promise.resolve(objectUrl);
-    }
-    const deferred = createDeferred();
-    this.pending.set(url, deferred);
-    this._send({
-      type: 'load',
-      thread: this.threadId,
-      url
-    });
-    return deferred.promise;
-  }
-}
+//#region src/image-worker/fetch.ts
+const isServerEnv = typeof FastBoot !== "undefined";
+/**
+* Main-thread client for an {@link ImageWorker}. Sends image `load`
+* requests to a `Worker` or `SharedWorker` running an `ImageWorker`.
+*
+* In FastBoot/SSR, or when constructed with a `null` worker, `ImageFetch`
+* skips worker communication entirely: {@link ImageFetch.load} resolves
+* immediately with the given url.
+*
+* A plain `Worker` is only accepted when running in a `TESTING` build;
+* production usage requires a `SharedWorker`.
+*
+* @public
+*/
+var ImageFetch = class {
+	/**
+	* @param worker - the `Worker` or `SharedWorker` running an
+	* {@link ImageWorker}, or `null` to disable worker communication (e.g.
+	* in FastBoot/SSR).
+	*/
+	constructor(worker) {
+		this.threadId = isServerEnv ? "" : crypto.randomUUID();
+		this.pending = /* @__PURE__ */ new Map();
+		this.cache = /* @__PURE__ */ new Map();
+		((test) => {
+			if (!test) throw new Error(`Expected a SharedWorker instance`);
+		})(true);
+		this.worker = worker;
+		if (!isServerEnv) {
+			const fn = (event) => {
+				const { type, url } = event.data;
+				const deferred = this.cleanupRequest(url);
+				if (!deferred) return;
+				if (type === "success-response") {
+					const { objectUrl } = event.data;
+					this.cache.set(url, objectUrl);
+					deferred.resolve(objectUrl);
+					return;
+				}
+				if (type === "error-response") {
+					deferred.reject(null);
+					return;
+				}
+			};
+			if (worker instanceof SharedWorker) {
+				worker.port.postMessage({
+					type: "connect",
+					thread: this.threadId
+				});
+				worker.port.onmessage = fn;
+			} else if (worker) {
+				this.channel = new MessageChannel();
+				worker.postMessage({
+					type: "connect",
+					thread: this.threadId
+				}, [this.channel.port2]);
+				this.channel.port1.onmessage = fn;
+			}
+		}
+	}
+	cleanupRequest(url) {
+		const deferred = this.pending.get(url);
+		this.pending.delete(url);
+		return deferred;
+	}
+	_send(event) {
+		this.worker instanceof SharedWorker ? this.worker.port.postMessage(event) : this.channel.port1.postMessage(event);
+	}
+	/**
+	* Requests that the given image url be loaded by the connected
+	* {@link ImageWorker}, resolving with an object url for the fetched
+	* image's blob once the worker responds (or immediately with the
+	* original `url`, in SSR/FastBoot or when this instance was constructed
+	* with a `null` worker).
+	*
+	* The resolved object url is cached in-memory by source url on this
+	* instance, so subsequent calls for the same url resolve immediately
+	* without another round-trip to the worker.
+	*
+	* Calling `load` again for a url that is already in-flight (not yet
+	* cached) on this instance replaces the pending request rather than
+	* joining it — only the most recently issued call for a given url will
+	* resolve.
+	*
+	* @public
+	*/
+	load(url) {
+		if (isServerEnv) return Promise.resolve(url);
+		const objectUrl = this.cache.get(url);
+		if (objectUrl) return Promise.resolve(objectUrl);
+		const deferred = createDeferred();
+		this.pending.set(url, deferred);
+		this._send({
+			type: "load",
+			thread: this.threadId,
+			url
+		});
+		return deferred.promise;
+	}
+};
 
+//#endregion
 export { ImageFetch };
+//# sourceMappingURL=image-fetch.js.map

package/dist/unpkg/dev/image-fetch.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"image-fetch.js","names":["createDeferred","isServerEnv","FastBoot","ImageFetch","constructor","worker","threadId","crypto","randomUUID","pending","Map","cache","isTesting","test","Error","SharedWorker","fn","event","type","url","data","deferred","cleanupRequest","objectUrl","set","resolve","reject","port","postMessage","thread","onmessage","channel","MessageChannel","port2","port1","get","delete","_send","load","Promise","promise"],"sources":["../../../src/image-worker/fetch.ts"],"sourcesContent":["import { TESTING } from '@warp-drive-mirror/core/build-config/env';\nimport { assert } from '@warp-drive-mirror/core/build-config/macros';\nimport type { Deferred } from '@warp-drive-mirror/core/request';\nimport { createDeferred } from '@warp-drive-mirror/core/request';\n\nimport type { MainThreadEvent, RequestEventData } from './types';\n// oxlint-disable-next-line no-unused-vars\nimport type { ImageWorker } from './worker';\n\nexport interface FastBoot {\n  require(moduleName: string): unknown;\n  isFastBoot: boolean;\n  request: Request;\n}\n\n// @ts-expect-error untyped global\nconst isServerEnv = typeof FastBoot !== 'undefined';\n\n/**\n * Main-thread client for an {@link ImageWorker}. Sends image `load`\n * requests to a `Worker` or `SharedWorker` running an `ImageWorker`.\n *\n * In FastBoot/SSR, or when constructed with a `null` worker, `ImageFetch`\n * skips worker communication entirely: {@link ImageFetch.load} resolves\n * immediately with the given url.\n *\n * A plain `Worker` is only accepted when running in a `TESTING` build;\n * production usage requires a `SharedWorker`.\n *\n * @public\n */\nexport class ImageFetch {\n  declare worker: Worker | SharedWorker;\n  declare threadId: string;\n  declare pending: Map<string, Deferred<string>>;\n  declare channel: MessageChannel;\n  declare cache: Map<string, string>;\n\n  /**\n   * @param worker - the `Worker` or `SharedWorker` running an\n   * {@link ImageWorker}, or `null` to disable worker communication (e.g.\n   * in FastBoot/SSR).\n   */\n  constructor(worker: Worker | SharedWorker | null) {\n    this.threadId = isServerEnv ? '' : crypto.randomUUID();\n    this.pending = new Map();\n    this.cache = new Map();\n\n    const isTesting = TESTING ? true : false;\n    assert(`Expected a SharedWorker instance`, isTesting || isServerEnv || worker instanceof SharedWorker);\n    this.worker = worker as SharedWorker;\n\n    if (!isServerEnv) {\n      const fn = (event: MainThreadEvent) => {\n        const { type, url } = event.data;\n        const deferred = this.cleanupRequest(url);\n        if (!deferred) {\n          return;\n        }\n\n        if (type === 'success-response') {\n          const { objectUrl } = event.data;\n          this.cache.set(url, objectUrl);\n          deferred.resolve(objectUrl);\n          return;\n        }\n\n        if (type === 'error-response') {\n          deferred.reject(null);\n          return;\n        }\n      };\n\n      if (worker instanceof SharedWorker) {\n        worker.port.postMessage({ type: 'connect', thread: this.threadId });\n        worker.port.onmessage = fn;\n      } else if (worker) {\n        this.channel = new MessageChannel();\n        worker.postMessage({ type: 'connect', thread: this.threadId }, [this.channel.port2]);\n\n        this.channel.port1.onmessage = fn;\n      }\n    }\n  }\n\n  cleanupRequest(url: string): Deferred<string> | undefined {\n    const deferred = this.pending.get(url);\n    this.pending.delete(url);\n\n    return deferred;\n  }\n\n  _send(event: RequestEventData): void {\n    // oxlint-disable-next-line no-unused-expressions\n    this.worker instanceof SharedWorker ? this.worker.port.postMessage(event) : this.channel.port1.postMessage(event);\n  }\n\n  /**\n   * Requests that the given image url be loaded by the connected\n   * {@link ImageWorker}, resolving with an object url for the fetched\n   * image's blob once the worker responds (or immediately with the\n   * original `url`, in SSR/FastBoot or when this instance was constructed\n   * with a `null` worker).\n   *\n   * The resolved object url is cached in-memory by source url on this\n   * instance, so subsequent calls for the same url resolve immediately\n   * without another round-trip to the worker.\n   *\n   * Calling `load` again for a url that is already in-flight (not yet\n   * cached) on this instance replaces the pending request rather than\n   * joining it — only the most recently issued call for a given url will\n   * resolve.\n   *\n   * @public\n   */\n  load(url: string): Promise<string> {\n    if (isServerEnv) {\n      return Promise.resolve(url);\n    }\n\n    const objectUrl = this.cache.get(url);\n    if (objectUrl) {\n      return Promise.resolve(objectUrl);\n    }\n\n    const deferred = createDeferred<string>();\n    this.pending.set(url, deferred);\n    this._send({ type: 'load', thread: this.threadId, url });\n    return deferred.promise;\n  }\n}\n"],"mappings":";;;AAgBA,MAAMC,cAAc,OAAOC,aAAa;;;;;;;;;;;;;;AAexC,IAAaC,aAAb,MAAwB;;;;;;CAYtBC,YAAYC,QAAsC;EAChD,KAAKC,WAAWL,cAAc,KAAKM,OAAOC,WAAW;EACrD,KAAKC,0BAAU,IAAIC,IAAI;EACvB,KAAKC,wBAAQ,IAAID,IAAI;EAGrB,EAAAG,SAAA;GAAA,IAAA,CAAAA,MAAA,MAAA,IAAAC,MAAO,kCAAkC;EAAA,EAAA,CAAEF,IAA0D;EACrG,KAAKP,SAASA;EAEd,IAAI,CAACJ,aAAa;GAChB,MAAMe,MAAMC,UAA2B;IACrC,MAAM,EAAEC,MAAMC,QAAQF,MAAMG;IAC5B,MAAMC,WAAW,KAAKC,eAAeH,GAAG;IACxC,IAAI,CAACE,UACH;IAGF,IAAIH,SAAS,oBAAoB;KAC/B,MAAM,EAAEK,cAAcN,MAAMG;KAC5B,KAAKT,MAAMa,IAAIL,KAAKI,SAAS;KAC7BF,SAASI,QAAQF,SAAS;KAC1B;IACF;IAEA,IAAIL,SAAS,kBAAkB;KAC7BG,SAASK,OAAO,IAAI;KACpB;IACF;GACF;GAEA,IAAIrB,kBAAkBU,cAAc;IAClCV,OAAOsB,KAAKC,YAAY;KAAEV,MAAM;KAAWW,QAAQ,KAAKvB;IAAS,CAAC;IAClED,OAAOsB,KAAKG,YAAYd;GAC1B,OAAO,IAAIX,QAAQ;IACjB,KAAK0B,UAAU,IAAIC,eAAe;IAClC3B,OAAOuB,YAAY;KAAEV,MAAM;KAAWW,QAAQ,KAAKvB;IAAS,GAAG,CAAC,KAAKyB,QAAQE,KAAK,CAAC;IAEnF,KAAKF,QAAQG,MAAMJ,YAAYd;GACjC;EACF;CACF;CAEAM,eAAeH,KAA2C;EACxD,MAAME,WAAW,KAAKZ,QAAQ0B,IAAIhB,GAAG;EACrC,KAAKV,QAAQ2B,OAAOjB,GAAG;EAEvB,OAAOE;CACT;CAEAgB,MAAMpB,OAA+B;EAEnC,KAAKZ,kBAAkBU,eAAe,KAAKV,OAAOsB,KAAKC,YAAYX,KAAK,IAAI,KAAKc,QAAQG,MAAMN,YAAYX,KAAK;CAClH;;;;;;;;;;;;;;;;;;;CAoBAqB,KAAKnB,KAA8B;EACjC,IAAIlB,aACF,OAAOsC,QAAQd,QAAQN,GAAG;EAG5B,MAAMI,YAAY,KAAKZ,MAAMwB,IAAIhB,GAAG;EACpC,IAAII,WACF,OAAOgB,QAAQd,QAAQF,SAAS;EAGlC,MAAMF,WAAWrB,eAAuB;EACxC,KAAKS,QAAQe,IAAIL,KAAKE,QAAQ;EAC9B,KAAKgB,MAAM;GAAEnB,MAAM;GAAQW,QAAQ,KAAKvB;GAAUa;EAAI,CAAC;EACvD,OAAOE,SAASmB;CAClB;AACF"}