@design-edito/tools 0.3.0 → 1.0.1

package/agnostic/time/duration/index.js

@@ -1,112 +0,0 @@
-import "../../../chunks/chunk-XCBH6NLF.js";
-
-// src/agnostic/time/duration/index.ts
-var Duration = class {
-  value;
-  type;
-  /**
-   * Creates a new Duration instance.
-   *
-   * @param value - The numeric value of the duration.
-   * @param type - The unit of the duration, either long or short form.
-   */
-  constructor(value, type) {
-    this.toMilliseconds = this.toMilliseconds.bind(this);
-    this.toMs = this.toMs.bind(this);
-    this.toSeconds = this.toSeconds.bind(this);
-    this.toMinutes = this.toMinutes.bind(this);
-    this.toHours = this.toHours.bind(this);
-    this.toDays = this.toDays.bind(this);
-    this.toWeeks = this.toWeeks.bind(this);
-    this.toMonths = this.toMonths.bind(this);
-    this.toYear = this.toYear.bind(this);
-    this.value = value;
-    if (type === "ms" || type === "milliseconds") {
-      this.type = "milliseconds";
-    } else if (type === "s" || type === "sec" || type === "seconds") {
-      this.type = "seconds";
-    } else if (type === "m" || type === "min" || type === "minutes") {
-      this.type = "minutes";
-    } else if (type === "h" || type === "hours") {
-      this.type = "hours";
-    } else if (type === "d" || type === "days") {
-      this.type = "days";
-    } else if (type === "w" || type === "weeks") {
-      this.type = "weeks";
-    } else if (type === "mo" || type === "mth" || type === "months") {
-      this.type = "months";
-    } else if (type === "y" || type === "years") {
-      this.type = "years";
-    } else {
-      this.type = "milliseconds";
-    }
-  }
-  toMilliseconds = this.toMs;
-  toMs() {
-    if (this.type === "milliseconds") return this.value;
-    if (this.type === "seconds") return this.value * 1e3;
-    if (this.type === "minutes") return this.value * 1e3 * 60;
-    if (this.type === "hours") return this.value * 1e3 * 60 * 60;
-    if (this.type === "days") return this.value * 1e3 * 60 * 60 * 24;
-    if (this.type === "weeks") return this.value * 1e3 * 60 * 60 * 24 * 7;
-    if (this.type === "months") return this.value * 1e3 * 60 * 60 * 24 * 30;
-    if (this.type === "years") return this.value * 1e3 * 60 * 60 * 24 * 365;
-    return this.value;
-  }
-  toSeconds() {
-    return this.toMs() / 1e3;
-  }
-  toMinutes() {
-    return this.toMs() / (1e3 * 60);
-  }
-  toHours() {
-    return this.toMs() / (1e3 * 60 * 60);
-  }
-  toDays() {
-    return this.toMs() / (1e3 * 60 * 60 * 24);
-  }
-  toWeeks() {
-    return this.toMs() / (1e3 * 60 * 60 * 24 * 7);
-  }
-  toMonths() {
-    return this.toMs() / (1e3 * 60 * 60 * 24 * 30);
-  }
-  toYear() {
-    return this.toMs() / (1e3 * 60 * 60 * 24 * 365);
-  }
-};
-function milliseconds(value) {
-  return new Duration(value, "milliseconds");
-}
-function seconds(value) {
-  return new Duration(value, "seconds");
-}
-function minutes(value) {
-  return new Duration(value, "minutes");
-}
-function hours(value) {
-  return new Duration(value, "hours");
-}
-function days(value) {
-  return new Duration(value, "days");
-}
-function weeks(value) {
-  return new Duration(value, "weeks");
-}
-function months(value) {
-  return new Duration(value, "months");
-}
-function years(value) {
-  return new Duration(value, "years");
-}
-export {
-  Duration,
-  days,
-  hours,
-  milliseconds,
-  minutes,
-  months,
-  seconds,
-  weeks,
-  years
-};

package/agnostic/time/timeout/index.d.ts

@@ -1,9 +0,0 @@
-/**
- * Executes a callback and rejects if it does not complete within a specified timeout.
- *
- * @template T - The type of the callback's return value.
- * @param timeoutMs - Maximum time in milliseconds to wait for the callback to complete.
- * @param callback - The function to execute. Can be synchronous or return a promise.
- * @returns A promise that resolves with the callback result if completed in time, or rejects with `false` if timed out.
- */
-export declare function timeout<T>(timeoutMs: number, callback: () => T): Promise<T>;

