@proteinjs/db-file 1.8.4 → 1.9.0

package/dist/src/FileCopyForOthers.js

@@ -0,0 +1,62 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FileCopyRefused = exports.getFileCopyForOthers = void 0;
+var reflection_1 = require("@proteinjs/reflection");
+var getFileCopyForOthers = function () {
+    return reflection_1.SourceRepository.get().object('@proteinjs/db-file/FileCopyForOthers');
+};
+exports.getFileCopyForOthers = getFileCopyForOthers;
+/**
+ * What a non-owner's read becomes when the registered maker could not make a copy: the file is
+ * served to no one but its owner. The seam's own cause, thrown by `FileStorage` in place of
+ * whatever the maker threw (the maker's own one-line reason kept as `reason`) and answered by
+ * `FileStorage` itself, once for every door — the browser service, `GET /file/:id`, a server-side
+ * reader — as a 404 `ServiceRefusal` saying only `File not found`, so a door never meets it: a
+ * deliberate refusal every door tells from a failure the same way. Its message and `reason` stay
+ * on the server (`FileStorage` logs them at WARN); a caller reads the words a missing file gets.
+ * Read by shape ({@link FileCopyRefused.is}), so it holds across duplicate copies of this package.
+ */
+var FileCopyRefused = /** @class */ (function (_super) {
+    __extends(FileCopyRefused, _super);
+    function FileCopyRefused(fileId, cause) {
+        var _this = this;
+        var reason = FileCopyRefused.plain(cause);
+        _this = _super.call(this, "File ".concat(fileId, " is not available to anyone but its owner").concat(reason ? ": ".concat(reason) : '')) || this;
+        _this.name = FileCopyRefused.NAME;
+        Object.setPrototypeOf(_this, FileCopyRefused.prototype);
+        _this.fileId = fileId;
+        _this.reason = reason;
+        return _this;
+    }
+    FileCopyRefused.is = function (error) {
+        return (error === null || error === void 0 ? void 0 : error.name) === FileCopyRefused.NAME;
+    };
+    FileCopyRefused.plain = function (cause) {
+        var message = cause instanceof Error ? cause.message : typeof cause === 'string' ? cause : '';
+        var line = message.replace(/\s+/g, ' ').trim();
+        return line.length > FileCopyRefused.MAX_REASON_CHARS
+            ? "".concat(line.slice(0, FileCopyRefused.MAX_REASON_CHARS), "\u2026")
+            : line;
+    };
+    FileCopyRefused.NAME = 'FileCopyRefused';
+    /** Free text that reaches a message is one line and bounded. */
+    FileCopyRefused.MAX_REASON_CHARS = 300;
+    return FileCopyRefused;
+}(Error));
+exports.FileCopyRefused = FileCopyRefused;
+//# sourceMappingURL=FileCopyForOthers.js.map

