@intlayer/chokidar 6.1.6 → 7.0.0-canary.0

package/dist/esm/utils/pLimit.mjs

@@ -0,0 +1,126 @@
+//#region src/utils/pLimit.ts
+var Node = class {
+	value;
+	next;
+	constructor(value) {
+		this.value = value;
+	}
+};
+var Queue = class {
+	#head;
+	#tail;
+	#size;
+	constructor() {
+		this.clear();
+	}
+	enqueue(value) {
+		const node = new Node(value);
+		if (this.#head) {
+			this.#tail.next = node;
+			this.#tail = node;
+		} else {
+			this.#head = node;
+			this.#tail = node;
+		}
+		this.#size++;
+	}
+	dequeue() {
+		const current = this.#head;
+		if (!current) return;
+		this.#head = current.next;
+		this.#size--;
+		return current.value;
+	}
+	peek() {
+		if (!this.#head) return;
+		return this.#head.value;
+	}
+	clear() {
+		this.#head = void 0;
+		this.#tail = void 0;
+		this.#size = 0;
+	}
+	get size() {
+		return this.#size;
+	}
+	*[Symbol.iterator]() {
+		let current = this.#head;
+		while (current) {
+			yield current.value;
+			current = current.next;
+		}
+	}
+	*drain() {
+		while (this.#head) yield this.dequeue();
+	}
+};
+const pLimit = (concurrency) => {
+	validateConcurrency(concurrency);
+	const queue = new Queue();
+	let activeCount = 0;
+	const idleWaiters = [];
+	const notifyIdleIfNeeded = () => {
+		if (activeCount === 0 && queue.size === 0) while (idleWaiters.length) idleWaiters.pop()?.();
+	};
+	const resumeNext = () => {
+		if (activeCount < concurrency && queue.size > 0) {
+			activeCount++;
+			queue.dequeue()?.();
+		}
+	};
+	const next = () => {
+		activeCount--;
+		resumeNext();
+	};
+	const run = async (fn, resolve, arguments_) => {
+		const result = (async () => fn(...arguments_))();
+		resolve(result);
+		try {
+			await result;
+		} catch {}
+		next();
+	};
+	const enqueue = (fn, resolve, arguments_) => {
+		new Promise((internalResolve) => {
+			queue.enqueue(internalResolve);
+		}).then(run.bind(void 0, fn, resolve, arguments_));
+		if (activeCount < concurrency) resumeNext();
+	};
+	const generator = (fn, ...arguments_) => new Promise((resolve) => {
+		enqueue(fn, resolve, arguments_);
+	});
+	Object.defineProperties(generator, {
+		activeCount: { get: () => activeCount },
+		pendingCount: { get: () => queue.size },
+		clearQueue: { value() {
+			queue.clear();
+			notifyIdleIfNeeded();
+		} },
+		concurrency: {
+			get: () => concurrency,
+			set(newConcurrency) {
+				validateConcurrency(newConcurrency);
+				concurrency = newConcurrency;
+				queueMicrotask(() => {
+					while (activeCount < concurrency && queue.size > 0) resumeNext();
+				});
+			}
+		},
+		map: { async value(array, fn) {
+			const promises = array.map((value, index) => this(fn, value, index));
+			return Promise.all(promises);
+		} },
+		onIdle: { value() {
+			if (activeCount === 0 && queue.size === 0) return Promise.resolve();
+			return new Promise((resolve) => idleWaiters.push(resolve));
+		} }
+	});
+	return generator;
+};
+const validateConcurrency = (concurrency) => {
+	if (!((Number.isInteger(concurrency) || concurrency === Number.POSITIVE_INFINITY) && concurrency > 0)) throw new TypeError("Expected `concurrency` to be a number from 1 and up");
+};
+
+//#endregion
+export { Queue, pLimit };
+//# sourceMappingURL=pLimit.mjs.map

package/dist/esm/utils/pLimit.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"pLimit.mjs","names":["#head","#tail","#size","idleWaiters: Array<() => void>"],"sources":["../../../src/utils/pLimit.ts"],"sourcesContent":["/*\nHow it works:\n`this.#head` is an instance of `Node` which keeps track of its current value and nests another instance of `Node` that keeps the value that comes after it. When a value is provided to `.enqueue()`, the code needs to iterate through `this.#head`, going deeper and deeper to find the last value. However, iterating through every single item is slow. This problem is solved by saving a reference to the last value as `this.#tail` so that it can reference it to add a new value.\n*/\n\nclass Node<T> {\n  value: T;\n  next: Node<T> | undefined;\n\n  constructor(value: T) {\n    this.value = value;\n  }\n}\n\nexport class Queue<T> {\n  #head: Node<T> | undefined;\n  #tail: Node<T> | undefined;\n  #size!: number;\n\n  constructor() {\n    this.clear();\n  }\n\n  enqueue(value: T): void {\n    const node = new Node(value);\n\n    if (this.#head) {\n      this.#tail!.next = node;\n      this.#tail = node;\n    } else {\n      this.#head = node;\n      this.#tail = node;\n    }\n\n    this.#size++;\n  }\n\n  dequeue(): T | undefined {\n    const current = this.#head;\n    if (!current) {\n      return;\n    }\n\n    this.#head = current.next;\n    this.#size--;\n    return current.value;\n  }\n\n  peek(): T | undefined {\n    if (!this.#head) {\n      return;\n    }\n\n    return this.#head.value;\n\n    // TODO: Node.js 18.\n    // return this.#head?.value;\n  }\n\n  clear(): void {\n    this.#head = undefined;\n    this.#tail = undefined;\n    this.#size = 0;\n  }\n\n  get size(): number {\n    return this.#size;\n  }\n\n  *[Symbol.iterator](): Generator<T, void, unknown> {\n    let current = this.#head;\n\n    while (current) {\n      yield current.value;\n      current = current.next;\n    }\n  }\n\n  *drain(): Generator<T | undefined, void, unknown> {\n    while (this.#head) {\n      yield this.dequeue();\n    }\n  }\n}\n\nexport const pLimit = (concurrency: number) => {\n  validateConcurrency(concurrency);\n\n  const queue = new Queue<() => void>();\n  let activeCount = 0;\n\n  const idleWaiters: Array<() => void> = [];\n  const notifyIdleIfNeeded = (): void => {\n    if (activeCount === 0 && queue.size === 0) {\n      while (idleWaiters.length) idleWaiters.pop()?.();\n    }\n  };\n\n  const resumeNext = (): void => {\n    // Process the next queued function if we're under the concurrency limit\n    if (activeCount < concurrency && queue.size > 0) {\n      activeCount++;\n      queue.dequeue()?.();\n    }\n  };\n\n  const next = (): void => {\n    activeCount--;\n    resumeNext();\n  };\n\n  const run = async (\n    fn: (...args: any[]) => Promise<any>,\n    resolve: (value: Promise<any>) => void,\n    arguments_: any[]\n  ): Promise<void> => {\n    // Execute the function and capture the result promise\n    const result = (async () => fn(...arguments_))();\n\n    // Resolve immediately with the promise (don't wait for completion)\n    resolve(result);\n\n    // Wait for the function to complete (success or failure)\n    // We catch errors here to prevent unhandled rejections,\n    // but the original promise rejection is preserved for the caller\n    try {\n      await result;\n    } catch {}\n\n    // Decrement active count and process next queued function\n    next();\n  };\n\n  const enqueue = (\n    fn: (...args: any[]) => Promise<any>,\n    resolve: (value: Promise<any>) => void,\n    arguments_: any[]\n  ): void => {\n    // Queue the internal resolve function instead of the run function\n    // to preserve the asynchronous execution context.\n    new Promise<void>((internalResolve) => {\n      queue.enqueue(internalResolve);\n    }).then(run.bind(undefined, fn, resolve, arguments_));\n\n    // Start processing immediately if we haven't reached the concurrency limit\n    if (activeCount < concurrency) {\n      resumeNext();\n    }\n  };\n\n  const generator = (\n    fn: (...args: any[]) => Promise<any>,\n    ...arguments_: any[]\n  ): Promise<any> =>\n    new Promise<any>((resolve) => {\n      enqueue(fn, resolve, arguments_);\n    });\n\n  Object.defineProperties(generator, {\n    activeCount: {\n      get: () => activeCount,\n    },\n    pendingCount: {\n      get: () => queue.size,\n    },\n    clearQueue: {\n      value() {\n        queue.clear();\n        notifyIdleIfNeeded();\n      },\n    },\n    concurrency: {\n      get: () => concurrency,\n\n      set(newConcurrency: number) {\n        validateConcurrency(newConcurrency);\n        concurrency = newConcurrency;\n\n        queueMicrotask(() => {\n          while (activeCount < concurrency && queue.size > 0) {\n            resumeNext();\n          }\n        });\n      },\n    },\n    map: {\n      async value<T, R>(\n        array: T[],\n        fn: (value: T, index: number) => Promise<R>\n      ): Promise<R[]> {\n        const promises = array.map((value, index) => this(fn, value, index));\n        return Promise.all(promises);\n      },\n    },\n    onIdle: {\n      /**\n       * Resolves when `activeCount === 0` and the queue is empty.\n       * Use this to wait for completion without holding a list of Promises.\n       */\n      value(): Promise<void> {\n        if (activeCount === 0 && queue.size === 0) return Promise.resolve();\n        return new Promise<void>((resolve) => idleWaiters.push(resolve));\n      },\n    },\n  });\n\n  return generator;\n};\n\nconst validateConcurrency = (concurrency: number): void => {\n  if (\n    !(\n      (Number.isInteger(concurrency) ||\n        concurrency === Number.POSITIVE_INFINITY) &&\n      concurrency > 0\n    )\n  ) {\n    throw new TypeError('Expected `concurrency` to be a number from 1 and up');\n  }\n};\n"],"mappings":"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"}

package/dist/esm/utils/parallelize.mjs

@@ -1,145 +1,11 @@
-class Node {
-  value;
-  next;
-  constructor(value) {
-    this.value = value;
-  }
-}
-class Queue {
-  #head;
-  #tail;
-  #size;
-  constructor() {
-    this.clear();
-  }
-  enqueue(value) {
-    const node = new Node(value);
-    if (this.#head) {
-      this.#tail.next = node;
-      this.#tail = node;
-    } else {
-      this.#head = node;
-      this.#tail = node;
-    }
-    this.#size++;
-  }
-  dequeue() {
-    const current = this.#head;
-    if (!current) {
-      return;
-    }
-    this.#head = current.next;
-    this.#size--;
-    return current.value;
-  }
-  peek() {
-    if (!this.#head) {
-      return;
-    }
-    return this.#head.value;
-  }
-  clear() {
-    this.#head = void 0;
-    this.#tail = void 0;
-    this.#size = 0;
-  }
-  get size() {
-    return this.#size;
-  }
-  *[Symbol.iterator]() {
-    let current = this.#head;
-    while (current) {
-      yield current.value;
-      current = current.next;
-    }
-  }
-  *drain() {
-    while (this.#head) {
-      yield this.dequeue();
-    }
-  }
-}
-const pLimit = (concurrency) => {
-  validateConcurrency(concurrency);
-  const queue = new Queue();
-  let activeCount = 0;
-  const resumeNext = () => {
-    if (activeCount < concurrency && queue.size > 0) {
-      activeCount++;
-      queue.dequeue()?.();
-    }
-  };
-  const next = () => {
-    activeCount--;
-    resumeNext();
-  };
-  const run = async (function_, resolve, arguments_) => {
-    const result = (async () => function_(...arguments_))();
-    resolve(result);
-    try {
-      await result;
-    } catch {
-    }
-    next();
-  };
-  const enqueue = (function_, resolve, arguments_) => {
-    new Promise((internalResolve) => {
-      queue.enqueue(internalResolve);
-    }).then(run.bind(void 0, function_, resolve, arguments_));
-    if (activeCount < concurrency) {
-      resumeNext();
-    }
-  };
-  const generator = (function_, ...arguments_) => new Promise((resolve) => {
-    enqueue(function_, resolve, arguments_);
-  });
-  Object.defineProperties(generator, {
-    activeCount: {
-      get: () => activeCount
-    },
-    pendingCount: {
-      get: () => queue.size
-    },
-    clearQueue: {
-      value() {
-        queue.clear();
-      }
-    },
-    concurrency: {
-      get: () => concurrency,
-      set(newConcurrency) {
-        validateConcurrency(newConcurrency);
-        concurrency = newConcurrency;
-        queueMicrotask(() => {
-          while (activeCount < concurrency && queue.size > 0) {
-            resumeNext();
-          }
-        });
-      }
-    },
-    map: {
-      async value(array, function_) {
-        const promises = array.map(
-          (value, index) => this(function_, value, index)
-        );
-        return Promise.all(promises);
-      }
-    }
-  });
-  return generator;
-};
-const validateConcurrency = (concurrency) => {
-  if (!((Number.isInteger(concurrency) || concurrency === Number.POSITIVE_INFINITY) && concurrency > 0)) {
-    throw new TypeError("Expected `concurrency` to be a number from 1 and up");
-  }
-};
-const parallelize = async (items, callback, parallelLimit = 10) => {
-  const limit = pLimit(parallelLimit);
-  return Promise.all(items.map((item) => limit(() => callback(item))));
-};
-export {
-  Queue as default,
-  pLimit,
-  parallelize
-};
+import { pLimit } from "./pLimit.mjs";
+
+//#region src/utils/parallelize.ts
+const parallelize = async (items, callback = async (item) => item, parallelLimit = 10) => {
+	const limit = pLimit(parallelLimit);
+	return Promise.all(items.map((item) => limit(() => callback(item))));
+};
+
+//#endregion
+export { parallelize };
 //# sourceMappingURL=parallelize.mjs.map

package/dist/esm/utils/parallelize.mjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/utils/parallelize.ts"],"sourcesContent":["/*\nHow it works:\n`this.#head` is an instance of `Node` which keeps track of its current value and nests another instance of `Node` that keeps the value that comes after it. When a value is provided to `.enqueue()`, the code needs to iterate through `this.#head`, going deeper and deeper to find the last value. However, iterating through every single item is slow. This problem is solved by saving a reference to the last value as `this.#tail` so that it can reference it to add a new value.\n*/\n\nclass Node<T> {\n  value: T;\n  next: Node<T> | undefined;\n\n  constructor(value: T) {\n    this.value = value;\n  }\n}\n\nexport default class Queue<T> {\n  #head: Node<T> | undefined;\n  #tail: Node<T> | undefined;\n  #size!: number;\n\n  constructor() {\n    this.clear();\n  }\n\n  enqueue(value: T): void {\n    const node = new Node(value);\n\n    if (this.#head) {\n      this.#tail!.next = node;\n      this.#tail = node;\n    } else {\n      this.#head = node;\n      this.#tail = node;\n    }\n\n    this.#size++;\n  }\n\n  dequeue(): T | undefined {\n    const current = this.#head;\n    if (!current) {\n      return;\n    }\n\n    this.#head = current.next;\n    this.#size--;\n    return current.value;\n  }\n\n  peek(): T | undefined {\n    if (!this.#head) {\n      return;\n    }\n\n    return this.#head.value;\n\n    // TODO: Node.js 18.\n    // return this.#head?.value;\n  }\n\n  clear(): void {\n    this.#head = undefined;\n    this.#tail = undefined;\n    this.#size = 0;\n  }\n\n  get size(): number {\n    return this.#size;\n  }\n\n  *[Symbol.iterator](): Generator<T, void, unknown> {\n    let current = this.#head;\n\n    while (current) {\n      yield current.value;\n      current = current.next;\n    }\n  }\n\n  *drain(): Generator<T | undefined, void, unknown> {\n    while (this.#head) {\n      yield this.dequeue();\n    }\n  }\n}\n\nexport const pLimit = (concurrency: number) => {\n  validateConcurrency(concurrency);\n\n  const queue = new Queue<() => void>();\n  let activeCount = 0;\n\n  const resumeNext = (): void => {\n    // Process the next queued function if we're under the concurrency limit\n    if (activeCount < concurrency && queue.size > 0) {\n      activeCount++;\n      queue.dequeue()?.();\n    }\n  };\n\n  const next = (): void => {\n    activeCount--;\n    resumeNext();\n  };\n\n  const run = async (\n    function_: (...args: any[]) => Promise<any>,\n    resolve: (value: Promise<any>) => void,\n    arguments_: any[]\n  ): Promise<void> => {\n    // Execute the function and capture the result promise\n    const result = (async () => function_(...arguments_))();\n\n    // Resolve immediately with the promise (don't wait for completion)\n    resolve(result);\n\n    // Wait for the function to complete (success or failure)\n    // We catch errors here to prevent unhandled rejections,\n    // but the original promise rejection is preserved for the caller\n    try {\n      await result;\n    } catch {}\n\n    // Decrement active count and process next queued function\n    next();\n  };\n\n  const enqueue = (\n    function_: (...args: any[]) => Promise<any>,\n    resolve: (value: Promise<any>) => void,\n    arguments_: any[]\n  ): void => {\n    // Queue the internal resolve function instead of the run function\n    // to preserve the asynchronous execution context.\n    new Promise<void>((internalResolve) => {\n      queue.enqueue(internalResolve);\n    }).then(run.bind(undefined, function_, resolve, arguments_));\n\n    // Start processing immediately if we haven't reached the concurrency limit\n    if (activeCount < concurrency) {\n      resumeNext();\n    }\n  };\n\n  const generator = (\n    function_: (...args: any[]) => Promise<any>,\n    ...arguments_: any[]\n  ): Promise<any> =>\n    new Promise<any>((resolve) => {\n      enqueue(function_, resolve, arguments_);\n    });\n\n  Object.defineProperties(generator, {\n    activeCount: {\n      get: () => activeCount,\n    },\n    pendingCount: {\n      get: () => queue.size,\n    },\n    clearQueue: {\n      value() {\n        queue.clear();\n      },\n    },\n    concurrency: {\n      get: () => concurrency,\n\n      set(newConcurrency: number) {\n        validateConcurrency(newConcurrency);\n        concurrency = newConcurrency;\n\n        queueMicrotask(() => {\n          while (activeCount < concurrency && queue.size > 0) {\n            resumeNext();\n          }\n        });\n      },\n    },\n    map: {\n      async value<T, R>(\n        array: T[],\n        function_: (value: T, index: number) => Promise<R>\n      ): Promise<R[]> {\n        const promises = array.map((value, index) =>\n          this(function_, value, index)\n        );\n        return Promise.all(promises);\n      },\n    },\n  });\n\n  return generator;\n};\n\nconst validateConcurrency = (concurrency: number): void => {\n  if (\n    !(\n      (Number.isInteger(concurrency) ||\n        concurrency === Number.POSITIVE_INFINITY) &&\n      concurrency > 0\n    )\n  ) {\n    throw new TypeError('Expected `concurrency` to be a number from 1 and up');\n  }\n};\n\nexport const parallelize = async <T, R>(\n  items: T[],\n  callback: (item: T) => Promise<R>,\n  parallelLimit: number = 10\n): Promise<R[]> => {\n  const limit = pLimit(parallelLimit);\n  return Promise.all(items.map((item) => limit(() => callback(item))));\n};\n"],"mappings":"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","names":[]}
+{"version":3,"file":"parallelize.mjs","names":[],"sources":["../../../src/utils/parallelize.ts"],"sourcesContent":["import { pLimit } from './pLimit';\n\nexport const parallelize = async <T, R>(\n  items: T[],\n  callback: (item: T) => Promise<R> = async (item) =>\n    item as unknown as Promise<R>,\n  parallelLimit: number = 10\n): Promise<R[]> => {\n  const limit = pLimit(parallelLimit);\n  return Promise.all(items.map((item) => limit(() => callback(item))));\n};\n"],"mappings":";;;AAEA,MAAa,cAAc,OACzB,OACA,WAAoC,OAAO,SACzC,MACF,gBAAwB,OACP;CACjB,MAAM,QAAQ,OAAO,cAAc;AACnC,QAAO,QAAQ,IAAI,MAAM,KAAK,SAAS,YAAY,SAAS,KAAK,CAAC,CAAC,CAAC"}

package/dist/esm/utils/parallelizeGlobal.mjs

@@ -0,0 +1,27 @@
+import { pLimit } from "./pLimit.mjs";
+
+//#region src/utils/parallelizeGlobal.ts
+let _globalLimiter = null;
+/** Get (and optionally configure) the single, shared limiter. */
+const getGlobalLimiter = (concurrency) => {
+	if (!_globalLimiter) _globalLimiter = pLimit(concurrency ?? 10);
+	else if (typeof concurrency === "number") _globalLimiter.concurrency = concurrency;
+	return _globalLimiter;
+};
+let _taskLimiter = null;
+/** Limits how many *tasks* run concurrently (independent from AI calls). */
+const getTaskLimiter = (concurrency) => {
+	if (!_taskLimiter) _taskLimiter = pLimit(concurrency ?? 5);
+	else if (typeof concurrency === "number") _taskLimiter.concurrency = concurrency;
+	return _taskLimiter;
+};
+const parallelizeGlobal = async (items, callback = async (item) => item, options) => {
+	const limiter = options?.limiter ?? getGlobalLimiter(options?.concurrency);
+	const run = options?.wrapInLimiter ?? true ? (fn) => limiter(fn) : (fn) => fn();
+	const promises = items.map((item, index) => run(() => callback(item, index)));
+	return Promise.all(promises);
+};
+
+//#endregion
+export { getGlobalLimiter, getTaskLimiter, parallelizeGlobal };
+//# sourceMappingURL=parallelizeGlobal.mjs.map

package/dist/esm/utils/parallelizeGlobal.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"parallelizeGlobal.mjs","names":["_globalLimiter: ReturnType<typeof pLimit> | null","_taskLimiter: ReturnType<typeof pLimit> | null"],"sources":["../../../src/utils/parallelizeGlobal.ts"],"sourcesContent":["// === keep your Queue, Node, pLimit, validateConcurrency exactly as-is ===\n\nimport { pLimit } from './pLimit';\n\n// --- NEW: single, shared limiter for the whole process ---\nlet _globalLimiter: ReturnType<typeof pLimit> | null = null;\n\n/** Get (and optionally configure) the single, shared limiter. */\nexport const getGlobalLimiter = (concurrency?: number) => {\n  if (!_globalLimiter) {\n    _globalLimiter = pLimit(concurrency ?? 10);\n  } else if (typeof concurrency === 'number') {\n    (_globalLimiter as any).concurrency = concurrency;\n  }\n  return _globalLimiter!;\n};\n\n// --- NEW: task limiter for gating task starts ---\nlet _taskLimiter: ReturnType<typeof pLimit> | null = null;\n\n/** Limits how many *tasks* run concurrently (independent from AI calls). */\nexport const getTaskLimiter = (concurrency?: number) => {\n  if (!_taskLimiter) {\n    _taskLimiter = pLimit(concurrency ?? 5);\n  } else if (typeof concurrency === 'number') {\n    (_taskLimiter as any).concurrency = concurrency;\n  }\n  return _taskLimiter!;\n};\n\n// --- REPLACE your existing `parallelize` with this version ---\nexport const parallelizeGlobal = async <T, R>(\n  items: T[],\n  callback: (item: T, index: number) => Promise<R> = async (item) =>\n    item as unknown as Promise<R>,\n  options?: {\n    /** Share a single limiter across the app. If omitted, uses global limiter. */\n    limiter?: ReturnType<typeof pLimit>;\n    /** If provided and no limiter is passed, configure the global limiter. */\n    concurrency?: number;\n    /**\n     * Whether to wrap *each* callback run in the limiter.\n     * - For orchestration (outer loops): set `false` (don't burn limiter slots).\n     * - For atomic work (AI calls, writes): leave `true` (default).\n     */\n    wrapInLimiter?: boolean;\n  }\n): Promise<R[]> => {\n  const limiter = options?.limiter ?? getGlobalLimiter(options?.concurrency);\n  const wrap = options?.wrapInLimiter ?? true;\n\n  const run = wrap\n    ? <U>(fn: () => Promise<U>) => limiter(fn)\n    : <U>(fn: () => Promise<U>) => fn();\n\n  const promises = items.map((item, index) => run(() => callback(item, index)));\n  return Promise.all(promises);\n};\n"],"mappings":";;;AAKA,IAAIA,iBAAmD;;AAGvD,MAAa,oBAAoB,gBAAyB;AACxD,KAAI,CAAC,eACH,kBAAiB,OAAO,eAAe,GAAG;UACjC,OAAO,gBAAgB,SAChC,CAAC,eAAuB,cAAc;AAExC,QAAO;;AAIT,IAAIC,eAAiD;;AAGrD,MAAa,kBAAkB,gBAAyB;AACtD,KAAI,CAAC,aACH,gBAAe,OAAO,eAAe,EAAE;UAC9B,OAAO,gBAAgB,SAChC,CAAC,aAAqB,cAAc;AAEtC,QAAO;;AAIT,MAAa,oBAAoB,OAC/B,OACA,WAAmD,OAAO,SACxD,MACF,YAYiB;CACjB,MAAM,UAAU,SAAS,WAAW,iBAAiB,SAAS,YAAY;CAG1E,MAAM,MAFO,SAAS,iBAAiB,QAG/B,OAAyB,QAAQ,GAAG,IACpC,OAAyB,IAAI;CAErC,MAAM,WAAW,MAAM,KAAK,MAAM,UAAU,UAAU,SAAS,MAAM,MAAM,CAAC,CAAC;AAC7E,QAAO,QAAQ,IAAI,SAAS"}

package/dist/esm/utils/reduceObjectFormat.mjs

@@ -0,0 +1,30 @@
+//#region src/utils/reduceObjectFormat.ts
+/**
+* Reduce an object to only the shape provided by a format object.
+* Values are always taken from the source object; the format is used only for structure.
+*
+* Examples:
+* reduceObjectFormat({ a: 1, b: 2 }, { a: 0 }) => { a: 1 }
+* reduceObjectFormat({ a: { x: 1, y: 2 } }, { a: { x: 0 } }) => { a: { x: 1 } }
+*/
+const reduceObjectFormat = (source, format) => {
+	if (Array.isArray(format)) {
+		const sourceArray = Array.isArray(source) ? source : [];
+		return format.map((formatItem, index) => reduceObjectFormat(sourceArray[index], formatItem));
+	}
+	if (typeof format === "object" && format !== null) {
+		const result = {};
+		const sourceObject = typeof source === "object" && source !== null && !Array.isArray(source) ? source : {};
+		for (const key of Object.keys(format)) {
+			const nextSource = sourceObject[key];
+			const nextFormat = format[key];
+			result[key] = reduceObjectFormat(nextSource, nextFormat);
+		}
+		return result;
+	}
+	return source;
+};
+
+//#endregion
+export { reduceObjectFormat };
+//# sourceMappingURL=reduceObjectFormat.mjs.map

package/dist/esm/utils/reduceObjectFormat.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"reduceObjectFormat.mjs","names":["result: Record<string, Recursive>"],"sources":["../../../src/utils/reduceObjectFormat.ts"],"sourcesContent":["type Primitive = string | number | boolean | null | undefined;\n\ntype Recursive = Primitive | { [key: string]: Recursive } | Array<Recursive>;\n\n/**\n * Reduce an object to only the shape provided by a format object.\n * Values are always taken from the source object; the format is used only for structure.\n *\n * Examples:\n * reduceObjectFormat({ a: 1, b: 2 }, { a: 0 }) => { a: 1 }\n * reduceObjectFormat({ a: { x: 1, y: 2 } }, { a: { x: 0 } }) => { a: { x: 1 } }\n */\nexport const reduceObjectFormat = (\n  source: Recursive,\n  format: Recursive\n): Recursive => {\n  // If the format is an array, reduce each element by its counterpart in source\n  if (Array.isArray(format)) {\n    const sourceArray = Array.isArray(source) ? source : [];\n    return format.map((formatItem, index) =>\n      reduceObjectFormat(sourceArray[index], formatItem)\n    );\n  }\n\n  // If the format is an object (and not null), pick matching keys and recurse\n  if (typeof format === 'object' && format !== null) {\n    const result: Record<string, Recursive> = {};\n    const sourceObject =\n      typeof source === 'object' && source !== null && !Array.isArray(source)\n        ? (source as Record<string, Recursive>)\n        : ({} as Record<string, Recursive>);\n\n    for (const key of Object.keys(format)) {\n      const nextSource = sourceObject[key];\n      const nextFormat = (format as Record<string, Recursive>)[key];\n      result[key] = reduceObjectFormat(nextSource, nextFormat);\n    }\n    return result;\n  }\n\n  // For primitives in the format, simply return the source value (can be undefined)\n  return source as Primitive;\n};\n"],"mappings":";;;;;;;;;AAYA,MAAa,sBACX,QACA,WACc;AAEd,KAAI,MAAM,QAAQ,OAAO,EAAE;EACzB,MAAM,cAAc,MAAM,QAAQ,OAAO,GAAG,SAAS,EAAE;AACvD,SAAO,OAAO,KAAK,YAAY,UAC7B,mBAAmB,YAAY,QAAQ,WAAW,CACnD;;AAIH,KAAI,OAAO,WAAW,YAAY,WAAW,MAAM;EACjD,MAAMA,SAAoC,EAAE;EAC5C,MAAM,eACJ,OAAO,WAAW,YAAY,WAAW,QAAQ,CAAC,MAAM,QAAQ,OAAO,GAClE,SACA,EAAE;AAET,OAAK,MAAM,OAAO,OAAO,KAAK,OAAO,EAAE;GACrC,MAAM,aAAa,aAAa;GAChC,MAAM,aAAc,OAAqC;AACzD,UAAO,OAAO,mBAAmB,YAAY,WAAW;;AAE1D,SAAO;;AAIT,QAAO"}

