修改后台权限

node_modules/rettime/build/index.d.mts

@@ -0,0 +1,152 @@
+//#region src/index.d.ts
+type DefaultEventMap = {
+  [eventType: string]: TypedEvent<any, any>;
+};
+/**
+ * Reserved event map containing special event types like '*' for catch-all listeners.
+ */
+type ReservedEventMap = {
+  '*': TypedEvent<any, any, '*'>;
+};
+type IsReservedEvent<Type extends string> = Type extends keyof ReservedEventMap ? true : false;
+interface TypedEvent<DataType = void, ReturnType = void, EventType extends string = string> extends Omit<MessageEvent<DataType>, 'type'> {
+  type: EventType;
+}
+declare const kDefaultPrevented: unique symbol;
+declare const kPropagationStopped: unique symbol;
+declare const kImmediatePropagationStopped: unique symbol;
+declare class TypedEvent<DataType = void, ReturnType = void, EventType extends string = string> extends MessageEvent<DataType> implements TypedEvent<DataType, ReturnType, EventType> {
+  #private;
+  [kDefaultPrevented]: boolean;
+  [kPropagationStopped]?: Emitter<any>;
+  [kImmediatePropagationStopped]?: boolean;
+  constructor(...args: [DataType] extends [void] ? [type: EventType] : [type: EventType, init: {
+    data: DataType;
+  }]);
+  get defaultPrevented(): boolean;
+  preventDefault(): void;
+  stopImmediatePropagation(): void;
+}
+/**
+ * Brands a TypedEvent or its subclass while preserving its (narrower) type.
+ */
+type Brand<Event extends TypedEvent, EventType extends string, Loose extends boolean = false> = Loose extends true ? Event extends TypedEvent<infer Data, any, any> ?
+/**
+* @note Omit the `ReturnType` so emit methods can accept type events
+* where infering the return type is impossible.
+*/
+TypedEvent<Data, any, EventType> & {
+  type: EventType;
+} : never : Event & {
+  type: EventType;
+};
+type InferEventMap<Target extends Emitter<any>> = Target extends Emitter<infer EventMap> ? MergedEventMap<EventMap> : never;
+/**
+ * Extracts only user-defined events, excluding reserved event types.
+ */
+type UserEventMap<EventMap$1 extends DefaultEventMap> = Omit<EventMap$1, keyof ReservedEventMap>;
+/**
+ * Merges the user EventMap with the ReservedEventMap.
+ * The '*' event type accepts a union of all user-defined events.
+ */
+type MergedEventMap<EventMap$1 extends DefaultEventMap> = EventMap$1 & ReservedEventMap;
+/**
+ * Creates a union of all events in the EventMap with their literal type strings.
+ */
+type AllEvents<EventMap$1 extends DefaultEventMap> = { [K in keyof EventMap$1 & string]: Brand<EventMap$1[K], K> }[keyof EventMap$1 & string];
+type TypedListenerOptions = {
+  once?: boolean;
+  signal?: AbortSignal;
+};
+declare namespace Emitter {
+  /**
+   * Returns an appropriate `Event` type for the given event type.
+   *
+   * @example
+   * const emitter = new Emitter<{ greeting: TypedEvent<string> }>()
+   * type GreetingEvent = Emitter.InferEventType<typeof emitter, 'greeting'>
+   * // TypedEvent<string>
+   */
+  type EventType<Target extends Emitter<any>, EventType extends keyof EventMap$1 & string, EventMap$1 extends DefaultEventMap = InferEventMap<Target>> = IsReservedEvent<EventType> extends true ? AllEvents<UserEventMap<EventMap$1>> : Brand<EventMap$1[EventType], EventType>;
+  type EventDataType<Target extends Emitter<any>, EventType extends keyof EventMap$1 & string, EventMap$1 extends DefaultEventMap = InferEventMap<Target>> = EventMap$1[EventType] extends TypedEvent<infer DataType> ? DataType : never;
+  /**
+   * Returns the listener type for the given event type.
+   *
+   * @example
+   * const emitter = new Emitter<{ getTotalPrice: TypedEvent<Cart, number> }>()
+   * type Listener = Emitter.ListenerType<typeof emitter, 'getTotalPrice'>
+   * // (event: TypedEvent<Cart>) => number
+   */
+  type ListenerType<Target extends Emitter<any>, EventType extends keyof EventMap$1 & string, EventMap$1 extends DefaultEventMap = InferEventMap<Target>> = IsReservedEvent<EventType> extends true ? (event: AllEvents<UserEventMap<EventMap$1>>) => void : (event: Emitter.EventType<Target, EventType, EventMap$1>) => Emitter.ListenerReturnType<Target, EventType, EventMap$1> extends [void] ? void : Emitter.ListenerReturnType<Target, EventType, EventMap$1>;
+  /**
+   * Returns the return type of the listener for the given event type.
+   *
+   * @example
+   * const emitter = new Emitter<{ getTotalPrice: TypedEvent<Cart, number> }>()
+   * type ListenerReturnType = Emitter.InferListenerReturnType<typeof emitter, 'getTotalPrice'>
+   * // number
+   */
+  type ListenerReturnType<Target extends Emitter<any>, EventType extends keyof EventMap$1 & string, EventMap$1 extends DefaultEventMap = InferEventMap<Target>> = IsReservedEvent<EventType> extends true ? void : EventMap$1[EventType] extends TypedEvent<unknown, infer ReturnType> ? ReturnType : never;
+}
+declare class Emitter<EventMap$1 extends DefaultEventMap> {
+  #private;
+  constructor();
+  /**
+   * Adds a listener for the given event type.
+   */
+  on<EventType extends keyof MergedEventMap<EventMap$1> & string>(type: EventType, listener: Emitter.ListenerType<typeof this, EventType, MergedEventMap<EventMap$1>>, options?: TypedListenerOptions): typeof this;
+  /**
+   * Adds a one-time listener for the given event type.
+   */
+  once<EventType extends keyof MergedEventMap<EventMap$1> & string>(type: EventType, listener: Emitter.ListenerType<typeof this, EventType, MergedEventMap<EventMap$1>>, options?: Omit<TypedListenerOptions, 'once'>): typeof this;
+  /**
+   * Prepends a listener for the given event type.
+   */
+  earlyOn<EventType extends keyof MergedEventMap<EventMap$1> & string>(type: EventType, listener: Emitter.ListenerType<typeof this, EventType, MergedEventMap<EventMap$1>>, options?: TypedListenerOptions): typeof this;
+  /**
+   * Prepends a one-time listener for the given event type.
+   */
+  earlyOnce<EventType extends keyof MergedEventMap<EventMap$1> & string>(type: EventType, listener: Emitter.ListenerType<typeof this, EventType, MergedEventMap<EventMap$1>>, options?: Omit<TypedListenerOptions, 'once'>): typeof this;
+  /**
+   * Emits the given typed event.
+   *
+   * @returns {boolean} Returns `true` if the event had any listeners, `false` otherwise.
+   */
+  emit<EventType extends keyof EventMap$1 & string>(event: Brand<EventMap$1[EventType], EventType, true>): boolean;
+  /**
+   * Emits the given typed event and returns a promise that resolves
+   * when all the listeners for that event have settled.
+   *
+   * @returns {Promise<Array<Emitter.ListenerReturnType>>} A promise that resolves
+   * with the return values of all listeners.
+   */
+  emitAsPromise<EventType extends keyof EventMap$1 & string>(event: Brand<EventMap$1[EventType], EventType, true>): Promise<Array<Emitter.ListenerReturnType<typeof this, EventType, EventMap$1>>>;
+  /**
+   * Emits the given event and returns a generator that yields
+   * the result of each listener in the order of their registration.
+   * This way, you stop exhausting the listeners once you get the expected value.
+   */
+  emitAsGenerator<EventType extends keyof EventMap$1 & string>(event: Brand<EventMap$1[EventType], EventType, true>): Generator<Emitter.ListenerReturnType<typeof this, EventType, EventMap$1>>;
+  /**
+   * Removes a listener for the given event type.
+   */
+  removeListener<EventType extends keyof MergedEventMap<EventMap$1> & string>(type: EventType, listener: Emitter.ListenerType<typeof this, EventType, MergedEventMap<EventMap$1>>): void;
+  /**
+   * Removes all listeners for the given event type.
+   * If no event type is provided, removes all existing listeners.
+   */
+  removeAllListeners<EventType extends keyof MergedEventMap<EventMap$1> & string>(type?: EventType): void;
+  /**
+   * Returns the list of listeners for the given event type.
+   * If no even type is provided, returns all listeners.
+   */
+  listeners<EventType extends keyof MergedEventMap<EventMap$1> & string>(type?: EventType): Array<Emitter.ListenerType<typeof this, EventType, MergedEventMap<EventMap$1>>>;
+  /**
+   * Returns the number of listeners for the given event type.
+   * If no even type is provided, returns the total number of listeners.
+   */
+  listenerCount<EventType extends keyof MergedEventMap<EventMap$1> & string>(type?: EventType): number;
+}
+//#endregion
+export { DefaultEventMap, Emitter, ReservedEventMap, TypedEvent, TypedListenerOptions };
+//# sourceMappingURL=index.d.mts.map