package/agnostic/time/timeout/index.js

@@ -1,19 +0,0 @@
-import "../../../chunks/chunk-XCBH6NLF.js";
-
-// src/agnostic/time/timeout/index.ts
-function timeout(timeoutMs, callback) {
-  let hasRejected = false;
-  return new Promise(async (resolve, reject) => {
-    const rejectTimeout = setTimeout(() => {
-      reject(false);
-      hasRejected = true;
-    }, timeoutMs);
-    const callbackResult = await callback();
-    if (hasRejected) return;
-    clearTimeout(rejectTimeout);
-    return resolve(callbackResult);
-  });
-}
-export {
-  timeout
-};

package/agnostic/time/transitions/index.d.ts

@@ -1,74 +0,0 @@
-/**
- * Callback function invoked at each step of a transition.
- *
- * @param val - The current eased value of the transition.
- * @param timeMs - The timestamp (in milliseconds) when this step occurs.
- */
-export type Callback = (val: number, timeMs: number) => void;
-/**
- * Predefined easing function names for transitions.
- * Used to control the acceleration pattern of a transition.
- */
-export declare enum Ease {
-    LINEAR = "linear",
-    EASE_IN_QUAD = "ease-in-quad",
-    EASE_OUT_QUAD = "ease-out-quad",
-    EASE_IN_OUT_QUAD = "ease-in-out-quad",
-    EASE_IN_CUBIC = "ease-in-cubic",
-    EASE_OUT_CUBIC = "ease-out-cubic",
-    EASE_IN_OUT_CUBIC = "ease-in-out-cubic",
-    EASE_IN_QUART = "ease-in-quart",
-    EASE_OUT_QUART = "ease-out-quart",
-    EASE_IN_OUT_QUART = "ease-in-out-quart",
-    EASE_IN_QUINT = "ease-in-quint",
-    EASE_OUT_QUINT = "ease-out-quint",
-    EASE_IN_OUT_QUINT = "ease-in-out-quint",
-    EASE_IN_SINE = "ease-in-sine",
-    EASE_OUT_SINE = "ease-out-sine",
-    EASE_IN_OUT_SINE = "ease-in-out-sine",
-    EASE_IN_EXPO = "ease-in-expo",
-    EASE_OUT_EXPO = "ease-out-expo",
-    EASE_IN_OUT_EXPO = "ease-in-out-expo",
-    EASE_IN_CIRC = "ease-in-circ",
-    EASE_OUT_CIRC = "ease-out-circ",
-    EASE_IN_OUT_CIRC = "ease-in-out-circ",
-    EASE_IN_BACK = "ease-in-back",
-    EASE_OUT_BACK = "ease-out-back",
-    EASE_IN_OUT_BACK = "ease-in-out-back",
-    EASE_IN_ELASTIC = "ease-in-elastic",
-    EASE_OUT_ELASTIC = "ease-out-elastic",
-    EASE_IN_OUT_ELASTIC = "ease-in-out-elastic",
-    EASE_IN_BOUNCE = "ease-in-bounce",
-    EASE_OUT_BOUNCE = "ease-out-bounce",
-    EASE_IN_OUT_BOUNCE = "ease-in-out-bounce"
-}
-/**
- * A function that maps a progress value between 0 and 1 to an eased progress value.
- *
- * @param progress - Progress of the transition from 0 (start) to 1 (end).
- * @returns The eased progress value.
- */
-export type EasingFunction = (progress: number) => number;
-/**
- * Dictionary mapping string keys to easing functions.
- */
-export type EasingDictionary = Record<string, EasingFunction>;
-/**
- * Performs a numeric transition from 0 to `to` over `durationMs` milliseconds.
- * Invokes a callback at each step with the eased value and timestamp.
- *
- * @param to - The number of steps or increments for the transition.
- * @param durationMs - Total duration of the transition in milliseconds.
- * @param callbackOrEase - Either a callback function for each step or a predefined easing name.
- * @param callback - Optional callback if `callbackOrEase` is an easing name.
- * @returns A promise that resolves when the transition is complete.
- */
-export declare function transition(to: number, durationMs: number, callbackOrEase: Ease | Callback, callback?: Callback): Promise<void>;
-/**
- * Predefined easing functions used internally by transitions.
- */
-export declare const easingFunctions: EasingDictionary;
-/**
- * Mapping from `Ease` enum values to easing functions.
- */
-export declare const easings: Record<Ease, ((ratio: number) => number) | undefined>;