package/dist/src/FileCopyForOthers.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"FileCopyForOthers.js","sourceRoot":"","sources":["../../src/FileCopyForOthers.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;AAAA,oDAAmE;AA8B5D,IAAM,oBAAoB,GAAG;IAClC,OAAA,6BAAgB,CAAC,GAAG,EAAE,CAAC,MAAM,CAAoB,sCAAsC,CAAC;AAAxF,CAAwF,CAAC;AAD9E,QAAA,oBAAoB,wBAC0D;AAE3F;;;;;;;;;GASG;AACH;IAAqC,mCAAK;IAOxC,yBAAY,MAAc,EAAE,KAAc;QAA1C,iBAOC;QANC,IAAM,MAAM,GAAG,eAAe,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;gBAC5C,kBAAM,eAAQ,MAAM,sDAA4C,MAAM,CAAC,CAAC,CAAC,YAAK,MAAM,CAAE,CAAC,CAAC,CAAC,EAAE,CAAE,CAAC;QAC9F,KAAI,CAAC,IAAI,GAAG,eAAe,CAAC,IAAI,CAAC;QACjC,MAAM,CAAC,cAAc,CAAC,KAAI,EAAE,eAAe,CAAC,SAAS,CAAC,CAAC;QACvD,KAAI,CAAC,MAAM,GAAG,MAAM,CAAC;QACrB,KAAI,CAAC,MAAM,GAAG,MAAM,CAAC;;IACvB,CAAC;IAEM,kBAAE,GAAT,UAAU,KAAc;QACtB,OAAO,CAAC,KAA+C,aAA/C,KAAK,uBAAL,KAAK,CAA4C,IAAI,MAAK,eAAe,CAAC,IAAI,CAAC;IACzF,CAAC;IAEc,qBAAK,GAApB,UAAqB,KAAc;QACjC,IAAM,OAAO,GAAG,KAAK,YAAY,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,OAAO,KAAK,KAAK,QAAQ,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,CAAC;QAChG,IAAM,IAAI,GAAG,OAAO,CAAC,OAAO,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC,IAAI,EAAE,CAAC;QACjD,OAAO,IAAI,CAAC,MAAM,GAAG,eAAe,CAAC,gBAAgB;YACnD,CAAC,CAAC,UAAG,IAAI,CAAC,KAAK,CAAC,CAAC,EAAE,eAAe,CAAC,gBAAgB,CAAC,WAAG;YACvD,CAAC,CAAC,IAAI,CAAC;IACX,CAAC;IAzBuB,oBAAI,GAAG,iBAAiB,CAAC;IACjD,gEAAgE;IACxC,gCAAgB,GAAG,GAAG,CAAC;IAwBjD,sBAAC;CAAA,AA3BD,CAAqC,KAAK,GA2BzC;AA3BY,0CAAe"}

package/dist/src/FileStorage.d.ts

@@ -1,7 +1,10 @@
+/// <reference types="node" />
+/// <reference types="node" />
 import { ScopedRecord } from '@proteinjs/user';
 import { File } from './tables/FileTable';
 import { FileStorageService } from './services/FileStorageService';
 import { FileStorageDriver } from './FileStorageDriver';