package/dist/esm/utils/resolveObjectPromises.mjs

@@ -1,27 +1,20 @@
+//#region src/utils/resolveObjectPromises.ts
+/**
+* A more "unified" approach where each type (function, array, object, primitive)
+* is handled inside the main recursive body.
+*/
 const resolveObjectPromises = async (entry) => {
-  if (entry && typeof entry.then === "function") {
-    const awaited = await entry;
-    return resolveObjectPromises(awaited);
-  }
-  if (typeof entry === "function") {
-    const result = entry();
-    return resolveObjectPromises(result);
-  }
-  if (Array.isArray(entry)) {
-    return Promise.all(
-      entry.map(async (item) => resolveObjectPromises(item))
-    );
-  }
-  if (entry && typeof entry === "object") {
-    const result = {};
-    for (const key of Object.keys(entry)) {
-      result[key] = await resolveObjectPromises(entry[key]);
-    }
-    return result;
-  }
-  return entry;
-};
-export {
-  resolveObjectPromises
+	if (entry && typeof entry.then === "function") return resolveObjectPromises(await entry);
+	if (typeof entry === "function") return resolveObjectPromises(entry());
+	if (Array.isArray(entry)) return Promise.all(entry.map(async (item) => resolveObjectPromises(item)));
+	if (entry && typeof entry === "object") {
+		const result = {};
+		for (const key of Object.keys(entry)) result[key] = await resolveObjectPromises(entry[key]);
+		return result;
+	}
+	return entry;
 };