package/agnostic/time/transitions/index.js

@@ -1,161 +0,0 @@
-import {
-  wait
-} from "../../../chunks/chunk-4CIS3R7T.js";
-import "../../../chunks/chunk-XCBH6NLF.js";
-
-// src/agnostic/time/transitions/index.ts
-var Ease = /* @__PURE__ */ ((Ease2) => {
-  Ease2["LINEAR"] = "linear";
-  Ease2["EASE_IN_QUAD"] = "ease-in-quad";
-  Ease2["EASE_OUT_QUAD"] = "ease-out-quad";
-  Ease2["EASE_IN_OUT_QUAD"] = "ease-in-out-quad";
-  Ease2["EASE_IN_CUBIC"] = "ease-in-cubic";
-  Ease2["EASE_OUT_CUBIC"] = "ease-out-cubic";
-  Ease2["EASE_IN_OUT_CUBIC"] = "ease-in-out-cubic";
-  Ease2["EASE_IN_QUART"] = "ease-in-quart";
-  Ease2["EASE_OUT_QUART"] = "ease-out-quart";
-  Ease2["EASE_IN_OUT_QUART"] = "ease-in-out-quart";
-  Ease2["EASE_IN_QUINT"] = "ease-in-quint";
-  Ease2["EASE_OUT_QUINT"] = "ease-out-quint";
-  Ease2["EASE_IN_OUT_QUINT"] = "ease-in-out-quint";
-  Ease2["EASE_IN_SINE"] = "ease-in-sine";
-  Ease2["EASE_OUT_SINE"] = "ease-out-sine";
-  Ease2["EASE_IN_OUT_SINE"] = "ease-in-out-sine";
-  Ease2["EASE_IN_EXPO"] = "ease-in-expo";
-  Ease2["EASE_OUT_EXPO"] = "ease-out-expo";
-  Ease2["EASE_IN_OUT_EXPO"] = "ease-in-out-expo";
-  Ease2["EASE_IN_CIRC"] = "ease-in-circ";
-  Ease2["EASE_OUT_CIRC"] = "ease-out-circ";
-  Ease2["EASE_IN_OUT_CIRC"] = "ease-in-out-circ";
-  Ease2["EASE_IN_BACK"] = "ease-in-back";
-  Ease2["EASE_OUT_BACK"] = "ease-out-back";
-  Ease2["EASE_IN_OUT_BACK"] = "ease-in-out-back";
-  Ease2["EASE_IN_ELASTIC"] = "ease-in-elastic";
-  Ease2["EASE_OUT_ELASTIC"] = "ease-out-elastic";
-  Ease2["EASE_IN_OUT_ELASTIC"] = "ease-in-out-elastic";
-  Ease2["EASE_IN_BOUNCE"] = "ease-in-bounce";
-  Ease2["EASE_OUT_BOUNCE"] = "ease-out-bounce";
-  Ease2["EASE_IN_OUT_BOUNCE"] = "ease-in-out-bounce";
-  return Ease2;
-})(Ease || {});
-async function transition(to, durationMs, callbackOrEase, callback) {
-  const ease = typeof callbackOrEase === "string" ? callbackOrEase : "linear" /* LINEAR */;
-  const easing = easings[ease];
-  if (easing === void 0) return;
-  const actualCallback = callback ?? (typeof callbackOrEase === "function" ? callbackOrEase : void 0);
-  if (actualCallback === void 0) return;
-  const start = Date.now();
-  const timeTable = new Array(to).fill(null).map((_, step) => {
-    const progression = (step + 1) / to;
-    const eased = easing(progression);
-    const time = start + eased * durationMs;
-    return { time, step: eased * to };
-  });
-  for (const { time, step } of timeTable) {
-    const now = Date.now();
-    const delay = time - now;
-    if (delay <= 0) actualCallback(step, time);
-    else {
-      await wait(delay);
-      actualCallback(step, time);
-    }
-  }
-}
-var pow = Math.pow;
-var sqrt = Math.sqrt;
-var sin = Math.sin;
-var cos = Math.cos;
-var PI = Math.PI;
-var c1 = 1.70158;
-var c2 = c1 * 1.525;
-var c3 = c1 + 1;
-var c4 = 2 * PI / 3;
-var c5 = 2 * PI / 4.5;
-var bounceOut = function(x) {
-  const n1 = 7.5625;
-  const d1 = 2.75;
-  if (x < 1 / d1) return n1 * x * x;
-  if (x < 2 / d1) return n1 * (x -= 1.5 / d1) * x + 0.75;
-  if (x < 2.5 / d1) return n1 * (x -= 2.25 / d1) * x + 0.9375;
-  return n1 * (x -= 2.625 / d1) * x + 0.984375;
-};
-var easingFunctions = {
-  linear: (x) => x,
-  easeInQuad: (x) => x * x,
-  easeOutQuad: (x) => 1 - (1 - x) * (1 - x),
-  easeInOutQuad: (x) => x < 0.5 ? 2 * x * x : 1 - pow(-2 * x + 2, 2) / 2,
-  easeInCubic: (x) => x * x * x,
-  easeOutCubic: (x) => 1 - pow(1 - x, 3),
-  easeInOutCubic: (x) => x < 0.5 ? 4 * x * x * x : 1 - pow(-2 * x + 2, 3) / 2,
-  easeInQuart: (x) => x * x * x * x,
-  easeOutQuart: (x) => 1 - pow(1 - x, 4),
-  easeInOutQuart: (x) => x < 0.5 ? 8 * x * x * x * x : 1 - pow(-2 * x + 2, 4) / 2,
-  easeInQuint: (x) => x * x * x * x * x,
-  easeOutQuint: (x) => 1 - pow(1 - x, 5),
-  easeInOutQuint: (x) => x < 0.5 ? 16 * x * x * x * x * x : 1 - pow(-2 * x + 2, 5) / 2,
-  easeInSine: (x) => 1 - cos(x * PI / 2),
-  easeOutSine: (x) => sin(x * PI / 2),
-  easeInOutSine: (x) => -(cos(PI * x) - 1) / 2,
-  easeInExpo: (x) => x === 0 ? 0 : pow(2, 10 * x - 10),
-  easeOutExpo: (x) => x === 1 ? 1 : 1 - pow(2, -10 * x),
-  easeInOutExpo: (x) => {
-    return x === 0 ? 0 : x === 1 ? 1 : x < 0.5 ? pow(2, 20 * x - 10) / 2 : (2 - pow(2, -20 * x + 10)) / 2;
-  },
-  easeInCirc: (x) => 1 - sqrt(1 - pow(x, 2)),
-  easeOutCirc: (x) => sqrt(1 - pow(x - 1, 2)),
-  easeInOutCirc: (x) => x < 0.5 ? (1 - sqrt(1 - pow(2 * x, 2))) / 2 : (sqrt(1 - pow(-2 * x + 2, 2)) + 1) / 2,
-  easeInBack: (x) => c3 * x * x * x - c1 * x * x,
-  easeOutBack: (x) => 1 + c3 * pow(x - 1, 3) + c1 * pow(x - 1, 2),
-  easeInOutBack: (x) => x < 0.5 ? pow(2 * x, 2) * ((c2 + 1) * 2 * x - c2) / 2 : (pow(2 * x - 2, 2) * ((c2 + 1) * (x * 2 - 2) + c2) + 2) / 2,
-  easeInElastic: (x) => {
-    return x === 0 ? 0 : x === 1 ? 1 : -pow(2, 10 * x - 10) * sin((x * 10 - 10.75) * c4);
-  },
-  easeOutElastic: (x) => {
-    return x === 0 ? 0 : x === 1 ? 1 : pow(2, -10 * x) * sin((x * 10 - 0.75) * c4) + 1;
-  },
-  easeInOutElastic: (x) => {
-    return x === 0 ? 0 : x === 1 ? 1 : x < 0.5 ? -(pow(2, 20 * x - 10) * sin((20 * x - 11.125) * c5)) / 2 : pow(2, -20 * x + 10) * sin((20 * x - 11.125) * c5) / 2 + 1;
-  },
-  easeInBounce: (x) => 1 - bounceOut(1 - x),
-  easeOutBounce: bounceOut,
-  easeInOutBounce: (x) => x < 0.5 ? (1 - bounceOut(1 - 2 * x)) / 2 : (1 + bounceOut(2 * x - 1)) / 2
-};
-var easings = {
-  ["linear" /* LINEAR */]: easingFunctions.linear,
-  ["ease-in-quad" /* EASE_IN_QUAD */]: easingFunctions.easeInQuad,
-  ["ease-out-quad" /* EASE_OUT_QUAD */]: easingFunctions.easeOutQuad,
-  ["ease-in-out-quad" /* EASE_IN_OUT_QUAD */]: easingFunctions.easeInOutQuad,
-  ["ease-in-cubic" /* EASE_IN_CUBIC */]: easingFunctions.easeInCubic,
-  ["ease-out-cubic" /* EASE_OUT_CUBIC */]: easingFunctions.easeOutCubic,
-  ["ease-in-out-cubic" /* EASE_IN_OUT_CUBIC */]: easingFunctions.easeInOutCubic,
-  ["ease-in-quart" /* EASE_IN_QUART */]: easingFunctions.easeInQuart,
-  ["ease-out-quart" /* EASE_OUT_QUART */]: easingFunctions.easeOutQuart,
-  ["ease-in-out-quart" /* EASE_IN_OUT_QUART */]: easingFunctions.easeInOutQuart,
-  ["ease-in-quint" /* EASE_IN_QUINT */]: easingFunctions.easeInQuint,
-  ["ease-out-quint" /* EASE_OUT_QUINT */]: easingFunctions.easeOutQuint,
-  ["ease-in-out-quint" /* EASE_IN_OUT_QUINT */]: easingFunctions.easeInOutQuint,
-  ["ease-in-sine" /* EASE_IN_SINE */]: easingFunctions.easeInSine,
-  ["ease-out-sine" /* EASE_OUT_SINE */]: easingFunctions.easeOutSine,
-  ["ease-in-out-sine" /* EASE_IN_OUT_SINE */]: easingFunctions.easeInOutSine,
-  ["ease-in-expo" /* EASE_IN_EXPO */]: easingFunctions.easeInExpo,
-  ["ease-out-expo" /* EASE_OUT_EXPO */]: easingFunctions.easeOutExpo,
-  ["ease-in-out-expo" /* EASE_IN_OUT_EXPO */]: easingFunctions.easeInOutExpo,
-  ["ease-in-circ" /* EASE_IN_CIRC */]: easingFunctions.easeInCirc,
-  ["ease-out-circ" /* EASE_OUT_CIRC */]: easingFunctions.easeOutCirc,
-  ["ease-in-out-circ" /* EASE_IN_OUT_CIRC */]: easingFunctions.easeInOutCirc,
-  ["ease-in-back" /* EASE_IN_BACK */]: easingFunctions.easeInBack,
-  ["ease-out-back" /* EASE_OUT_BACK */]: easingFunctions.easeOutBack,
-  ["ease-in-out-back" /* EASE_IN_OUT_BACK */]: easingFunctions.easeInOutBack,
-  ["ease-in-elastic" /* EASE_IN_ELASTIC */]: easingFunctions.easeInElastic,
-  ["ease-out-elastic" /* EASE_OUT_ELASTIC */]: easingFunctions.easeOutElastic,
-  ["ease-in-out-elastic" /* EASE_IN_OUT_ELASTIC */]: easingFunctions.easeInOutElastic,
-  ["ease-in-bounce" /* EASE_IN_BOUNCE */]: easingFunctions.easeInBounce,
-  ["ease-out-bounce" /* EASE_OUT_BOUNCE */]: easingFunctions.easeOutBounce,
-  ["ease-in-out-bounce" /* EASE_IN_OUT_BOUNCE */]: easingFunctions.easeInOutBounce
-};
-export {
-  Ease,
-  easingFunctions,
-  easings,
-  transition
-};

