@design-edito/tools 0.2.39 → 0.2.40

package/chunks/chunk-DKITT7OT.js

@@ -1,296 +0,0 @@
-import {
-  zod_default
-} from "./chunk-DZ2T5DTY.js";
-import {
-  toSharpColor,
-  toSharpInstance
-} from "./chunk-D5CCWCEI.js";
-import {
-  Outcome
-} from "./chunk-JMU5PDBD.js";
-import {
-  clamp
-} from "./chunk-OSAXBA7G.js";
-import {
-  isColor
-} from "./chunk-67V4BGOB.js";
-import {
-  __export
-} from "./chunk-WSFCRVEQ.js";
-
-// src/node/images/format/index.ts
-var format_exports = {};
-__export(format_exports, {
-  format: () => format,
-  isFormatAvifOptions: () => isFormatAvifOptions,
-  isFormatCommonOptions: () => isFormatCommonOptions,
-  isFormatHeifOptions: () => isFormatHeifOptions,
-  isFormatJpgOptions: () => isFormatJpgOptions,
-  isFormatOptions: () => isFormatOptions,
-  isFormatPngOptions: () => isFormatPngOptions,
-  isFormatTiffOptions: () => isFormatTiffOptions,
-  isFormatWebpOptions: () => isFormatWebpOptions,
-  toAvif: () => toAvif,
-  toHeif: () => toHeif,
-  toHeight: () => toHeight,
-  toJpg: () => toJpg,
-  toPng: () => toPng,
-  toSharpAvifOptions: () => toSharpAvifOptions,
-  toSharpHeifOptions: () => toSharpHeifOptions,
-  toSharpJpegOptions: () => toSharpJpegOptions,
-  toSharpPngOptions: () => toSharpPngOptions,
-  toSharpResizeOptions: () => toSharpResizeOptions,
-  toSharpTiffOptions: () => toSharpTiffOptions,
-  toSharpWebpOptions: () => toSharpWebpOptions,
-  toTiff: () => toTiff,
-  toWebp: () => toWebp,
-  toWidth: () => toWidth
-});
-var formatCommonOptionsSchema = zod_default.object({
-  width: zod_default.number().optional(),
-  height: zod_default.number().optional(),
-  fit: zod_default.enum(["contain", "cover", "fill", "inside", "outside"]).optional(),
-  position: zod_default.union([zod_default.number(), zod_default.string()]).optional(),
-  background: zod_default.custom(isColor).optional(),
-  kernel: zod_default.enum(["nearest", "cubic", "mitchell", "lanczos2", "lanczos3", "mks2013", "mks2021"]).optional(),
-  withoutEnlargement: zod_default.boolean().optional(),
-  withoutReduction: zod_default.boolean().optional(),
-  fastShrinkOnLoad: zod_default.boolean().optional()
-});
-var formatJpgOptionsSchema = formatCommonOptionsSchema.extend({
-  type: zod_default.union([zod_default.literal("jpg"), zod_default.literal("jpeg")]),
-  quality: zod_default.number().optional(),
-  force: zod_default.boolean().optional(),
-  progressive: zod_default.boolean().optional(),
-  chromaSubsampling: zod_default.string().optional(),
-  trellisQuantisation: zod_default.boolean().optional(),
-  overshootDeringing: zod_default.boolean().optional(),
-  optimizeScans: zod_default.boolean().optional(),
-  optimizeCoding: zod_default.boolean().optional(),
-  quantizationTable: zod_default.number().optional(),
-  mozjpeg: zod_default.boolean().optional()
-});
-var formatPngOptionsSchema = formatCommonOptionsSchema.extend({
-  type: zod_default.literal("png"),
-  quality: zod_default.number().optional(),
-  force: zod_default.boolean().optional(),
-  progressive: zod_default.boolean().optional(),
-  compressionLevel: zod_default.number().min(0).max(9).optional(),
-  adaptiveFiltering: zod_default.boolean().optional(),
-  effort: zod_default.number().min(1).max(10).optional(),
-  palette: zod_default.boolean().optional(),
-  colors: zod_default.number().min(1).max(256).optional(),
-  dither: zod_default.number().min(0).max(1).optional()
-});
-var formatWebpOptionsSchema = formatCommonOptionsSchema.extend({
-  type: zod_default.literal("webp"),
-  quality: zod_default.number().optional(),
-  force: zod_default.boolean().optional(),
-  alphaQuality: zod_default.number().optional(),
-  lossless: zod_default.boolean().optional(),
-  nearLossless: zod_default.boolean().optional(),
-  smartSubsample: zod_default.boolean().optional(),
-  smartDeblock: zod_default.boolean().optional(),
-  effort: zod_default.number().optional(),
-  minSize: zod_default.boolean().optional(),
-  mixed: zod_default.boolean().optional(),
-  preset: zod_default.enum(["default", "picture", "photo", "drawing", "icon", "text"]).optional(),
-  loop: zod_default.number().optional(),
-  delay: zod_default.union([zod_default.number(), zod_default.array(zod_default.number())]).optional()
-});
-var formatAvifOptionsSchema = formatCommonOptionsSchema.extend({
-  type: zod_default.literal("avif"),
-  quality: zod_default.number().optional(),
-  force: zod_default.boolean().optional(),
-  lossless: zod_default.boolean().optional(),
-  effort: zod_default.number().optional(),
-  chromaSubsampling: zod_default.string().optional(),
-  bitdepth: zod_default.union([zod_default.literal(8), zod_default.literal(10), zod_default.literal(12)]).optional()
-});
-var formatTiffOptionsSchema = formatCommonOptionsSchema.extend({
-  type: zod_default.literal("tiff"),
-  quality: zod_default.number().optional(),
-  compression: zod_default.enum(["none", "jpeg", "deflate", "packbits", "ccittfax4", "lzw", "webp", "zstd", "jp2k"]).optional(),
-  force: zod_default.boolean().optional(),
-  predictor: zod_default.enum(["none", "horizontal", "float"]).optional(),
-  pyramid: zod_default.boolean().optional(),
-  tile: zod_default.boolean().optional(),
-  tileWidth: zod_default.number().optional(),
-  tileHeight: zod_default.number().optional(),
-  xres: zod_default.number().optional(),
-  yres: zod_default.number().optional(),
-  bitdepth: zod_default.union([zod_default.literal(1), zod_default.literal(2), zod_default.literal(4), zod_default.literal(8)]).optional(),
-  miniswhite: zod_default.boolean().optional(),
-  resolutionUnit: zod_default.enum(["inch", "cm"]).optional()
-});
-var formatHeifOptionsSchema = formatCommonOptionsSchema.extend({
-  type: zod_default.literal("heif"),
-  quality: zod_default.number().optional(),
-  force: zod_default.boolean().optional(),
-  compression: zod_default.enum(["av1", "hevc"]).optional(),
-  lossless: zod_default.boolean().optional(),
-  effort: zod_default.number().optional(),
-  chromaSubsampling: zod_default.string().optional(),
-  bitdepth: zod_default.union([zod_default.literal(8), zod_default.literal(10), zod_default.literal(12)]).optional()
-});
-var formatKeepOptionsSchema = formatCommonOptionsSchema;
-var formatOptionsSchema = zod_default.union([
-  formatJpgOptionsSchema,
-  formatPngOptionsSchema,
-  formatWebpOptionsSchema,
-  formatAvifOptionsSchema,
-  formatTiffOptionsSchema,
-  formatHeifOptionsSchema,
-  formatKeepOptionsSchema
-]);
-var isFormatCommonOptions = (options) => formatCommonOptionsSchema.safeParse(options).success;
-var isFormatJpgOptions = (options) => formatJpgOptionsSchema.safeParse(options).success;
-var isFormatPngOptions = (options) => formatPngOptionsSchema.safeParse(options).success;
-var isFormatWebpOptions = (options) => formatWebpOptionsSchema.safeParse(options).success;
-var isFormatAvifOptions = (options) => formatAvifOptionsSchema.safeParse(options).success;
-var isFormatTiffOptions = (options) => formatTiffOptionsSchema.safeParse(options).success;
-var isFormatHeifOptions = (options) => formatHeifOptionsSchema.safeParse(options).success;
-var isFormatOptions = (options) => formatOptionsSchema.safeParse(options).success;
-var toSharpResizeOptions = (options) => {
-  return {
-    width: options.width,
-    height: options.height,
-    fit: options.fit,
-    position: options.position,
-    background: options.background ? toSharpColor(options.background) : void 0,
-    kernel: options.kernel,
-    withoutEnlargement: options.withoutEnlargement,
-    withoutReduction: options.withoutReduction,
-    fastShrinkOnLoad: options.fastShrinkOnLoad
-  };
-};
-var toSharpJpegOptions = (options) => {
-  return {
-    quality: options.quality,
-    force: options.force,
-    progressive: options.progressive,
-    chromaSubsampling: options.chromaSubsampling,
-    trellisQuantisation: options.trellisQuantisation,
-    overshootDeringing: options.overshootDeringing,
-    optimizeScans: options.optimizeScans,
-    optimizeCoding: options.optimizeCoding,
-    quantizationTable: options.quantizationTable,
-    mozjpeg: options.mozjpeg
-  };
-};
-var toSharpPngOptions = (options) => {
-  return {
-    quality: options.quality,
-    force: options.force,
-    progressive: options.progressive,
-    compressionLevel: options.compressionLevel,
-    adaptiveFiltering: options.adaptiveFiltering,
-    effort: options.effort,
-    palette: options.palette,
-    colors: options.colors,
-    dither: options.dither
-  };
-};
-var toSharpWebpOptions = (options) => {
-  return {
-    quality: options.quality,
-    loop: options.loop,
-    delay: options.delay,
-    force: options.force,
-    alphaQuality: options.alphaQuality,
-    lossless: options.lossless,
-    nearLossless: options.nearLossless,
-    smartSubsample: options.smartSubsample,
-    smartDeblock: options.smartDeblock,
-    effort: options.effort,
-    minSize: options.minSize,
-    mixed: options.mixed,
-    preset: options.preset
-  };
-};
-var toSharpAvifOptions = (options) => {
-  return {
-    force: options.force,
-    quality: options.quality,
-    lossless: options.lossless,
-    effort: options.effort,
-    chromaSubsampling: options.chromaSubsampling,
-    bitdepth: options.bitdepth
-  };
-};
-var toSharpTiffOptions = (options) => {
-  return {
-    force: options.force,
-    quality: options.quality,
-    compression: options.compression,
-    predictor: options.predictor,
-    pyramid: options.pyramid,
-    tile: options.tile,
-    tileWidth: options.tileWidth,
-    tileHeight: options.tileHeight,
-    xres: options.xres,
-    yres: options.yres,
-    bitdepth: options.bitdepth,
-    miniswhite: options.miniswhite,
-    resolutionUnit: options.resolutionUnit
-  };
-};
-var toSharpHeifOptions = (options) => {
-  return {
-    force: options.force,
-    quality: options.quality,
-    compression: options.compression,
-    lossless: options.lossless,
-    effort: options.effort,
-    chromaSubsampling: options.chromaSubsampling,
-    bitdepth: options.bitdepth
-  };
-};
-async function format(input, options) {
-  const sharpInstance = await toSharpInstance(input);
-  const resizeOptions = toSharpResizeOptions(options);
-  const resizedInstance = sharpInstance.resize(resizeOptions);
-  if (isFormatJpgOptions(options)) return Outcome.makeSuccess(await resizedInstance.jpeg(toSharpJpegOptions(options)).toBuffer());
-  if (isFormatPngOptions(options)) return Outcome.makeSuccess(await resizedInstance.png(toSharpPngOptions(options)).toBuffer());
-  if (isFormatWebpOptions(options)) return Outcome.makeSuccess(await resizedInstance.webp(toSharpWebpOptions(options)).toBuffer());
-  if (isFormatAvifOptions(options)) return Outcome.makeSuccess(await resizedInstance.avif(toSharpAvifOptions(options)).toBuffer());
-  if (isFormatTiffOptions(options)) return Outcome.makeSuccess(await resizedInstance.tiff(toSharpTiffOptions(options)).toBuffer());
-  if (isFormatHeifOptions(options)) return Outcome.makeSuccess(await resizedInstance.heif(toSharpHeifOptions(options)).toBuffer());
-  return Outcome.makeSuccess(await resizedInstance.toBuffer());
-}
-var toWidth = async (input, width) => (await toSharpInstance(input)).resize({ width }).toBuffer();
-var toHeight = async (input, height) => (await toSharpInstance(input)).resize({ height }).toBuffer();
-var toJpg = async (input, quality) => (await toSharpInstance(input)).jpeg({ quality: clamp(quality ?? 100, 1, 100) }).toBuffer();
-var toPng = async (input, quality, compressionLevel) => (await toSharpInstance(input)).png({ quality: clamp(quality ?? 100, 1, 100), compressionLevel }).toBuffer();
-var toWebp = async (input, quality) => (await toSharpInstance(input)).webp({ quality: clamp(quality ?? 100, 1, 100) }).toBuffer();
-var toAvif = async (input, quality) => (await toSharpInstance(input)).avif({ quality: clamp(quality ?? 100, 1, 100) }).toBuffer();
-var toTiff = async (input, quality, compression) => (await toSharpInstance(input)).tiff({ quality: clamp(quality ?? 100, 1, 100), compression }).toBuffer();
-var toHeif = async (input, quality) => (await toSharpInstance(input)).heif({ quality: clamp(quality ?? 100, 1, 100) }).toBuffer();
-
-export {
-  isFormatCommonOptions,
-  isFormatJpgOptions,
-  isFormatPngOptions,
-  isFormatWebpOptions,
-  isFormatAvifOptions,
-  isFormatTiffOptions,
-  isFormatHeifOptions,
-  isFormatOptions,
-  toSharpResizeOptions,
-  toSharpJpegOptions,
-  toSharpPngOptions,
-  toSharpWebpOptions,
-  toSharpAvifOptions,
-  toSharpTiffOptions,
-  toSharpHeifOptions,
-  format,
-  toWidth,
-  toHeight,
-  toJpg,
-  toPng,
-  toWebp,
-  toAvif,
-  toTiff,
-  toHeif,
-  format_exports
-};