+
+//#endregion
+export { resolveObjectPromises };
 //# sourceMappingURL=resolveObjectPromises.mjs.map

package/dist/esm/utils/resolveObjectPromises.mjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/utils/resolveObjectPromises.ts"],"sourcesContent":["/**\n * A more \"unified\" approach where each type (function, array, object, primitive)\n * is handled inside the main recursive body.\n */\nexport const resolveObjectPromises = async <T = unknown>(\n  entry: any\n): Promise<T> => {\n  // Check if entry is a Promise (Thenable)\n  if (entry && typeof entry.then === 'function') {\n    const awaited = await entry;\n    return resolveObjectPromises(awaited);\n  }\n\n  // If entry is a function, invoke it and process the result\n  if (typeof entry === 'function') {\n    const result = entry();\n    return resolveObjectPromises(result);\n  }\n\n  if (Array.isArray(entry)) {\n    return Promise.all(\n      entry.map(async (item) => resolveObjectPromises(item))\n    ) as unknown as T;\n  }\n\n  // Handle plain objects (but not arrays)\n  if (entry && typeof entry === 'object') {\n    // Arrays are handled in the `Array.isArray` branch above, so we know `entry` is a plain object here.\n\n    const result: Record<string, any> = {};\n\n    // Iterate over keys **sequentially** to make sure the insertion order of the\n    // resulting object matches the original key order. Using `Promise.all` here\n    // could lead to out-of-order insertions when asynchronous resolutions\n    // finish at different times.\n    for (const key of Object.keys(entry)) {\n      result[key] = await resolveObjectPromises(entry[key]);\n    }\n\n    return result as T;\n  }\n\n  return entry as T;\n};\n"],"mappings":"AAIO,MAAM,wBAAwB,OACnC,UACe;AAEf,MAAI,SAAS,OAAO,MAAM,SAAS,YAAY;AAC7C,UAAM,UAAU,MAAM;AACtB,WAAO,sBAAsB,OAAO;AAAA,EACtC;AAGA,MAAI,OAAO,UAAU,YAAY;AAC/B,UAAM,SAAS,MAAM;AACrB,WAAO,sBAAsB,MAAM;AAAA,EACrC;AAEA,MAAI,MAAM,QAAQ,KAAK,GAAG;AACxB,WAAO,QAAQ;AAAA,MACb,MAAM,IAAI,OAAO,SAAS,sBAAsB,IAAI,CAAC;AAAA,IACvD;AAAA,EACF;AAGA,MAAI,SAAS,OAAO,UAAU,UAAU;AAGtC,UAAM,SAA8B,CAAC;AAMrC,eAAW,OAAO,OAAO,KAAK,KAAK,GAAG;AACpC,aAAO,GAAG,IAAI,MAAM,sBAAsB,MAAM,GAAG,CAAC;AAAA,IACtD;AAEA,WAAO;AAAA,EACT;AAEA,SAAO;AACT;","names":[]}
+{"version":3,"file":"resolveObjectPromises.mjs","names":["result: Record<string, any>"],"sources":["../../../src/utils/resolveObjectPromises.ts"],"sourcesContent":["/**\n * A more \"unified\" approach where each type (function, array, object, primitive)\n * is handled inside the main recursive body.\n */\nexport const resolveObjectPromises = async <T = unknown>(\n  entry: any\n): Promise<T> => {\n  // Check if entry is a Promise (Thenable)\n  if (entry && typeof entry.then === 'function') {\n    const awaited = await entry;\n    return resolveObjectPromises(awaited);\n  }\n\n  // If entry is a function, invoke it and process the result\n  if (typeof entry === 'function') {\n    const result = entry();\n    return resolveObjectPromises(result);\n  }\n\n  if (Array.isArray(entry)) {\n    return Promise.all(\n      entry.map(async (item) => resolveObjectPromises(item))\n    ) as unknown as T;\n  }\n\n  // Handle plain objects (but not arrays)\n  if (entry && typeof entry === 'object') {\n    // Arrays are handled in the `Array.isArray` branch above, so we know `entry` is a plain object here.\n\n    const result: Record<string, any> = {};\n\n    // Iterate over keys **sequentially** to make sure the insertion order of the\n    // resulting object matches the original key order. Using `Promise.all` here\n    // could lead to out-of-order insertions when asynchronous resolutions\n    // finish at different times.\n    for (const key of Object.keys(entry)) {\n      result[key] = await resolveObjectPromises(entry[key]);\n    }\n\n    return result as T;\n  }\n\n  return entry as T;\n};\n"],"mappings":";;;;;AAIA,MAAa,wBAAwB,OACnC,UACe;AAEf,KAAI,SAAS,OAAO,MAAM,SAAS,WAEjC,QAAO,sBADS,MAAM,MACe;AAIvC,KAAI,OAAO,UAAU,WAEnB,QAAO,sBADQ,OAAO,CACc;AAGtC,KAAI,MAAM,QAAQ,MAAM,CACtB,QAAO,QAAQ,IACb,MAAM,IAAI,OAAO,SAAS,sBAAsB,KAAK,CAAC,CACvD;AAIH,KAAI,SAAS,OAAO,UAAU,UAAU;EAGtC,MAAMA,SAA8B,EAAE;AAMtC,OAAK,MAAM,OAAO,OAAO,KAAK,MAAM,CAClC,QAAO,OAAO,MAAM,sBAAsB,MAAM,KAAK;AAGvD,SAAO;;AAGT,QAAO"}

package/dist/esm/utils/runOnce.mjs

@@ -1,35 +1,78 @@
-import { mkdir, stat, unlink, writeFile } from "fs/promises";
-import { dirname } from "path";
-const runOnce = async (sentinelFilePath, callback, onIsCached, cacheTimeoutMs = 60 * 1e3) => {
-  const currentTimestamp = Date.now();
-  const timeoutDuration = cacheTimeoutMs;
-  try {
-    const sentinelStats = await stat(sentinelFilePath);
-    const sentinelAge = currentTimestamp - sentinelStats.mtime.getTime();
-    if (sentinelAge > timeoutDuration) {
-      await unlink(sentinelFilePath);
-    } else {
-      await onIsCached?.();
-      return;
-    }
-  } catch (err) {
-    if (err.code === "ENOENT") {
-    } else {
-      throw err;
-    }
-  }
-  try {
-    await mkdir(dirname(sentinelFilePath), { recursive: true });
-    await writeFile(sentinelFilePath, String(currentTimestamp), { flag: "wx" });
-  } catch (err) {
-    if (err.code === "EEXIST") {
-      return;
-    }
-    throw err;
-  }
-  await callback();
-};
-export {
-  runOnce
+import { dirname } from "node:path";
+import { mkdir, readFile, stat, unlink, writeFile } from "node:fs/promises";
+import packageJson from "@intlayer/core/package.json" with { type: "json" };
+
+//#region src/utils/runOnce.ts
+const DEFAULT_RUN_ONCE_OPTIONS = { cacheTimeoutMs: 60 * 1e3 };
+/**
+* Ensures a callback function runs only once within a specified time window across multiple processes.
+* Uses a sentinel file to coordinate execution and prevent duplicate work.
+*
+* @param sentinelFilePath - Path to the sentinel file used for coordination
+* @param callback - The function to execute (should be async)
+* @param options - The options for the runOnce function
+*
+* @example
+* ```typescript
+* await runPrepareIntlayerOnce(
+*   '/tmp/intlayer-sentinel',
+*   async () => {
+*     // Your initialization logic here
+*     await prepareIntlayer();
+*   },
+*   30 * 1000 // 30 seconds cache
+* );
+* ```
+*
+* @throws {Error} When there are unexpected filesystem errors
+*/
+const runOnce = async (sentinelFilePath, callback, options) => {
+	const { onIsCached, cacheTimeoutMs, forceRun } = {
+		...DEFAULT_RUN_ONCE_OPTIONS,
+		...options ?? {}
+	};
+	const currentTimestamp = Date.now();
+	try {
+		const sentinelAge = currentTimestamp - (await stat(sentinelFilePath)).mtime.getTime();
+		let shouldRebuild = Boolean(forceRun) || sentinelAge > cacheTimeoutMs;
+		if (!shouldRebuild) try {
+			const raw = await readFile(sentinelFilePath, "utf8");
+			let cachedVersion;
+			try {
+				cachedVersion = JSON.parse(raw).version;
+			} catch {
+				cachedVersion = void 0;
+			}
+			if (!cachedVersion || cachedVersion !== packageJson.version) shouldRebuild = true;
+		} catch {
+			shouldRebuild = true;
+		}
+		if (shouldRebuild) try {
+			await unlink(sentinelFilePath);
+		} catch (err) {
+			if (err.code !== "ENOENT") throw err;
+		}
+		else {
+			await onIsCached?.();
+			return;
+		}
+	} catch (err) {
+		if (err.code === "ENOENT") {} else throw err;
+	}
+	try {
+		await mkdir(dirname(sentinelFilePath), { recursive: true });
+		const data = {
+			version: packageJson.version,
+			timestamp: currentTimestamp
+		};
+		await writeFile(sentinelFilePath, JSON.stringify(data), { flag: "wx" });
+	} catch (err) {
+		if (err.code === "EEXIST") return;
+		throw err;
+	}
+	await callback();
 };
+
+//#endregion
+export { runOnce };
 //# sourceMappingURL=runOnce.mjs.map

package/dist/esm/utils/runOnce.mjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/utils/runOnce.ts"],"sourcesContent":["import { mkdir, stat, unlink, writeFile } from 'fs/promises';\nimport { dirname } from 'path';\n\n/**\n * Ensures a callback function runs only once within a specified time window across multiple processes.\n * Uses a sentinel file to coordinate execution and prevent duplicate work.\n *\n * @param sentinelFilePath - Path to the sentinel file used for coordination\n * @param callback - The function to execute (should be async)\n * @param cacheTimeoutMs - Time window in milliseconds during which the sentinel is considered valid (default: 60000ms = 1 minute)\n *\n * @example\n * ```typescript\n * await runPrepareIntlayerOnce(\n *   '/tmp/intlayer-sentinel',\n *   async () => {\n *     // Your initialization logic here\n *     await prepareIntlayer();\n *   },\n *   30 * 1000 // 30 seconds cache\n * );\n * ```\n *\n * @throws {Error} When there are unexpected filesystem errors\n */\nexport const runOnce = async (\n  sentinelFilePath: string,\n  callback: () => void | Promise<void>,\n  onIsCached?: () => void | Promise<void>,\n  cacheTimeoutMs: number = 60 * 1000 // 1 minute in milliseconds\n) => {\n  const currentTimestamp = Date.now();\n  const timeoutDuration = cacheTimeoutMs;\n\n  try {\n    // Check if sentinel file exists and get its stats\n    const sentinelStats = await stat(sentinelFilePath);\n    const sentinelAge = currentTimestamp - sentinelStats.mtime.getTime();\n\n    // If sentinel is older than the timeout, delete it and rebuild\n    if (sentinelAge > timeoutDuration) {\n      await unlink(sentinelFilePath);\n      // Fall through to create new sentinel and rebuild\n    } else {\n      await onIsCached?.();\n      // Sentinel is recent, no need to rebuild\n      return;\n    }\n  } catch (err: any) {\n    if (err.code === 'ENOENT') {\n      // File doesn't exist, continue to create it\n    } else {\n      throw err; // unexpected FS error\n    }\n  }\n\n  try {\n    // Ensure the directory exists before writing the file\n    await mkdir(dirname(sentinelFilePath), { recursive: true });\n\n    // O_EXCL ensures only the *first* process can create the file\n    await writeFile(sentinelFilePath, String(currentTimestamp), { flag: 'wx' });\n  } catch (err: any) {\n    if (err.code === 'EEXIST') {\n      // Another process already created it → we're done\n      return;\n    }\n    throw err; // unexpected FS error\n  }\n\n  await callback();\n};\n"],"mappings":"AAAA,SAAS,OAAO,MAAM,QAAQ,iBAAiB;AAC/C,SAAS,eAAe;AAwBjB,MAAM,UAAU,OACrB,kBACA,UACA,YACA,iBAAyB,KAAK,QAC3B;AACH,QAAM,mBAAmB,KAAK,IAAI;AAClC,QAAM,kBAAkB;AAExB,MAAI;AAEF,UAAM,gBAAgB,MAAM,KAAK,gBAAgB;AACjD,UAAM,cAAc,mBAAmB,cAAc,MAAM,QAAQ;AAGnE,QAAI,cAAc,iBAAiB;AACjC,YAAM,OAAO,gBAAgB;AAAA,IAE/B,OAAO;AACL,YAAM,aAAa;AAEnB;AAAA,IACF;AAAA,EACF,SAAS,KAAU;AACjB,QAAI,IAAI,SAAS,UAAU;AAAA,IAE3B,OAAO;AACL,YAAM;AAAA,IACR;AAAA,EACF;AAEA,MAAI;AAEF,UAAM,MAAM,QAAQ,gBAAgB,GAAG,EAAE,WAAW,KAAK,CAAC;AAG1D,UAAM,UAAU,kBAAkB,OAAO,gBAAgB,GAAG,EAAE,MAAM,KAAK,CAAC;AAAA,EAC5E,SAAS,KAAU;AACjB,QAAI,IAAI,SAAS,UAAU;AAEzB;AAAA,IACF;AACA,UAAM;AAAA,EACR;AAEA,QAAM,SAAS;AACjB;","names":[]}
+{"version":3,"file":"runOnce.mjs","names":["cachedVersion: string | undefined","err: any","data: SentinelData"],"sources":["../../../src/utils/runOnce.ts"],"sourcesContent":["import { mkdir, readFile, stat, unlink, writeFile } from 'node:fs/promises';\nimport { dirname } from 'node:path';\nimport packageJson from '@intlayer/core/package.json' with { type: 'json' };\n\ntype RunOnceOptions = {\n  /**\n   * The function to execute when the sentinel is not found or is older than the cache timeout.\n   */\n  onIsCached?: () => void | Promise<void>;\n  /**\n   * The time window in milliseconds during which the sentinel is considered valid.\n   *\n   * @default 60000 = 1 minute\n   */\n  cacheTimeoutMs?: number;\n  /**\n   * If true, the callback will always run. If undefined, the callback will run only if the sentinel is older than the cache timeout.\n   *\n   * @default false\n   */\n  forceRun?: boolean;\n};\n\nconst DEFAULT_RUN_ONCE_OPTIONS = {\n  cacheTimeoutMs: 60 * 1000, // 1 minute in milliseconds,\n} satisfies RunOnceOptions;\n\ntype SentinelData = {\n  version: string;\n  timestamp: number;\n};\n\n/**\n * Ensures a callback function runs only once within a specified time window across multiple processes.\n * Uses a sentinel file to coordinate execution and prevent duplicate work.\n *\n * @param sentinelFilePath - Path to the sentinel file used for coordination\n * @param callback - The function to execute (should be async)\n * @param options - The options for the runOnce function\n *\n * @example\n * ```typescript\n * await runPrepareIntlayerOnce(\n *   '/tmp/intlayer-sentinel',\n *   async () => {\n *     // Your initialization logic here\n *     await prepareIntlayer();\n *   },\n *   30 * 1000 // 30 seconds cache\n * );\n * ```\n *\n * @throws {Error} When there are unexpected filesystem errors\n */\nexport const runOnce = async (\n  sentinelFilePath: string,\n  callback: () => void | Promise<void>,\n  options?: RunOnceOptions\n) => {\n  const { onIsCached, cacheTimeoutMs, forceRun } = {\n    ...DEFAULT_RUN_ONCE_OPTIONS,\n    ...(options ?? {}),\n  };\n  const currentTimestamp = Date.now();\n\n  try {\n    // Check if sentinel file exists and get its stats\n    const sentinelStats = await stat(sentinelFilePath);\n    const sentinelAge = currentTimestamp - sentinelStats.mtime.getTime();\n\n    // Determine if we should rebuild based on cache age, force flag, or version mismatch\n    let shouldRebuild = Boolean(forceRun) || sentinelAge > cacheTimeoutMs!;\n\n    if (!shouldRebuild) {\n      try {\n        const raw = await readFile(sentinelFilePath, 'utf8');\n        let cachedVersion: string | undefined;\n        try {\n          const parsed = JSON.parse(raw) as Partial<SentinelData>;\n          cachedVersion = parsed.version;\n        } catch {\n          // Legacy format (timestamp only). Force a rebuild once to write versioned sentinel.\n          cachedVersion = undefined;\n        }\n\n        if (!cachedVersion || cachedVersion !== packageJson.version) {\n          shouldRebuild = true;\n        }\n      } catch {\n        // If we cannot read the file, err on the safe side and rebuild\n        shouldRebuild = true;\n      }\n    }\n\n    if (shouldRebuild) {\n      try {\n        await unlink(sentinelFilePath);\n      } catch (err: any) {\n        if (err.code !== 'ENOENT') throw err;\n      }\n      // Fall through to create new sentinel and rebuild\n    } else {\n      await onIsCached?.();\n      // Sentinel is recent and versions match, no need to rebuild\n      return;\n    }\n  } catch (err: any) {\n    if (err.code === 'ENOENT') {\n      // File doesn't exist, continue to create it\n    } else {\n      throw err; // unexpected FS error\n    }\n  }\n\n  try {\n    // Ensure the directory exists before writing the file\n    await mkdir(dirname(sentinelFilePath), { recursive: true });\n\n    // O_EXCL ensures only the *first* process can create the file\n    const data: SentinelData = {\n      version: packageJson.version,\n      timestamp: currentTimestamp,\n    };\n    await writeFile(sentinelFilePath, JSON.stringify(data), { flag: 'wx' });\n  } catch (err: any) {\n    if (err.code === 'EEXIST') {\n      // Another process already created it → we're done\n      return;\n    }\n    throw err; // unexpected FS error\n  }\n\n  await callback();\n};\n"],"mappings":";;;;;AAuBA,MAAM,2BAA2B,EAC/B,gBAAgB,KAAK,KACtB;;;;;;;;;;;;;;;;;;;;;;;AA6BD,MAAa,UAAU,OACrB,kBACA,UACA,YACG;CACH,MAAM,EAAE,YAAY,gBAAgB,aAAa;EAC/C,GAAG;EACH,GAAI,WAAW,EAAE;EAClB;CACD,MAAM,mBAAmB,KAAK,KAAK;AAEnC,KAAI;EAGF,MAAM,cAAc,oBADE,MAAM,KAAK,iBAAiB,EACG,MAAM,SAAS;EAGpE,IAAI,gBAAgB,QAAQ,SAAS,IAAI,cAAc;AAEvD,MAAI,CAAC,cACH,KAAI;GACF,MAAM,MAAM,MAAM,SAAS,kBAAkB,OAAO;GACpD,IAAIA;AACJ,OAAI;AAEF,oBADe,KAAK,MAAM,IAAI,CACP;WACjB;AAEN,oBAAgB;;AAGlB,OAAI,CAAC,iBAAiB,kBAAkB,YAAY,QAClD,iBAAgB;UAEZ;AAEN,mBAAgB;;AAIpB,MAAI,cACF,KAAI;AACF,SAAM,OAAO,iBAAiB;WACvBC,KAAU;AACjB,OAAI,IAAI,SAAS,SAAU,OAAM;;OAG9B;AACL,SAAM,cAAc;AAEpB;;UAEKA,KAAU;AACjB,MAAI,IAAI,SAAS,UAAU,OAGzB,OAAM;;AAIV,KAAI;AAEF,QAAM,MAAM,QAAQ,iBAAiB,EAAE,EAAE,WAAW,MAAM,CAAC;EAG3D,MAAMC,OAAqB;GACzB,SAAS,YAAY;GACrB,WAAW;GACZ;AACD,QAAM,UAAU,kBAAkB,KAAK,UAAU,KAAK,EAAE,EAAE,MAAM,MAAM,CAAC;UAChED,KAAU;AACjB,MAAI,IAAI,SAAS,SAEf;AAEF,QAAM;;AAGR,OAAM,UAAU"}