package/agnostic/time/wait/index.d.ts

@@ -1,7 +0,0 @@
-/**
- * Returns a promise that resolves after the specified duration in milliseconds.
- *
- * @param durationMs - Time to wait in milliseconds.
- * @returns A promise that resolves to `true` after the delay.
- */
-export declare function wait(durationMs: number): Promise<unknown>;

package/agnostic/time/wait/index.js

@@ -1,7 +0,0 @@
-import {
-  wait
-} from "../../../chunks/chunk-4CIS3R7T.js";
-import "../../../chunks/chunk-XCBH6NLF.js";
-export {
-  wait
-};

package/agnostic/typescript/types.d.ts

@@ -1,37 +0,0 @@
-/**
- * Converts `undefined` to `null` in a type, while preserving other types.
- *
- * @template T - The type to transform
- * @returns If T extends `undefined`, returns `null`, otherwise returns T
- *
- * @example
- * ```ts
- * type Example1 = NullIfUndefined<string | undefined>; // string | null
- * type Example2 = NullIfUndefined<number>; // number
- * type Example3 = NullIfUndefined<undefined>; // null
- * ```
- */
-export type NullIfUndefined<T> = T extends undefined ? null : T;
-/**
- * Makes specific keys of a type required, while keeping other keys optional.
- *
- * @template T - The base type
- * @template K - The keys of T that should be required
- * @returns A new type where keys K are required and other keys remain as they were
- *
- * @example
- * ```ts
- * interface User {
- *   name?: string;
- *   age?: number;
- *   email?: string;
- * }
- *
- * type UserWithRequiredName = RequireKeys<User, 'name'>;
- * // { name: string; age?: number; email?: string; }
- *
- * type UserWithRequiredNameAndEmail = RequireKeys<User, 'name' | 'email'>;
- * // { name: string; age?: number; email: string; }
- * ```
- */
-export type RequireKeys<T, K extends keyof T> = Omit<T, K> & Required<Pick<T, K>>;