package/chunks/chunk-EDVNAV3G.js

@@ -1,72 +0,0 @@
-// src/agnostic/css/generate-nice-color/index.ts
-var niceColors = [
-  "fuchsia",
-  "teal",
-  "aliceblue",
-  "bisque",
-  "blueviolet",
-  "burlywood",
-  "chocolate",
-  "coral",
-  "cornflowerblue",
-  "crimson",
-  "darkblue",
-  "darkgoldenrod",
-  "darkkhaki",
-  "darkmagenta",
-  "darkolivegreen",
-  "darkorange",
-  "darkorchid",
-  "darkred",
-  "darksalmon",
-  "darkslateblue",
-  "darkslategray",
-  "darkviolet",
-  "deeppink",
-  "deepskyblue",
-  "dodgerblue",
-  "firebrick",
-  "floralwhite",
-  "gainsboro",
-  "gold",
-  "hotpink",
-  "indianred",
-  "indigo",
-  "khaki",
-  "lavender",
-  "lightcoral",
-  "lightgreen",
-  "lightsalmon",
-  "lightsteelblue",
-  "limegreen",
-  "magenta",
-  "mediumseagreen",
-  "mediumspringgreen",
-  "mediumvioletred",
-  "moccasin",
-  "orangered",
-  "orchid",
-  "palegoldenrod",
-  "palevioletred",
-  "peachpuff",
-  "peru",
-  "plum",
-  "royalblue",
-  "sandybrown",
-  "springgreen",
-  "tan",
-  "thistle",
-  "tomato",
-  "violet",
-  "wheat",
-  "yellowgreen"
-];
-var generateNiceColor = () => {
-  const pos = Math.floor(Math.random() * niceColors.length);
-  return niceColors[pos];
-};
-
-export {
-  niceColors,
-  generateNiceColor
-};