+import { FileVariantKind } from './FileVariantMaker';
 import { Loadable } from '@proteinjs/reflection';
 /**
  * A convenience factory function so code using this is portable (can be used in server or browser).
@@ -21,11 +24,14 @@ export interface DefaultFileStorageDriverFactory extends Loadable {
  */
 export declare class FileStorage implements FileStorageService {
     private static driver;
+    /** The read path's derivations running in this process, by file and kind — see {@link deriveOnce}. */
+    private static derivations;
     serviceMetadata: {
         auth: {
             allUsers: boolean;
         };
     };
+    private logger;
     /**
      * The `FileStorageDriver` for this process — provided by the `DefaultFileStorageDriverFactory`
      * implementation, defaulting to the `DbFileStorageDriver`. One resolution for every byte
@@ -44,15 +50,46 @@ export declare class FileStorage implements FileStorageService {
      * Retrieves the metadata of a given file — THE file-read access decision every serving path
      * derives from (`/file/:id`, signed-URL minting, the browser service).
      *
-     * Two legs: the caller's own file resolves by the SCOPED read; when that misses, the
-     * shared-content leg asks the registered {@link FileReachabilityResolver}s whether the caller
-     * can read a row that REFERENCES the file (a shared thought's media node) — content access
-     * confers file access, through the content's own grant-filtered read, never by widening file
-     * scope. No resolver vouching means the miss stands. Reads only: writes/deletes stay scoped.
+     * Three legs, cheapest first: the caller's own file resolves by the SCOPED read. When that
+     * misses, the derived leg: a VARIANT the seam made (`File.variantOf`) is readable by whoever
+     * can read its original — this same decision, asked of the original — so a variant derived
+     * after the content was placed (no content row names it) is reachable by exactly the readers
+     * of the file it was made from; one system point read decides whether the row is a variant at
+     * all. Last, the shared-content leg asks the registered {@link FileReachabilityResolver}s
+     * whether the caller can read a row that REFERENCES the file (a shared thought's media node) —
+     * content access confers file access, through the content's own grant-filtered read, never by
+     * widening file scope. No leg vouching means the miss stands. Reads only: writes/deletes stay
+     * scoped.
      * @param fileId - The `id` of the file.
      * @returns The file metadata, or `undefined` when the caller can neither own nor reach it.
      */
     getFile(fileId: string): Promise<File>;
+    /**
+     * The variant of this kind of a file — the derived File the row names, or one made now, ONCE,
+     * by the registered {@link FileVariantMaker} (the read path's door, behind
+     * `GET /file/:id/variant/:kind`: a file made before the seam existed, or by a producer that did
+     * not derive it, gets its variant on the first request from a surface that draws it; every
+     * later request is served the same row without the maker). Server-only, like `getSignedUrl` —
+     * the browser asks by URL, never by service call. Access is the original's ({@link getFile});
+     * the variant is stored as the owner's own File whoever's read made it, and is served like any
+     * File afterwards — with the same non-owner copy rule.
+     * @returns The variant's File row, or `undefined` when the caller cannot read the original, no
+     *          maker is registered, the maker does not apply to this file for this kind, or the
+     *          maker could not make it of these bytes (the consumer then draws the original).
+     */
+    getVariant(fileId: string, kind: FileVariantKind): Promise<File | undefined>;
+    /**
+     * Make and store every variant the registered maker applies to, with the original's bytes in
+     * hand (the ingest's door — one decode of bytes just stored, never a re-read). Each is named on
+     * the row; a kind the maker does not apply to is left unset (the read path may derive it later
+     * if the maker's rule changes). With no maker registered nothing is made.
+     * @returns The caller's file row with each variant made here named on it (the row as the caller
+     *          holds it, not a re-read — an unset column stays unset), and the variant Files made.
+     */
+    deriveVariants(file: File, bytes: Buffer): Promise<{
+        file: File;
+        variants: Partial<Record<FileVariantKind, File>>;
+    }>;
     /**
      * Retrieves the data chunks associated with a given file.
      *
@@ -61,24 +98,49 @@ export declare class FileStorage implements FileStorageService {
      * exactly as reachable as the row that names them. The gate lives here because this is the
      * browser-facing service boundary (`FileStorageService` is `allUsers`) and the driver byte ops
      * below are deliberately unscoped. Server-side doors that make their OWN documented access
-     * decision (the avatar route, issue/ticket attachment doors) read bytes through
-     * `FileStorage.getDriver()` instead.
+     * decision (an attachment door keyed by a record's linkage, say) serve through
+     * {@link getAuthorizedFileData} — the same owner-or-copy bytes, without this gate.
+     *
+     * WHICH bytes: the owner's read serves the original; anyone else's — a read that reached the
+     * file through the shared-content leg — serves the {@link FileCopyForOthers} copy
+     * ({@link servedFileId}): the same substitution `getSignedUrl` makes, so the proxy route, the
+     * signed-URL route and every server-side reader of this door agree.
      * @param fileId - The `id` of the file.
      * @returns The file data as a single string.
-     * @throws When the file row does not exist or is not readable by the caller — the same named
-     *         miss either way, so existence is not leaked to unauthorized callers.
+     * @throws ServiceRefusal (404, `File not found`) when the file row does not exist or is not
+     *         readable by the caller, and when the caller is not the owner and no copy can be made
+     *         ({@link servedFileId}) — ONE answer for all three ({@link notFound}), so no door tells
+     *         a missing file from one this caller may not have.
      */
     getFileData(fileId: string): Promise<string>;
+    /**
+     * The bytes THIS caller is served for a file a server-side door has ALREADY decided the caller
+     * may read, by its own documented rule (an attachment door keyed by a record's linkage, say —
+     * a read neither the caller's scope nor a {@link FileReachabilityResolver} would open). The
+     * door vouches for access; this decides WHICH bytes, exactly as {@link getFileData} does: the
+     * original for the file's owner, the {@link FileCopyForOthers} copy for anyone else — the same
+     * copy, made once and named on the row, that every other door serves them. Server-only (not
+     * part of the browser-facing `FileStorageService`), so the rule that opens the file stays the
+     * door's.
+     * @param file - The file's row, as the door read it (its `scope` names the owner).
+     * @returns The file data as a single string.
+     * @throws ServiceRefusal (404) when the caller is not the owner and no copy can be made — the same
+     *         refusal every door gives ({@link servedFileId}).
+     */
+    getAuthorizedFileData(file: File): Promise<string>;
     /**
      * Mint a short-lived, read-only URL for the file's bytes (server-only; not part of the
      * browser-facing `FileStorageService`). A signed URL is a bearer capability, so minting
      * verifies the caller can read the file row (the two-legged {@link getFile} read — own scope
-     * or shared-content reachability) before signing.
+     * or shared-content reachability) before signing — and signs the bytes THAT caller is served:
+     * the original for the owner, the {@link FileCopyForOthers} copy for anyone else.
      * @param fileId - The `id` of the file.
      * @param options.ttlMs - How long the URL stays valid; the driver applies its default when omitted.
      * @returns The signed URL, or `undefined` when the driver has no external URL space
      *          (`DbFileStorageDriver`) — the caller then serves bytes through the proxy route.
-     * @throws When the file row does not exist or is not readable by the caller.
+     * @throws ServiceRefusal (404, `File not found`) when the file row does not exist or is not
+     *         readable by the caller, and when the caller is not the owner and no copy can be made —
+     *         the one answer {@link getFileData} gives ({@link notFound}).
      */
     getSignedUrl(fileId: string, options?: {
         ttlMs?: number;
@@ -90,6 +152,10 @@ export declare class FileStorage implements FileStorageService {
      * (the same authorization a scoped row update enforces). Deliberately STRICTER than
      * {@link getFileData}: the {@link FileReachabilityResolver} leg widens READS only, so a
      * share recipient who can read the bytes still cannot write them.
+     *
+     * New bytes make every derived File stale — the copy others were served, the preview, the
+     * stage variant: each is dropped here — the row forgets it, then its row (and, through the
+     * delete watcher, its bytes) goes — and the next read that wants one makes a fresh one.
      * @param fileId - The `id` of the file.
      * @param data - The new data string to replace the existing data.
      * @throws When the file row does not exist or is not writable by the caller — the same named
@@ -109,5 +175,73 @@ export declare class FileStorage implements FileStorageService {
      * @param fileId - The `id` of the file to delete.
      */
     deleteFile(fileId: string): Promise<void>;
+    /**
+     * The id whose bytes this caller is served: the file's own for its owner, or for a file with
+     * no maker (or one the maker does not apply to); otherwise the {@link FileCopyForOthers} copy —
+     * the one already named on the row, or made now, once, and named for every later read.
+     *
+     * ONE REFUSAL, EVERY DOOR: when no copy can be made (the seam's {@link FileCopyRefused}), the file
+     * is served to no one but its owner, so to this caller it is not there — a
+     * `ServiceRefusal(404, 'File not found')`, thrown here so the browser service, `GET /file/:id` in
+     * both its shapes and the server-side door answer the same by construction: the service router
+     * answers 404 `{ error: 'File not found' }`, the executor logs one WARN (a refusal, never a
+     * failure), the route answers `404 File not found` — the same answer, at every door, as a row the
+     * caller cannot read ({@link notFound}). The refusal carries no reason, file id or owner: the
+     * maker's reason is the server's, logged here in one WARN, so nothing a caller reads tells a
+     * refused copy from a file that is not there.
+     */
+    private servedFileId;
+    /**
+     * Whether the caller is the file's owner — the row's `scope` is the owner (the scoped read
+     * {@link getFile} makes first is exactly `scope = the caller`), so a row {@link getFile} handed
+     * back whose scope is someone else's was reached through the shared-content leg. A row with no
+     * owner recorded serves as itself: there is no one to withhold it from.
+     */
+    private ownedByCaller;
+    /**
+     * Makes the copy (the maker's bytes, from the original's), stores it as a File in the owner's
+     * scope and names it on the original's row. Two non-owners reading at once may both get here:
+     * the row's word wins — decided in ONE transaction (the read of the row and the write of its
+     * word together, so racing writers are serialized and the loser's transaction, retried, finds
+     * the winner named) — and a copy that lost is deleted after the commit, the first is served.
+     */
+    private makeCopyForOthers;
+    /**
+     * The read path's derivation, ONCE per file and kind at a time in this process: the readers
+     * that ask for the same absent variant while one derives (a shared document opened by many on
+     * one tick — every face asks the same URL) wait for that derivation's answer instead of each
+     * reading the original, encoding it and storing an object the row's word would then discard.
+     * Across processes the row's word in one transaction ({@link makeVariant}) still decides: this
+     * bounds the cost, that bounds the outcome. A maker that cannot make the variant of these
+     * bytes (a picture its decoder cannot read) answers `undefined` — nothing is stored, the reader
+     * draws the file itself, the next reader asks again — said in the log, never as a failed read;
+     * any other failure (the store, the database) is the reader's as it would be for any File.
+     */
+    private deriveOnce;
+    /**
+     * Makes the variant (the maker's answer from the original's bytes), stores it as a File in the
+     * OWNER's scope naming its original, and names it on the original's row. Two readers may derive
+     * the same kind at once: the row's word wins — decided in ONE transaction, exactly as the copy
+     * for others is named — and the variant that lost is deleted after the commit. The maker's own
+     * failure (it could not make the variant of these bytes) is thrown as {@link FileVariantNotMade}
+     * with the maker's reason, so the doors can tell it from a failure of the store or the database;
+     * nothing is stored on it.
+     * @returns The id of the variant the row names.
+     */
+    private makeVariant;
+    /**
+     * The row forgets each derived File first (nothing serves a copy or a variant the row no longer
+     * names), then their rows go — the bytes with them, through the delete watcher: the copy for
+     * others and every variant kind, one rule.
+     */
+    private dropDerivedFiles;
+    /**
+     * THE answer a byte door gives a caller who does not get the file's bytes — a row that is not
+     * there, one this caller cannot read, or a copy that cannot be made for them: a 404 refusal in
+     * the same words every time, never the id, so the answer reveals nothing about existence (the
+     * service router sends `{ error: 'File not found' }`, the executor logs it at WARN, the routes
+     * send `404 File not found`).
+     */
+    private static notFound;
 }
 //# sourceMappingURL=FileStorage.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"FileStorage.d.ts","sourceRoot":"","sources":["../../src/FileStorage.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAoC,MAAM,iBAAiB,CAAC;AACjF,OAAO,EAAE,IAAI,EAAE,MAAM,oBAAoB,CAAC;AAE1C,OAAO,EAAE,kBAAkB,EAAyB,MAAM,+BAA+B,CAAC;AAC1F,OAAO,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAC;AAExD,OAAO,EAAE,QAAQ,EAAoB,MAAM,uBAAuB,CAAC;AAInE;;;KAGK;AACL,eAAO,MAAM,cAAc,mBACiE,CAAC;AAE7F;;GAEG;AACH,MAAM,WAAW,+BAAgC,SAAQ,QAAQ;IAC/D,SAAS,IAAI,iBAAiB,CAAC;CAChC;AAED;;;;GAIG;AACH,qBAAa,WAAY,YAAW,kBAAkB;IACpD,OAAO,CAAC,MAAM,CAAC,MAAM,CAAoB;IAElC,eAAe;;;;MAIpB;IAEF;;;;;OAKG;IACH,MAAM,CAAC,SAAS,IAAI,iBAAiB;IAkBrC;;;;;OAKG;IACG,UAAU,CAAC,YAAY,EAAE,IAAI,CAAC,IAAI,EAAE,MAAM,YAAY,CAAC,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAO/F;;;;;;;;;;;OAWG;IACG,OAAO,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAkB5C;;;;;;;;;;;;;;OAcG;IACG,WAAW,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;IASlD;;;;;;;;;;OAUG;IACG,YAAY,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE;QAAE,KAAK,CAAC,EAAE,MAAM,CAAA;KAAE,GAAG,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC;IAc7F;;;;;;;;;;;OAWG;IACG,cAAc,CAAC,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAUjE;;;OAGG;IACG,UAAU,CAAC,IAAI,EAAE,IAAI,CAAC,IAAI,EAAE,MAAM,YAAY,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC;IAUrE;;;;;;OAMG;IACG,UAAU,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;CAIhD"}
+{"version":3,"file":"FileStorage.d.ts","sourceRoot":"","sources":["../../src/FileStorage.ts"],"names":[],"mappings":";;AACA,OAAO,EAAE,YAAY,EAA8C,MAAM,iBAAiB,CAAC;AAC3F,OAAO,EAAE,IAAI,EAAE,MAAM,oBAAoB,CAAC;AAE1C,OAAO,EAAE,kBAAkB,EAAyB,MAAM,+BAA+B,CAAC;AAC1F,OAAO,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAC;AAGxD,OAAO,EAGL,eAAe,EAGhB,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EAAE,QAAQ,EAAoB,MAAM,uBAAuB,CAAC;AAKnE;;;KAGK;AACL,eAAO,MAAM,cAAc,mBACiE,CAAC;AAE7F;;GAEG;AACH,MAAM,WAAW,+BAAgC,SAAQ,QAAQ;IAC/D,SAAS,IAAI,iBAAiB,CAAC;CAChC;AAED;;;;GAIG;AACH,qBAAa,WAAY,YAAW,kBAAkB;IACpD,OAAO,CAAC,MAAM,CAAC,MAAM,CAAoB;IACzC,sGAAsG;IACtG,OAAO,CAAC,MAAM,CAAC,WAAW,CAAkD;IAErE,eAAe;;;;MAIpB;IACF,OAAO,CAAC,MAAM,CAA+C;IAE7D;;;;;OAKG;IACH,MAAM,CAAC,SAAS,IAAI,iBAAiB;IAkBrC;;;;;OAKG;IACG,UAAU,CAAC,YAAY,EAAE,IAAI,CAAC,IAAI,EAAE,MAAM,YAAY,CAAC,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAO/F;;;;;;;;;;;;;;;;OAgBG;IACG,OAAO,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IA4B5C;;;;;;;;;;;;OAYG;IACG,UAAU,CAAC,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,eAAe,GAAG,OAAO,CAAC,IAAI,GAAG,SAAS,CAAC;IAiBlF;;;;;;;OAOG;IACG,cAAc,CAClB,IAAI,EAAE,IAAI,EACV,KAAK,EAAE,MAAM,GACZ,OAAO,CAAC;QAAE,IAAI,EAAE,IAAI,CAAC;QAAC,QAAQ,EAAE,OAAO,CAAC,MAAM,CAAC,eAAe,EAAE,IAAI,CAAC,CAAC,CAAA;KAAE,CAAC;IAgB5E;;;;;;;;;;;;;;;;;;;;;OAqBG;IACG,WAAW,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;IASlD;;;;;;;;;;;;;OAaG;IACG,qBAAqB,CAAC,IAAI,EAAE,IAAI,GAAG,OAAO,CAAC,MAAM,CAAC;IAIxD;;;;;;;;;;;;;OAaG;IACG,YAAY,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE;QAAE,KAAK,CAAC,EAAE,MAAM,CAAA;KAAE,GAAG,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC;IAc7F;;;;;;;;;;;;;;;OAeG;IACG,cAAc,CAAC,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAWjE;;;OAGG;IACG,UAAU,CAAC,IAAI,EAAE,IAAI,CAAC,IAAI,EAAE,MAAM,YAAY,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC;IAUrE;;;;;;OAMG;IACG,UAAU,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAK/C;;;;;;;;;;;;;;OAcG;YACW,YAAY;IAyB1B;;;;;OAKG;IACH,OAAO,CAAC,aAAa;IAIrB;;;;;;OAMG;YACW,iBAAiB;IAwC/B;;;;;;;;;;OAUG;IACH,OAAO,CAAC,UAAU;IAyBlB;;;;;;;;;OASG;YACW,WAAW;IAuCzB;;;;OAIG;YACW,gBAAgB;IAiB9B;;;;;;OAMG;IACH,OAAO,CAAC,MAAM,CAAC,QAAQ;CAGxB"}