package/chunks/chunk-2WSVYQ5Q.js

@@ -1,77 +0,0 @@
-import {
-  makeFailure,
-  makeSuccess
-} from "./chunk-QEKI6WGQ.js";
-import {
-  unknownToString
-} from "./chunk-FENXVJYO.js";
-
-// src/node/@aws-s3/storage/directory/move-dir/index.ts
-import {
-  ListObjectsV2Command,
-  CopyObjectCommand,
-  DeleteObjectCommand,
-  HeadObjectCommand
-} from "@aws-sdk/client-s3";
-async function moveDir(client, bucketName, sourceDir, targetDir, options) {
-  const {
-    listObjectsOptions,
-    copyOptions,
-    deleteOptions,
-    overwrite = false
-  } = options ?? {};
-  const from = sourceDir.endsWith("/") ? sourceDir : `${sourceDir}/`;
-  const to = targetDir.endsWith("/") ? targetDir : `${targetDir}/`;
-  try {
-    let token;
-    do {
-      const listResp = await client.send(
-        new ListObjectsV2Command({
-          Bucket: bucketName,
-          Prefix: from,
-          ContinuationToken: token,
-          ...listObjectsOptions
-        })
-      );
-      for (const obj of listResp.Contents ?? []) {
-        if (!obj.Key) continue;
-        const rel = obj.Key.substring(from.length);
-        const dest = `${to}${rel}`;
-        if (!overwrite) {
-          try {
-            await client.send(
-              new HeadObjectCommand({ Bucket: bucketName, Key: dest })
-            );
-            throw new Error(`Object already exists at ${dest}.`);
-          } catch (err) {
-            if (err.$metadata?.httpStatusCode !== 404 && err.name !== "NotFound")
-              throw err;
-          }
-        }
-        await client.send(
-          new CopyObjectCommand({
-            Bucket: bucketName,
-            Key: dest,
-            CopySource: `${bucketName}/${obj.Key}`,
-            ...copyOptions
-          })
-        );
-        await client.send(
-          new DeleteObjectCommand({
-            Bucket: bucketName,
-            Key: obj.Key,
-            ...deleteOptions
-          })
-        );
-      }
-      token = listResp.IsTruncated ? listResp.NextContinuationToken : void 0;
-    } while (token);
-    return makeSuccess(true);
-  } catch (err) {
-    return makeFailure(unknownToString(err));
-  }
-}
-
-export {
-  moveDir
-};