package/chunks/chunk-EGBJXHCW.js

@@ -1,47 +0,0 @@
-import {
-  viaLab,
-  viaLch,
-  viaRgb
-} from "./chunk-FNQAF6CQ.js";
-import {
-  absoluteModulo
-} from "./chunk-DNIOWD7K.js";
-
-// src/agnostic/colors/invert/index.ts
-function invertRgb(color) {
-  return viaRgb(color, (rgb) => ({
-    ...rgb,
-    r: 255 - rgb.r,
-    g: 255 - rgb.g,
-    b: 255 - rgb.b
-  }));
-}
-function invertLab(color) {
-  return viaLab(color, (lab) => ({
-    ...lab,
-    l: 100 - lab.l,
-    a: -1 * lab.a,
-    b: -1 * lab.b
-  }));
-}
-function invertLch(color) {
-  return viaLch(color, (lch) => ({
-    ...lch,
-    l: 100 - lch.l,
-    h: absoluteModulo(lch.h + 180, 360)
-  }));
-}
-function invert(color, method = "lch") {
-  switch (method) {
-    case "rgb":
-      return invertRgb(color);
-    case "lab":
-      return invertLab(color);
-    case "lch":
-      return invertLch(color);
-  }
-}
-
-export {
-  invert
-};

package/chunks/chunk-EIIADR7E.js