node_modules/rettime/build/index.mjs

@@ -0,0 +1,225 @@
+import { LensList } from "./lens-list.mjs";
+
+//#region src/index.ts
+const kDefaultPrevented = Symbol("kDefaultPrevented");
+const kPropagationStopped = Symbol("kPropagationStopped");
+const kImmediatePropagationStopped = Symbol("kImmediatePropagationStopped");
+var TypedEvent = class extends MessageEvent {
+	/**
+	* @note Keep a placeholder property with the return type
+	* because the type must be set somewhere in order to be
+	* correctly associated and inferred from the event.
+	*/
+	#returnType;
+	[kDefaultPrevented];
+	[kPropagationStopped];
+	[kImmediatePropagationStopped];
+	constructor(...args) {
+		super(args[0], args[1]);
+		this[kDefaultPrevented] = false;
+	}
+	get defaultPrevented() {
+		return this[kDefaultPrevented];
+	}
+	preventDefault() {
+		super.preventDefault();
+		this[kDefaultPrevented] = true;
+	}
+	stopImmediatePropagation() {
+		/**
+		* @note Despite `.stopPropagation()` and `.stopImmediatePropagation()` being defined
+		* in Node.js, they do nothing. It is safe to re-define them.
+		*/
+		super.stopImmediatePropagation();
+		this[kImmediatePropagationStopped] = true;
+	}
+};
+const kListenerOptions = Symbol("kListenerOptions");
+var Emitter = class {
+	#listeners;
+	constructor() {
+		this.#listeners = new LensList();
+	}
+	/**
+	* Adds a listener for the given event type.
+	*/
+	on(type, listener, options) {
+		this.#addListener(type, listener, options);
+		return this;
+	}
+	/**
+	* Adds a one-time listener for the given event type.
+	*/
+	once(type, listener, options) {
+		return this.on(type, listener, {
+			...options || {},
+			once: true
+		});
+	}
+	/**
+	* Prepends a listener for the given event type.
+	*/
+	earlyOn(type, listener, options) {
+		this.#addListener(type, listener, options, "prepend");
+		return this;
+	}
+	/**
+	* Prepends a one-time listener for the given event type.
+	*/
+	earlyOnce(type, listener, options) {
+		return this.earlyOn(type, listener, {
+			...options || {},
+			once: true
+		});
+	}
+	/**
+	* Emits the given typed event.
+	*
+	* @returns {boolean} Returns `true` if the event had any listeners, `false` otherwise.
+	*/
+	emit(event) {
+		if (this.#listeners.size === 0) return false;
+		/**
+		* @note Calculate matching listeners before calling them
+		* since one-time listeners will self-destruct.
+		*/
+		const hasListeners = this.listenerCount(event.type) > 0;
+		const proxiedEvent = this.#proxyEvent(event);
+		for (const listener of this.#matchListeners(event.type)) {
+			if (proxiedEvent.event[kPropagationStopped] != null && proxiedEvent.event[kPropagationStopped] !== this) {
+				proxiedEvent.revoke();
+				return false;
+			}
+			if (proxiedEvent.event[kImmediatePropagationStopped]) break;
+			this.#callListener(proxiedEvent.event, listener);
+		}
+		proxiedEvent.revoke();
+		return hasListeners;
+	}
+	/**
+	* Emits the given typed event and returns a promise that resolves
+	* when all the listeners for that event have settled.
+	*
+	* @returns {Promise<Array<Emitter.ListenerReturnType>>} A promise that resolves
+	* with the return values of all listeners.
+	*/
+	async emitAsPromise(event) {
+		if (this.#listeners.size === 0) return [];
+		const pendingListeners = [];
+		const proxiedEvent = this.#proxyEvent(event);
+		for (const listener of this.#matchListeners(event.type)) {
+			if (proxiedEvent.event[kPropagationStopped] != null && proxiedEvent.event[kPropagationStopped] !== this) {
+				proxiedEvent.revoke();
+				return [];
+			}
+			if (proxiedEvent.event[kImmediatePropagationStopped]) break;
+			const returnValue = await Promise.resolve(this.#callListener(proxiedEvent.event, listener));
+			if (!this.#isTypelessListener(listener)) pendingListeners.push(returnValue);
+		}
+		proxiedEvent.revoke();
+		return Promise.allSettled(pendingListeners).then((results) => {
+			return results.map((result) => result.status === "fulfilled" ? result.value : result.reason);
+		});
+	}
+	/**
+	* Emits the given event and returns a generator that yields
+	* the result of each listener in the order of their registration.
+	* This way, you stop exhausting the listeners once you get the expected value.
+	*/
+	*emitAsGenerator(event) {
+		if (this.#listeners.size === 0) return;
+		const proxiedEvent = this.#proxyEvent(event);
+		for (const listener of this.#matchListeners(event.type)) {
+			if (proxiedEvent.event[kPropagationStopped] != null && proxiedEvent.event[kPropagationStopped] !== this) {
+				proxiedEvent.revoke();
+				return;
+			}
+			if (proxiedEvent.event[kImmediatePropagationStopped]) break;
+			const returnValue = this.#callListener(proxiedEvent.event, listener);
+			if (!this.#isTypelessListener(listener)) yield returnValue;
+		}
+		proxiedEvent.revoke();
+	}
+	/**
+	* Removes a listener for the given event type.
+	*/
+	removeListener(type, listener) {
+		this.#listeners.delete(type, listener);
+	}
+	/**
+	* Removes all listeners for the given event type.
+	* If no event type is provided, removes all existing listeners.
+	*/
+	removeAllListeners(type) {
+		if (type == null) {
+			this.#listeners.clear();
+			return;
+		}
+		this.#listeners.deleteAll(type);
+	}
+	/**
+	* Returns the list of listeners for the given event type.
+	* If no even type is provided, returns all listeners.
+	*/
+	listeners(type) {
+		if (type == null) return this.#listeners.getAll();
+		return this.#listeners.get(type);
+	}
+	/**
+	* Returns the number of listeners for the given event type.
+	* If no even type is provided, returns the total number of listeners.
+	*/
+	listenerCount(type) {
+		if (type == null) return this.#listeners.size;
+		return this.listeners(type).length;
+	}
+	#addListener(type, listener, options, insertMode = "append") {
+		if (insertMode === "prepend") this.#listeners.prepend(type, listener);
+		else this.#listeners.append(type, listener);
+		if (options) {
+			Object.defineProperty(listener, kListenerOptions, {
+				value: options,
+				enumerable: false,
+				writable: false
+			});
+			if (options.signal) options.signal.addEventListener("abort", () => {
+				this.removeListener(type, listener);
+			}, { once: true });
+		}
+	}
+	#proxyEvent(event) {
+		const { stopPropagation } = event;
+		event.stopPropagation = new Proxy(event.stopPropagation, { apply: (target, thisArg, argArray) => {
+			event[kPropagationStopped] = this;
+			return Reflect.apply(target, thisArg, argArray);
+		} });
+		return {
+			event,
+			revoke() {
+				event.stopPropagation = stopPropagation;
+			}
+		};
+	}
+	#callListener(event, listener) {
+		const returnValue = listener.call(this, event);
+		if (listener[kListenerOptions]?.once) {
+			const key = this.#isTypelessListener(listener) ? "*" : event.type;
+			this.#listeners.delete(key, listener);
+		}
+		return returnValue;
+	}
+	/**
+	* Return a list of all event listeners relevant for the given event type.
+	* This includes the explicit event listeners and also typeless event listeners.
+	*/
+	*#matchListeners(type) {
+		for (const [key, listener] of this.#listeners) if (key === "*" || key === type) yield listener;
+	}
+	#isTypelessListener(listener) {
+		return this.#listeners.get("*").includes(listener);
+	}
+};
+
+//#endregion
+export { Emitter, TypedEvent };
+//# sourceMappingURL=index.mjs.map

node_modules/rettime/build/lens-list.d.mts

@@ -0,0 +1,36 @@
+//#region src/lens-list.d.ts
+declare class LensList<T> {
+  #private;
+  constructor();
+  get [Symbol.iterator](): any;
+  entries(): MapIterator<[string, T[]]>;
+  /**
+   * Return an order-sensitive list of values by the given key.
+   */
+  get(key: string): Array<T>;
+  /**
+   * Return an order-sensitive list of all values.
+   */
+  getAll(): Array<T>;
+  /**
+   * Append a new value to the given key.
+   */
+  append(key: string, value: T): void;
+  /**
+   * Prepend a new value to the given key.
+   */
+  prepend(key: string, value: T): void;
+  /**
+   * Delete the value belonging to the given key.
+   */
+  delete(key: string, value: T): void;
+  /**
+   * Delete all values belogning to the given key.
+   */
+  deleteAll(key: string): void;
+  get size(): number;
+  clear(): void;
+}
+//#endregion
+export { LensList };
+//# sourceMappingURL=lens-list.d.mts.map

node_modules/rettime/build/lens-list.mjs

@@ -0,0 +1,72 @@
+//#region src/lens-list.ts
+var LensList = class {
+	#list;
+	#lens;
+	constructor() {
+		this.#list = [];
+		this.#lens = /* @__PURE__ */ new Map();
+	}
+	get [Symbol.iterator]() {
+		return this.#list[Symbol.iterator].bind(this.#list);
+	}
+	entries() {
+		return this.#lens.entries();
+	}
+	/**
+	* Return an order-sensitive list of values by the given key.
+	*/
+	get(key) {
+		return this.#lens.get(key) || [];
+	}
+	/**
+	* Return an order-sensitive list of all values.
+	*/
+	getAll() {
+		return this.#list.map(([, value]) => value);
+	}
+	/**
+	* Append a new value to the given key.
+	*/
+	append(key, value) {
+		this.#list.push([key, value]);
+		this.#openLens(key, (list) => list.push(value));
+	}
+	/**
+	* Prepend a new value to the given key.
+	*/
+	prepend(key, value) {
+		this.#list.unshift([key, value]);
+		this.#openLens(key, (list) => list.unshift(value));
+	}
+	/**
+	* Delete the value belonging to the given key.
+	*/
+	delete(key, value) {
+		if (this.size === 0) return;
+		this.#list = this.#list.filter((item) => item[1] !== value);
+		for (const [existingKey, values] of this.#lens) if (existingKey === key && values.includes(value)) values.splice(values.indexOf(value), 1);
+	}
+	/**
+	* Delete all values belogning to the given key.
+	*/
+	deleteAll(key) {
+		if (this.size === 0) return;
+		this.#list = this.#list.filter((item) => item[0] !== key);
+		this.#lens.delete(key);
+	}
+	get size() {
+		return this.#list.length;
+	}
+	clear() {
+		if (this.size === 0) return;
+		this.#list.length = 0;
+		this.#lens.clear();
+	}
+	#openLens(key, setter) {
+		setter(this.#lens.get(key) || this.#lens.set(key, []).get(key));
+	}
+};
+
+//#endregion
+export { LensList };
+//# sourceMappingURL=lens-list.mjs.map

node_modules/rettime/build/lens-list.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"lens-list.mjs","names":["#list","#lens","#openLens"],"sources":["../src/lens-list.ts"],"sourcesContent":["export class LensList<T> {\n  #list: Array<[string, T]>\n  #lens: Map<string, Array<T>>\n\n  constructor() {\n    this.#list = []\n    this.#lens = new Map()\n  }\n\n  get [Symbol.iterator]() {\n    // Return the list's iterator so iteration is order-sensitive.\n    return this.#list[Symbol.iterator].bind(this.#list)\n  }\n\n  public entries() {\n    return this.#lens.entries()\n  }\n\n  /**\n   * Return an order-sensitive list of values by the given key.\n   */\n  public get(key: string): Array<T> {\n    return this.#lens.get(key) || []\n  }\n\n  /**\n   * Return an order-sensitive list of all values.\n   */\n  public getAll(): Array<T> {\n    return this.#list.map(([, value]) => value)\n  }\n\n  /**\n   * Append a new value to the given key.\n   */\n  public append(key: string, value: T): void {\n    this.#list.push([key, value])\n    this.#openLens(key, (list) => list.push(value))\n  }\n\n  /**\n   * Prepend a new value to the given key.\n   */\n  public prepend(key: string, value: T): void {\n    this.#list.unshift([key, value])\n    this.#openLens(key, (list) => list.unshift(value))\n  }\n\n  /**\n   * Delete the value belonging to the given key.\n   */\n  public delete(key: string, value: T): void {\n    if (this.size === 0) {\n      return\n    }\n\n    this.#list = this.#list.filter((item) => item[1] !== value)\n\n    for (const [existingKey, values] of this.#lens) {\n      if (existingKey === key && values.includes(value)) {\n        values.splice(values.indexOf(value), 1)\n      }\n    }\n  }\n\n  /**\n   * Delete all values belogning to the given key.\n   */\n  public deleteAll(key: string): void {\n    if (this.size === 0) {\n      return\n    }\n\n    this.#list = this.#list.filter((item) => item[0] !== key)\n    this.#lens.delete(key)\n  }\n\n  get size(): number {\n    return this.#list.length\n  }\n\n  public clear(): void {\n    if (this.size === 0) {\n      return\n    }\n\n    this.#list.length = 0\n    this.#lens.clear()\n  }\n\n  #openLens(key: string, setter: (target: Array<T>) => void): void {\n    setter(this.#lens.get(key) || this.#lens.set(key, []).get(key))\n  }\n}\n"],"mappings":";AAAA,IAAa,WAAb,MAAyB;CACvB;CACA;CAEA,cAAc;AACZ,QAAKA,OAAQ,EAAE;AACf,QAAKC,uBAAQ,IAAI,KAAK;;CAGxB,KAAK,OAAO,YAAY;AAEtB,SAAO,MAAKD,KAAM,OAAO,UAAU,KAAK,MAAKA,KAAM;;CAGrD,AAAO,UAAU;AACf,SAAO,MAAKC,KAAM,SAAS;;;;;CAM7B,AAAO,IAAI,KAAuB;AAChC,SAAO,MAAKA,KAAM,IAAI,IAAI,IAAI,EAAE;;;;;CAMlC,AAAO,SAAmB;AACxB,SAAO,MAAKD,KAAM,KAAK,GAAG,WAAW,MAAM;;;;;CAM7C,AAAO,OAAO,KAAa,OAAgB;AACzC,QAAKA,KAAM,KAAK,CAAC,KAAK,MAAM,CAAC;AAC7B,QAAKE,SAAU,MAAM,SAAS,KAAK,KAAK,MAAM,CAAC;;;;;CAMjD,AAAO,QAAQ,KAAa,OAAgB;AAC1C,QAAKF,KAAM,QAAQ,CAAC,KAAK,MAAM,CAAC;AAChC,QAAKE,SAAU,MAAM,SAAS,KAAK,QAAQ,MAAM,CAAC;;;;;CAMpD,AAAO,OAAO,KAAa,OAAgB;AACzC,MAAI,KAAK,SAAS,EAChB;AAGF,QAAKF,OAAQ,MAAKA,KAAM,QAAQ,SAAS,KAAK,OAAO,MAAM;AAE3D,OAAK,MAAM,CAAC,aAAa,WAAW,MAAKC,KACvC,KAAI,gBAAgB,OAAO,OAAO,SAAS,MAAM,CAC/C,QAAO,OAAO,OAAO,QAAQ,MAAM,EAAE,EAAE;;;;;CAQ7C,AAAO,UAAU,KAAmB;AAClC,MAAI,KAAK,SAAS,EAChB;AAGF,QAAKD,OAAQ,MAAKA,KAAM,QAAQ,SAAS,KAAK,OAAO,IAAI;AACzD,QAAKC,KAAM,OAAO,IAAI;;CAGxB,IAAI,OAAe;AACjB,SAAO,MAAKD,KAAM;;CAGpB,AAAO,QAAc;AACnB,MAAI,KAAK,SAAS,EAChB;AAGF,QAAKA,KAAM,SAAS;AACpB,QAAKC,KAAM,OAAO;;CAGpB,UAAU,KAAa,QAA0C;AAC/D,SAAO,MAAKA,KAAM,IAAI,IAAI,IAAI,MAAKA,KAAM,IAAI,KAAK,EAAE,CAAC,CAAC,IAAI,IAAI,CAAC"}