package/chunks/chunk-33SNWUIB.js

@@ -1,103 +0,0 @@
-import {
-  isDuckTypedSharpInstance,
-  toSharpInstance
-} from "./chunk-P6K7NPUZ.js";
-import {
-  zod_default
-} from "./chunk-LFHDJTZJ.js";
-import {
-  makeFailure,
-  makeSuccess
-} from "./chunk-QEKI6WGQ.js";
-import {
-  isColor
-} from "./chunk-JDINERKY.js";
-
-// src/node/images/transform/operations/overlay/index.ts
-import sharp from "sharp";
-function isOverlayOperationParams(obj) {
-  const schema = zod_default.object({
-    input: zod_default.union([
-      zod_default.custom(isDuckTypedSharpInstance),
-      zod_default.custom(Buffer.isBuffer),
-      zod_default.string(),
-      zod_default.object({
-        width: zod_default.number().optional(),
-        height: zod_default.number().optional(),
-        channels: zod_default.union([zod_default.literal(3), zod_default.literal(4)]).optional(),
-        background: zod_default.custom(isColor).optional(),
-        noise: zod_default.object({
-          mean: zod_default.number().optional(),
-          sigma: zod_default.number().optional()
-        }).optional(),
-        pageHeight: zod_default.number().optional()
-      })
-    ]),
-    top: zod_default.number().optional(),
-    left: zod_default.number().optional(),
-    tile: zod_default.boolean().optional(),
-    premultiplied: zod_default.boolean().optional(),
-    density: zod_default.number().optional(),
-    animated: zod_default.boolean().optional(),
-    autoOrient: zod_default.boolean().optional(),
-    ignoreIcc: zod_default.boolean().optional(),
-    pages: zod_default.number().optional(),
-    page: zod_default.number().optional(),
-    blend: zod_default.enum([
-      "clear",
-      "source",
-      "over",
-      "in",
-      "out",
-      "atop",
-      "dest",
-      "dest-over",
-      "dest-in",
-      "dest-out",
-      "dest-atop",
-      "xor",
-      "add",
-      "saturate",
-      "multiply",
-      "screen",
-      "overlay",
-      "darken",
-      "lighten",
-      "color-dodge",
-      "colour-dodge",
-      "color-burn",
-      "colour-burn",
-      "hard-light",
-      "soft-light",
-      "difference",
-      "exclusion"
-    ]).optional(),
-    gravity: zod_default.enum([
-      "north",
-      "northeast",
-      "southeast",
-      "south",
-      "southwest",
-      "west",
-      "northwest",
-      "east",
-      "center",
-      "centre"
-    ]).optional()
-  });
-  const result = schema.safeParse(obj);
-  if (!result.success) return makeFailure(result.error.message);
-  return makeSuccess(result.data);
-}
-async function overlay(sharpInstance, params) {
-  const inputBuffer = params.input instanceof Buffer ? params.input : await (await toSharpInstance(params.input)).toBuffer();
-  return sharp(await sharpInstance.composite([{
-    ...params,
-    input: inputBuffer
-  }]).webp().toBuffer());
-}
-
-export {
-  isOverlayOperationParams,
-  overlay
-};