@@ -1,24 +0,0 @@
-import {
-  file_exports
-} from "./chunk-PWNX5TWJ.js";
-import {
-  bucket_exports
-} from "./chunk-UXEKCYL7.js";
-import {
-  directory_exports
-} from "./chunk-26T64AEI.js";
-import {
-  __export
-} from "./chunk-WSFCRVEQ.js";
-
-// src/node/@google-cloud/storage/index.ts
-var storage_exports = {};
-__export(storage_exports, {
-  Bucket: () => bucket_exports,
-  Directory: () => directory_exports,
-  File: () => file_exports
-});
-
-export {
-  storage_exports
-};

package/chunks/chunk-ENMBK6H7.js

@@ -1,162 +0,0 @@
-import {
-  wait
-} from "./chunk-4CIS3R7T.js";
-
-// src/agnostic/time/transitions/index.ts
-var Transitions;
-((Transitions2) => {
-  let Ease;
-  ((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";
-  })(Ease = Transitions2.Ease || (Transitions2.Ease = {}));
-  async function transition(to, durationMs, callbackOrEase, callback) {
-    const ease = typeof callbackOrEase === "string" ? callbackOrEase : "linear" /* LINEAR */;
-    const easing = Transitions2.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);
-      }
-    }
-  }
-  Transitions2.transition = transition;
-  const pow = Math.pow;
-  const sqrt = Math.sqrt;
-  const sin = Math.sin;
-  const cos = Math.cos;
-  const PI = Math.PI;
-  const c1 = 1.70158;
-  const c2 = c1 * 1.525;
-  const c3 = c1 + 1;
-  const c4 = 2 * PI / 3;
-  const c5 = 2 * PI / 4.5;
-  const 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;
-  };
-  Transitions2.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
-  };
-  Transitions2.easings = {
-    ["linear" /* LINEAR */]: Transitions2.easingFunctions.linear,
-    ["ease-in-quad" /* EASE_IN_QUAD */]: Transitions2.easingFunctions.easeInQuad,
-    ["ease-out-quad" /* EASE_OUT_QUAD */]: Transitions2.easingFunctions.easeOutQuad,
-    ["ease-in-out-quad" /* EASE_IN_OUT_QUAD */]: Transitions2.easingFunctions.easeInOutQuad,
-    ["ease-in-cubic" /* EASE_IN_CUBIC */]: Transitions2.easingFunctions.easeInCubic,
-    ["ease-out-cubic" /* EASE_OUT_CUBIC */]: Transitions2.easingFunctions.easeOutCubic,
-    ["ease-in-out-cubic" /* EASE_IN_OUT_CUBIC */]: Transitions2.easingFunctions.easeInOutCubic,
-    ["ease-in-quart" /* EASE_IN_QUART */]: Transitions2.easingFunctions.easeInQuart,
-    ["ease-out-quart" /* EASE_OUT_QUART */]: Transitions2.easingFunctions.easeOutQuart,
-    ["ease-in-out-quart" /* EASE_IN_OUT_QUART */]: Transitions2.easingFunctions.easeInOutQuart,
-    ["ease-in-quint" /* EASE_IN_QUINT */]: Transitions2.easingFunctions.easeInQuint,
-    ["ease-out-quint" /* EASE_OUT_QUINT */]: Transitions2.easingFunctions.easeOutQuint,
-    ["ease-in-out-quint" /* EASE_IN_OUT_QUINT */]: Transitions2.easingFunctions.easeInOutQuint,
-    ["ease-in-sine" /* EASE_IN_SINE */]: Transitions2.easingFunctions.easeInSine,
-    ["ease-out-sine" /* EASE_OUT_SINE */]: Transitions2.easingFunctions.easeOutSine,
-    ["ease-in-out-sine" /* EASE_IN_OUT_SINE */]: Transitions2.easingFunctions.easeInOutSine,
-    ["ease-in-expo" /* EASE_IN_EXPO */]: Transitions2.easingFunctions.easeInExpo,
-    ["ease-out-expo" /* EASE_OUT_EXPO */]: Transitions2.easingFunctions.easeOutExpo,
-    ["ease-in-out-expo" /* EASE_IN_OUT_EXPO */]: Transitions2.easingFunctions.easeInOutExpo,
-    ["ease-in-circ" /* EASE_IN_CIRC */]: Transitions2.easingFunctions.easeInCirc,
-    ["ease-out-circ" /* EASE_OUT_CIRC */]: Transitions2.easingFunctions.easeOutCirc,
-    ["ease-in-out-circ" /* EASE_IN_OUT_CIRC */]: Transitions2.easingFunctions.easeInOutCirc,
-    ["ease-in-back" /* EASE_IN_BACK */]: Transitions2.easingFunctions.easeInBack,
-    ["ease-out-back" /* EASE_OUT_BACK */]: Transitions2.easingFunctions.easeOutBack,
-    ["ease-in-out-back" /* EASE_IN_OUT_BACK */]: Transitions2.easingFunctions.easeInOutBack,
-    ["ease-in-elastic" /* EASE_IN_ELASTIC */]: Transitions2.easingFunctions.easeInElastic,
-    ["ease-out-elastic" /* EASE_OUT_ELASTIC */]: Transitions2.easingFunctions.easeOutElastic,
-    ["ease-in-out-elastic" /* EASE_IN_OUT_ELASTIC */]: Transitions2.easingFunctions.easeInOutElastic,
-    ["ease-in-bounce" /* EASE_IN_BOUNCE */]: Transitions2.easingFunctions.easeInBounce,
-    ["ease-out-bounce" /* EASE_OUT_BOUNCE */]: Transitions2.easingFunctions.easeOutBounce,
-    ["ease-in-out-bounce" /* EASE_IN_OUT_BOUNCE */]: Transitions2.easingFunctions.easeInOutBounce
-  };
-})(Transitions || (Transitions = {}));
-
-export {
-  Transitions
-};

package/chunks/chunk-EUQFWLAH.js

@@ -1,20 +0,0 @@
-import {
-  file_exports
-} from "./chunk-536IRELM.js";
-import {
-  directory_exports
-} from "./chunk-N4JGLSGA.js";
-import {
-  __export
-} from "./chunk-WSFCRVEQ.js";
-
-// src/node/@aws-s3/storage/index.ts
-var storage_exports = {};
-__export(storage_exports, {
-  Directory: () => directory_exports,
-  File: () => file_exports
-});
-
-export {
-  storage_exports
-};