package/chunks/chunk-3MPXVP4L.js

@@ -1,25 +0,0 @@
-import {
-  get
-} from "./chunk-ROWPCMQY.js";
-
-// src/agnostic/html/get-node-ancestors/index.ts
-function getNodeAncestors(node, traverseShadowRoots) {
-  const returned = [];
-  let currentNode = node;
-  const { ShadowRoot } = get();
-  while (currentNode !== null) {
-    returned.push(currentNode);
-    const parentNode = currentNode.parentNode;
-    if (parentNode instanceof ShadowRoot) {
-      returned.push(parentNode);
-      currentNode = traverseShadowRoots ? parentNode.host : null;
-      continue;
-    }
-    currentNode = currentNode.parentElement;
-  }
-  return returned;
-}
-
-export {
-  getNodeAncestors
-};

package/chunks/chunk-4CIS3R7T.js

@@ -1,10 +0,0 @@
-// src/agnostic/time/wait/index.ts
-async function wait(durationMs) {
-  return new Promise((resolve) => {
-    setTimeout(() => resolve(true), durationMs);
-  });
-}
-
-export {
-  wait
-};

package/chunks/chunk-4WE2WEXL.js

@@ -1,12 +0,0 @@
-// node_modules/ansi-regex/index.js
-function ansiRegex({ onlyFirst = false } = {}) {
-  const ST = "(?:\\u0007|\\u001B\\u005C|\\u009C)";
-  const osc = `(?:\\u001B\\][\\s\\S]*?${ST})`;
-  const csi = "[\\u001B\\u009B][[\\]()#;?]*(?:\\d{1,4}(?:[;:]\\d{0,4})*)?[\\dA-PR-TZcf-nq-uy=><~]";
-  const pattern = `${osc}|${csi}`;
-  return new RegExp(pattern, onlyFirst ? void 0 : "g");
-}
-
-export {
-  ansiRegex
-};